statement.c

ORACLE编程的好东西,纯C写的OCI封装.很好用,支持数据池.

        }

        /* 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);

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

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

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

    /* free sql statement */

    OCI_FREE(stmt->sql);

    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;

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

    /* get the iter value for execution */

    iters =  (ub4) ((stmt->type == OCI_CST_SELECT) ? 0 : 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,
                            (ub4) stmt->exec_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
    {
        /* get parse error position type */

        /* (one of the rare OCI call not enclosed with a OCI_CALLX macro ...) */

            
        OCIAttrGet((dvoid *) stmt->stmt, (ub4) OCI_HTYPE_STMT,
                   (dvoid *) &stmt->err_pos, (ub4 *) NULL,
                   (ub4) OCI_ATTR_PARSE_ERROR_OFFSET, stmt->con->err);

        /* raise exception */

        OCI_ExceptionOCI(stmt->con->err, stmt->con, stmt); 
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ExecuteStmt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_ExecuteStmt(OCI_Statement *stmt, const mtext *sql)
{
    return (OCI_Prepare(stmt, sql) && OCI_Execute(stmt));
}

/* ------------------------------------------------------------------------ *
 * OCI_PrepareFmt
 * ------------------------------------------------------------------------ */

boolean OCI_PrepareFmt(OCI_Statement *stmt, const mtext *sql, ...)
{
    boolean res    = FALSE;
    mtext *sql_fmt = NULL;
    va_list args;
    int size;

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

    /* first, get buffer size */

    va_start(args, sql);

    size = OCI_ParseSqlFmt(stmt, NULL, sql, &args);

    va_end(args);

    if (size > 0)
    {
        /* allocate buffer */

        sql_fmt = (mtext *) OCI_MemAlloc(OCI_IPC_STRING, sizeof(mtext), (size+1),
                                         TRUE);

        if (sql_fmt != NULL)
        {
            /* format buffer */

            va_start(args, sql);

            if (OCI_ParseSqlFmt(stmt, sql_fmt, sql, &args) > 0)
            {
               /* parse buffer */

               res = OCI_Prepare(stmt, sql_fmt);
            }

            va_end(args);

            OCI_FREE(sql_fmt);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ExecuteStmtFmt
 * ------------------------------------------------------------------------ */

boolean OCI_ExecuteStmtFmt(OCI_Statement *stmt, const mtext *sql, ...)
{
    boolean res    = FALSE;
    mtext *sql_fmt = NULL;
    va_list args;
    int size;

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

    /* first, get buffer size */

    va_start(args, sql);

    size = OCI_ParseSqlFmt(stmt, NULL, sql, &args);

    va_end(args);

    if (size > 0)
    {
        /* allocate buffer */

        sql_fmt = (mtext *) OCI_MemAlloc(OCI_IPC_STRING, sizeof(mtext), (size+1),
                                         TRUE);

        if (sql_fmt != NULL)
        {
            /* format buffer */

            va_start(args, sql);

            if (OCI_ParseSqlFmt(stmt, sql_fmt, sql, &args) > 0)
            {
                /* prepare and execute SQL buffer */

                res = (OCI_Prepare(stmt, sql_fmt) &&  OCI_Execute(stmt));
            }

            va_end(args);

            OCI_FREE(sql_fmt);
        }
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_Immediate
 * ------------------------------------------------------------------------ */