statement.c

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

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)
{
    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);

    stmt->nb_iters = size;

    OCI_RESULT(TRUE);

    return TRUE;
}

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

/* ------------------------------------------------------------------------ *
 * OCI_BindUnsignedBigInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindUnsignedBigInt(OCI_Statement *stmt, const mtext *name,
                                      big_uint *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_BIGUINT, NULL, 0);
}

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

boolean OCI_API OCI_BindArrayOfUnsignedBigInts(OCI_Statement *stmt, 
                                               const mtext *name, 
                                               big_uint *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_BIGUINT, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindString
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindString(OCI_Statement *stmt, const mtext *name, 
                               dtext *data, unsigned int len)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_STRING);

    if (len == 0 || len == UINT_MAX)
        len = (int) dtslen(data);

    return OCI_BindData(stmt, data, (len + 1) * sizeof(odtext), name, OCI_CDT_TEXT, 
                        SQLT_STR, OCI_BIND_INPUT, 0, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfStrings
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfStrings(OCI_Statement *stmt, const mtext *name,
                                       dtext *data, unsigned int len, 
                                       unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_STRING);

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

    return OCI_BindData(stmt, data, (len + 1) * sizeof(odtext), name, OCI_CDT_TEXT,
                        SQLT_STR, OCI_BIND_INPUT, 0, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindRaw
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindRaw(OCI_Statement *stmt, const mtext *name, void *data,
                               unsigned int len)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_VOID);
    
    OCI_CHECK_MIN(stmt->con, stmt, len, 1, FALSE);

    return OCI_BindData(stmt, data, len, name, OCI_CDT_RAW, 
                        SQLT_BIN, OCI_BIND_INPUT, 0, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfRaws
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfRaws(OCI_Statement *stmt, const mtext *name,
                                       void  *data, unsigned int len, 
                                       unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_VOID);

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

    return OCI_BindData(stmt, data, len, name, OCI_CDT_RAW, 
                        SQLT_BIN, OCI_BIND_INPUT, 0, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindDouble
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindDouble(OCI_Statement *stmt, const mtext *name, 
                               double *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_DOUBLE);

    return OCI_BindData(stmt, data, sizeof(double), name, OCI_CDT_NUMERIC, 
                        SQLT_FLT, OCI_BIND_INPUT, 0, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfDoubles
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfDoubles(OCI_Statement *stmt, const mtext *name,
                                       double *data, unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_DOUBLE);

    return OCI_BindData(stmt, data, sizeof(double), name, OCI_CDT_NUMERIC, 
                        SQLT_FLT, OCI_BIND_INPUT, 0, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindDate
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindDate(OCI_Statement *stmt, const mtext *name, 
                             OCI_Date *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_DATE);

    return OCI_BindData(stmt, data, sizeof(OCIDate), name, OCI_CDT_DATETIME,
                        SQLT_ODT, OCI_BIND_INPUT, 0, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfDates
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfDates(OCI_Statement *stmt, const mtext *name,
                                     OCI_Date **data, unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_DATE);
    
    return OCI_BindData(stmt, data, sizeof(OCIDate), name, OCI_CDT_DATETIME, 
                        SQLT_ODT, OCI_BIND_INPUT, 0, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindTimestamp
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindTimestamp(OCI_Statement *stmt, const mtext *name,
                                  OCI_Timestamp *data)
{
    int code    = 0;
    boolean res = FALSE;

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_TIMESTAMP);