statement.c

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

    {
        /* 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
 * ------------------------------------------------------------------------ */

boolean OCI_Immediate(OCI_Connection *con, const mtext *sql, ...)
{
    OCI_Statement *stmt = NULL;
    boolean res = FALSE;
    va_list args;

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, sql, FALSE);

    /* First, execute SQL */

    stmt = OCI_StatementCreate(con);

    if ((stmt != NULL) &&OCI_ExecuteStmt(stmt, sql))
    {
        /* get resultset and set up variables */

        if (OCI_GetStatementType(stmt) == OCI_CST_SELECT)
        {
            va_start(args, sql);

            res = OCI_FetchIntoUserVariables(stmt, args);

            va_end(args);
        }

        OCI_StatementFree(stmt);
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_ImmediateFmt
 * ------------------------------------------------------------------------ */

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

    OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, FALSE);
    OCI_CHECK_PTR(OCI_IPC_STRING, sql, FALSE);

    stmt = OCI_StatementCreate(con);

    if (stmt != NULL)
    {
        /* 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));

                    /* get resultset and set up variables */

                    if (res && (OCI_GetStatementType(stmt) == OCI_CST_SELECT))
                    {
                        res = OCI_FetchIntoUserVariables(stmt, args);
                    }
                }

                va_end(args);

                OCI_FREE(sql_fmt);
            }
        }

        OCI_StatementFree(stmt);
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArraySetSize
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArraySetSize(OCI_Statement *stmt, unsigned int size)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    OCI_CHECK_MIN(stmt->con, stmt, size, 1, FALSE);

    OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_CLOSED, FALSE);

    /* if the statements already has binds, we need to check if the new size is
       not greater than the initial size
    */

    if ((stmt->nb_ubinds > 0) && (size > stmt->ubinds[0]->buf.count))
    {
        OCI_ExceptionBindArraySize(stmt, stmt->ubinds[0]->buf.count, 
                                         stmt->nb_iters, size);

        res = FALSE;
    }
    else
    {
        stmt->nb_iters   = size;
        stmt->bind_array = TRUE;
    }

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayGetSize
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_BindArrayGetSize(OCI_Statement *stmt)
{
    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    OCI_RESULT(TRUE);

    return stmt->nb_iters;
}

/* ------------------------------------------------------------------------ *
 * OCI_AllowRebinding
 * ------------------------------------------------------------------------ */

OCI_EXPORT boolean OCI_API OCI_AllowRebinding(OCI_Statement *stmt, boolean value)
{
    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    OCI_RESULT(TRUE);

    stmt->bind_reuse = value;

    return TRUE;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindShort
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindShort(OCI_Statement *stmt, const mtext *name, short *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_SHORT);

    return OCI_BindData(stmt, data, sizeof(short), name, OCI_CDT_NUMERIC,
                        SQLT_INT, OCI_BIND_INPUT, OCI_NUM_SHORT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfShorts
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfShorts(OCI_Statement *stmt, const mtext *name,
                                    short *data, unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_SHORT);

    return OCI_BindData(stmt, data, sizeof(short), name, OCI_CDT_NUMERIC,
                        SQLT_INT, OCI_BIND_INPUT, OCI_NUM_SHORT, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindUnsignedShort
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindUnsignedShort(OCI_Statement *stmt, const mtext *name,
                                    unsigned short *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_SHORT);

    return OCI_BindData(stmt, data, sizeof(unsigned short), name, OCI_CDT_NUMERIC,
                        SQLT_UIN, OCI_BIND_INPUT, OCI_NUM_USHORT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfUnsignedShorts
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfUnsignedShorts(OCI_Statement *stmt,
                                            const mtext *name,
                                            unsigned short *data,
                                            unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_SHORT);

    return OCI_BindData(stmt, data, sizeof(unsigned short), name, OCI_CDT_NUMERIC,
                        SQLT_UIN, OCI_BIND_INPUT, OCI_NUM_USHORT, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindInt(OCI_Statement *stmt, const mtext *name, int *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_INT);

    return OCI_BindData(stmt, data, sizeof(int), name, OCI_CDT_NUMERIC,
                        SQLT_INT, OCI_BIND_INPUT, OCI_NUM_INT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfInts
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfInts(OCI_Statement *stmt, const mtext *name,
                                    int *data, unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_INT);

   return OCI_BindData(stmt, data, sizeof(int), name, OCI_CDT_NUMERIC,
                       SQLT_INT, OCI_BIND_INPUT, OCI_NUM_INT, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindUnsignedInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindUnsignedInt(OCI_Statement *stmt, const mtext *name,
                                    unsigned int *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_INT);

    return OCI_BindData(stmt, data, sizeof(unsigned int), name, OCI_CDT_NUMERIC,
                        SQLT_UIN, OCI_BIND_INPUT, OCI_NUM_UINT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfUnsignedInts
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfUnsignedInts(OCI_Statement *stmt, const mtext *name,
                                            unsigned int *data, unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_INT);

    return OCI_BindData(stmt, data, sizeof(unsigned int), name, OCI_CDT_NUMERIC,
                        SQLT_UIN, OCI_BIND_INPUT, OCI_NUM_UINT, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindBigInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindBigInt(OCI_Statement *stmt, const mtext *name,
                               big_int *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_BIGINT);

    return OCI_BindData(stmt, data, sizeof(OCINumber), name, OCI_CDT_NUMERIC,
                        SQLT_VNU, OCI_BIND_INPUT, OCI_NUM_BIGINT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfBigInts
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfBigInts(OCI_Statement *stmt, const mtext *name,
                                       big_int *data, unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_BIGINT);

    return OCI_BindData(stmt, data, sizeof(OCINumber), name, OCI_CDT_NUMERIC,
                        SQLT_VNU, OCI_BIND_INPUT, OCI_NUM_BIGINT, NULL, nbelem);
}