statement.c

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

    OCI_CHECK_TIMESTAMP_ENABLED(stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    /* map oracle internal type */

    if (data->type == OCI_TIMESTAMP_TZ)
        code = SQLT_TIMESTAMP_TZ;
    else if (data->type == OCI_TIMESTAMP_LTZ)
        code = SQLT_TIMESTAMP_LTZ;
    else
        code = SQLT_TIMESTAMP;

    res = OCI_BindData(stmt, data, sizeof(OCIDateTime *), name, OCI_CDT_TIMESTAMP,
                       code, OCI_BIND_INPUT, data->type, NULL, 0);

#else

    OCI_NOT_USED(name);
    OCI_NOT_USED(code);
    OCI_NOT_USED(code);

#endif

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfTimestamps
 * ------------------------------------------------------------------------ */

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

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_TIMESTAMP);

    OCI_CHECK_TIMESTAMP_ENABLED(stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    /* map oracle internal type */

    if (type == OCI_TIMESTAMP_TZ)
        code = SQLT_TIMESTAMP_TZ;
    else if (type == OCI_TIMESTAMP_LTZ)
        code = SQLT_TIMESTAMP_LTZ;
    else
        code = SQLT_TIMESTAMP;

    res =  OCI_BindData(stmt, data, sizeof(OCIDateTime *), name, OCI_CDT_TIMESTAMP, 
                        code, OCI_BIND_INPUT, type, NULL, nbelem);

#else

    OCI_NOT_USED(name);
    OCI_NOT_USED(type);
    OCI_NOT_USED(code);

#endif

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindInterval
 * ------------------------------------------------------------------------ */

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

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_INTERVAL);

    OCI_CHECK_INTERVAL_ENABLED(stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    /* map oracle internal type */

    if (data->type == OCI_INTERVAL_YM)
        code = SQLT_INTERVAL_YM;
    else if (data->type == OCI_INTERVAL_DS)
        code = SQLT_INTERVAL_DS;

    res = OCI_BindData(stmt, data, sizeof(OCIInterval *), name, OCI_CDT_INTERVAL,
                       code, OCI_BIND_INPUT, data->type, NULL, 0);

#else

    OCI_NOT_USED(name);
    OCI_NOT_USED(code);

#endif

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfIntervals
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfIntervals(OCI_Statement *stmt, const mtext *name,
                                         OCI_Interval **data, 
                                         unsigned int type,
                                         unsigned int nbelem)
{
    unsigned int code = 0;
    boolean res       = FALSE;

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_INTERVAL);

    OCI_CHECK_INTERVAL_ENABLED(stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    /* map oracle internal type */

    if (type == OCI_INTERVAL_YM)
        code = SQLT_INTERVAL_YM;
    else if (type == OCI_INTERVAL_DS)
        code = SQLT_INTERVAL_DS;

    res = OCI_BindData(stmt, data, sizeof(OCIInterval *), name, OCI_CDT_INTERVAL, 
                       code, OCI_BIND_INPUT, type, NULL, nbelem);

#else

    OCI_NOT_USED(name);
    OCI_NOT_USED(type);
    OCI_NOT_USED(code);

#endif

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindObject
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindObject(OCI_Statement *stmt, const mtext *name,
                               OCI_Object *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_OBJECT);

    return OCI_BindData(stmt, data, sizeof(void*), name, OCI_CDT_OBJECT, 
                        SQLT_NTY, OCI_BIND_INPUT, 0, data->nty->tdo, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfObjects
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfObjects(OCI_Statement *stmt, const mtext *name,
                                       OCI_Object **data, OCI_Schema *schema,
                                       unsigned int nbelem)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_OBJECT);

    OCI_CHECK_PTR(OCI_IPC_SCHEMA, schema, FALSE);

    return OCI_BindData(stmt, data, sizeof(void *), name, OCI_CDT_OBJECT,
                        SQLT_NTY, OCI_BIND_INPUT, 0, schema->tdo, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindLob
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindLob(OCI_Statement *stmt, const mtext *name, 
                            OCI_Lob *data)
{
    int code = 0;
 
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_LOB);

    /* map oracle internal type */

    if (data->type == OCI_CLOB || data->type == OCI_NCLOB)
        code = SQLT_CLOB;
    else
        code = SQLT_BLOB;

    return OCI_BindData(stmt, data, sizeof(OCILobLocator*), name, OCI_CDT_LOB,
                        code, OCI_BIND_INPUT, data->type, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfLobs
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfLobs(OCI_Statement *stmt, const mtext *name,
                                    OCI_Lob **data, unsigned int type,
                                    unsigned int nbelem)
{
    unsigned int code = 0;

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_LOB);

    /* map oracle internal type */

    if (type == OCI_CLOB || type == OCI_NCLOB)
        code = SQLT_CLOB;
    else
        code = SQLT_BLOB;

    return OCI_BindData(stmt, data, sizeof(OCILobLocator*), name, OCI_CDT_LOB, 
                        code, OCI_BIND_INPUT, type, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindFile
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindFile(OCI_Statement *stmt, const mtext *name, 
                             OCI_File *data)
{
    int code = 0;

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_FILE);

    /* map oracle internal type */

    if (data->type == OCI_CFILE)
        code = SQLT_CFILE;
    else
        code = SQLT_BFILE;

    return OCI_BindData(stmt, data, sizeof(OCILobLocator*), name, OCI_CDT_FILE,
                        code, OCI_BIND_INPUT, data->type, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindArrayOfFiles
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindArrayOfFiles(OCI_Statement *stmt, const mtext *name,
                                     OCI_File **data, unsigned int type,
                                     unsigned int nbelem)
{
    unsigned int code = 0;

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_FILE);

    /* map oracle internal type */

    if (type == OCI_CFILE)
        code = SQLT_CFILE;
    else
        code = SQLT_BFILE;

    return OCI_BindData(stmt, data, sizeof(OCILobLocator*), name, OCI_CDT_FILE, 
                        code, OCI_BIND_INPUT, type, NULL, nbelem);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindColl
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindColl(OCI_Statement *stmt, const mtext *name,
                             OCI_Coll *data)
{
    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_COLLECTION);

    return OCI_BindData(stmt, &data->handle, sizeof(OCIColl*), name,
                        OCI_CDT_COLLECTION, SQLT_NTY, OCI_BIND_INPUT, 0, 
                        data->nty->tdo, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_BindStatement
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindStatement(OCI_Statement *stmt, const mtext *name,
                                  OCI_Statement *data)
{
    boolean res = FALSE;

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_STATEMENT);

    OCI_StatementReset(data);

    res = OCI_BindData(stmt, &data->stmt, sizeof(OCIStmt*), name, OCI_CDT_CURSOR,
                      SQLT_RSET, OCI_BIND_INPUT, 0, NULL, 0);
 
    if (res == TRUE)
    {
        /* Once stmt is exectuted, Oracle provides a statemment handle
           ready to be fetched  */

        data->status  = OCI_STMT_EXECUTED;
        data->type    = OCI_CST_SELECT;
    }

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_BindLong
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_BindLong(OCI_Statement *stmt, const mtext *name, 
                             OCI_Long *data, unsigned int size)
{
    int code = 0;

    OCI_CHECK_BIND_CALL(stmt, name, data, OCI_IPC_LONG);

    /* map oracle internal type */

    if (data->type == OCI_CLONG)
        code = SQLT_LNG;
    else
        code = SQLT_LBI;

    if (data->type == OCI_CLONG)
        size *= sizeof(dtext);

    return OCI_BindData(stmt, data, size, name, OCI_CDT_LONG,
                        code, OCI_BIND_INPUT, data->type, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_RegisterShort
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_RegisterShort(OCI_Statement *stmt, const mtext *name)
{
    OCI_CHECK_REGISTER_CALL(stmt, name);

    return OCI_BindData(stmt, NULL, sizeof(OCINumber), name, OCI_CDT_NUMERIC, 
                        SQLT_VNU, OCI_BIND_OUTPUT, OCI_NUM_SHORT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_RegisterUnsignedShort
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_RegisterUnsignedShort(OCI_Statement *stmt, const mtext *name)
{
    OCI_CHECK_REGISTER_CALL(stmt, name);

    return OCI_BindData(stmt, NULL, sizeof(OCINumber), name, OCI_CDT_NUMERIC, 
                        SQLT_VNU, OCI_BIND_OUTPUT, OCI_NUM_USHORT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_RegisterInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_RegisterInt(OCI_Statement *stmt, const mtext *name)
{
    OCI_CHECK_REGISTER_CALL(stmt, name);

    return OCI_BindData(stmt, NULL, sizeof(OCINumber), name, OCI_CDT_NUMERIC, 
                        SQLT_VNU, OCI_BIND_OUTPUT, OCI_NUM_INT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_RegisterUnsignedInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_RegisterUnsignedInt(OCI_Statement *stmt, const mtext *name)
{
    OCI_CHECK_REGISTER_CALL(stmt, name);

    return OCI_BindData(stmt, NULL, sizeof(OCINumber), name, OCI_CDT_NUMERIC,
                        SQLT_VNU, OCI_BIND_OUTPUT, OCI_NUM_UINT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_RegisterBigInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_RegisterBigInt(OCI_Statement *stmt, const mtext *name)
{
    OCI_CHECK_REGISTER_CALL(stmt, name);

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

/* ------------------------------------------------------------------------ *
 * OCI_RegisterUnsignedBigInt
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_RegisterUnsignedBigInt(OCI_Statement *stmt, const mtext *name)
{
    OCI_CHECK_REGISTER_CALL(stmt, name);

    return OCI_BindData(stmt, NULL, sizeof(OCINumber), name, OCI_CDT_NUMERIC, 
                        SQLT_VNU, OCI_BIND_OUTPUT, OCI_NUM_BIGUINT, NULL, 0);
}

/* ------------------------------------------------------------------------ *
 * OCI_RegisterString
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_RegisterString(OCI_Statement *stmt, const mtext *name, 
                                   unsigned int len)
{
    OCI_CHECK_REGISTER_CALL(stmt, name);

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

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

/*