statement.c

oci的源码,可以在任何平台上编译,相当方便实用

                    break;
                }
                case OCI_ARG_TEXT:
                {
                    const dtext *src;
                    dtext *dst;

                    src = OCI_GetString(rs, i);
                    dst = va_arg(args, dtext *);

                    if (dst != NULL)
                        dst[0] = 0;

                    if (dst != NULL && src != NULL)
                        dtscat(dst, src);

                    break;
                }
                case OCI_ARG_RAW:
                {
                    OCI_GetRaw(rs, i, va_arg(args, dtext *), col->bufsize);
                    break;
                }
                case OCI_ARG_LOB:
                {
                    OCI_Lob *src, *dst;

                    src = OCI_GetLob(rs, i);
                    dst = (OCI_Lob *) va_arg(args, OCI_Lob *);

                    if (src != NULL && dst != NULL)
                        res = OCI_LobAssign(dst, src);

                    break;
                }
                case OCI_ARG_FILE:
                {
                    OCI_File *src, *dst;

                    src = OCI_GetFile(rs, i);
                    dst = (OCI_File *) va_arg(args, OCI_File *);

                    if (src != NULL && dst != NULL)
                        res = OCI_FileAssign(dst, src);

                    break;
                }
                case OCI_ARG_TIMESTAMP:
                {
                    OCI_Timestamp *src, *dst;

                    src = OCI_GetTimestamp(rs, i);
                    dst = (OCI_Timestamp *) va_arg(args, OCI_Timestamp *);

                    if (src != NULL && dst != NULL)
                        res = OCI_TimestampAssign(dst, src);

                    break;
                }
                case OCI_ARG_INTERVAL:
                {
                    OCI_Interval *src, *dst;

                    src = OCI_GetInterval(rs, i);
                    dst = (OCI_Interval *) va_arg(args, OCI_Interval *);

                    if (src != NULL && dst != NULL)
                        res =OCI_IntervalAssign(dst, src);

                    break;
                }
                default:
                {
                    OCI_ExceptionMappingArgument(stmt->con, stmt, type);

                    res = FALSE;

                    break;
                }
            }
        }
    }

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_StatementInit
 * ------------------------------------------------------------------------ */

OCI_Statement * OCI_StatementInit(OCI_Connection *con, OCI_Statement **pstmt,
                                  OCIStmt *handle, OCI_Define *def)
{
    OCI_Statement * stmt = NULL;
    boolean res = TRUE;

    OCI_CHECK(pstmt == NULL, NULL);

    if (*pstmt == NULL)
        *pstmt = (OCI_Statement *) OCI_MemAlloc(OCI_IPC_STATEMENT, sizeof(*stmt),
                                              1, TRUE);

    if (*pstmt != NULL)
    {
        stmt = *pstmt;

        stmt->con           = con;
        stmt->stmt          = handle;

        stmt->exec_mode     = OCI_DEFAULT;
        stmt->long_size     = OCI_SIZE_LONG;
        stmt->bind_reuse    = FALSE;
        stmt->bind_mode     = OCI_BIND_BY_NAME;
        stmt->long_mode     = OCI_LONG_EXPLICIT;

        /* reset statement */

        OCI_StatementReset(stmt);

        if (def == NULL)
        {
            /* allocate handle for non fetched lob (temporary lob) */

            stmt->hstate = OCI_OBJECT_ALLOCATED;

            /* allocate handle */

            res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) OCILib.env,
                                                  (dvoid **) (void *) &stmt->stmt,
                                                  (ub4) OCI_HTYPE_STMT,
                                                  (size_t) 0, (dvoid **) NULL));
        }
        else
        {
            stmt->hstate = OCI_OBJECT_FETCHED_CLEAN;
            stmt->status = OCI_STMT_EXECUTED;
            stmt->type   = OCI_CST_SELECT;

            /* not really perfect, but better than nothing */

            if (def->col.name != NULL)
                stmt->sql = mtsdup(def->col.name);
        }

        /* set statement default attributes */

        OCI_SetPrefetchSize(stmt, OCI_PREFETCH_SIZE);
        OCI_SetFetchSize(stmt, OCI_FETCH_SIZE);
    }

    /* check for failure */

    if (res == FALSE)
    {
        OCI_StatementFree(stmt);
        stmt = NULL;
    }

    return stmt;
}

/* ------------------------------------------------------------------------ *
 * OCI_StatementReset
 * ------------------------------------------------------------------------ */

boolean OCI_StatementReset(OCI_Statement *stmt)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    /* free resultsets */

    res = OCI_ReleaseResultsets(stmt);

    /* free in/out binds */

    res = OCI_BindFreeAll(stmt);

    /* free bind map */

    if (stmt->map != NULL)
    {
        OCI_HashFree(stmt->map);
    }

    /* free sql statement */

    OCI_FREE(stmt->sql);

    stmt->rsts        = NULL;
    stmt->sql         = NULL;
    stmt->map         = NULL;

    stmt->status      = OCI_STMT_CLOSED;
    stmt->type        = OCI_UNKNOWN;
    stmt->bind_array  = FALSE;

    stmt->nb_iters     = 1;
    stmt->dynidx       = 0;
    stmt->err_pos      = 0;

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_StatementClose
 * ------------------------------------------------------------------------ */

boolean OCI_StatementClose(OCI_Statement *stmt)
{
    boolean res    = TRUE;
    OCI_Error *err = NULL;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    /* clear statement reference from current error object */

    err = OCI_ErrorGet(FALSE);

    if (err != NULL && err->stmt == stmt)
        err->stmt = NULL;

    /* reset data */

    res = OCI_StatementReset(stmt);

    if (stmt->stmt != NULL && stmt->hstate == OCI_OBJECT_ALLOCATED)
    {
        OCI_HandleFree((dvoid *) stmt->stmt, (ub4) OCI_HTYPE_STMT);
    }

    return res;
}

/* ************************************************************************ *
 *                            PUBLIC FUNCTIONS
 * ************************************************************************ */

/* ------------------------------------------------------------------------ *
 * OCI_StatementCreate
 * ------------------------------------------------------------------------ */

OCI_Statement * OCI_API OCI_StatementCreate(OCI_Connection *con)
{
    OCI_Statement *stmt = NULL;
    OCI_Item *item      = NULL;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);

    /* create statement object */

    item = OCI_ListAppend(con->stmts, sizeof(*stmt));

    if (item != NULL)
    {
        stmt = OCI_StatementInit(con, (OCI_Statement **) &item->data, NULL, FALSE);
    }

    OCI_RESULT(stmt != NULL);

    return stmt;
}

/* ------------------------------------------------------------------------ *
 * OCI_StatementFree
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_StatementFree(OCI_Statement *stmt)
{
    boolean res = FALSE;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    OCI_CHECK_OBJECT_FETCHED(stmt, FALSE);

    res = OCI_StatementClose(stmt);

    OCI_ListRemove(stmt->con->stmts, stmt);

    OCI_FREE(stmt);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ReleaseResultsets
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ReleaseResultsets(OCI_Statement *stmt)
{
    boolean res   = TRUE;
    ub4 i, nb_err = 0;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    if (stmt->rsts != NULL)
    {
        for (i = 0; i  < stmt->nb_rs; i++)
        {
            if (stmt->rsts[i] != NULL)
            {
                if (FALSE == OCI_ResultsetFree(stmt->rsts[i]))
                    nb_err++;
            }
        }

        OCI_FREE(stmt->rsts);
    }

    res = (nb_err == 0);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_Prepare
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_Prepare(OCI_Statement *stmt, const mtext *sql)
{
    boolean res = TRUE;
    void *ostr  = NULL;
    int  osize  = -1;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, sql, FALSE);

    /* reset statement */

    res = OCI_StatementReset(stmt);

    if (res == TRUE)
    {
        /* store SQL */

        stmt->sql = mtsdup(sql);

        ostr = OCI_GetInputMetaString(stmt->sql, &osize);

        /* prepare SQL */

        OCI_CALL1
        (
            res, stmt->con, stmt,

            OCIStmtPrepare(stmt->stmt,stmt->con->err, (OraText *) ostr,
                           (ub4) osize, (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT)
        )

        OCI_ReleaseMetaString(ostr);

        /* get statement type */

        OCI_CALL1
        (
            res, stmt->con, stmt,

            OCIAttrGet((dvoid *) stmt->stmt, (ub4) OCI_HTYPE_STMT,
                       (dvoid *) &stmt->type, (ub4 *) NULL,
                       (ub4) OCI_ATTR_STMT_TYPE, stmt->con->err)
        )
    }

    /* update statement status */

    if (res == TRUE)
        stmt->status = OCI_STMT_PREPARED;

    OCI_RESULT(res);

   return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_Execute
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_Execute(OCI_Statement *stmt)
{
    boolean res   = TRUE;
    sword status  = OCI_SUCCESS;
    ub4 iters     = 0;
    ub4 mode      = OCI_DEFAULT;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);
    OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_CLOSED, FALSE);

    /* set up iters and mode values for execution */

    if (stmt->type == OCI_CST_SELECT)
        mode  = stmt->exec_mode;
    else
        iters = stmt->nb_iters;

    /* check bind objects for updating their null indicator status */

    res = OCI_BindCheck(stmt);

    /* free previous resulsets in case of re-execution of the same SQL order */

   if (res == TRUE)
       res = OCI_ReleaseResultsets(stmt);

    /* Oracle execute call */

    status = OCIStmtExecute(stmt->con->cxt, stmt->stmt, stmt->con->err, iters,
                            (ub4) 0, (OCISnapshot *) NULL, (OCISnapshot *) NULL,
                            mode);

    /* reset input binds indicators status even if execution failed */

    OCI_BindReset(stmt);

    /* check result */

    res = ((status == OCI_SUCCESS) || (status == OCI_NEED_DATA));

    /* update status on success */

    if (res == TRUE)
    {
        stmt->status = OCI_STMT_EXECUTED;

        /* commit if necessary */

        if (stmt->con->autocom == TRUE)
            OCI_Commit(stmt->con);
    }
    else