resultset.c

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

                            temp[0] = 0;

                            OCI_TimestampToText(tmsp, fmt, OCI_SIZE_BUFFER,
                                                (mtext *) temp, 0);

                            mbstowcs(def->buf.temp, temp, strlen(temp) + OCI_CVT_CHAR);
         #endif
                            str = def->buf.temp;
                        }

                        break;
                    }
                    case OCI_CDT_INTERVAL:
                    {
                         OCI_Interval *itv = OCI_GetInterval(rs, index);

                         if (itv != NULL)
                         {
#ifndef OCI_CHARSET_MIXED
                             OCI_IntervalToText(OCI_GetInterval(rs, index),                            
                                                OCI_STRING_DEFAULT_PREC,
                                                OCI_STRING_DEFAULT_PREC,
                                                OCI_SIZE_BUFFER, 
                                                (mtext *) def->buf.temp);
#else

                            /* mixed mode... hum conversion needed ! */

                            mtext temp[OCI_SIZE_BUFFER+1];

                            temp[0] = 0;

                            OCI_IntervalToText(OCI_GetInterval(rs, index),                                      
                                               OCI_STRING_DEFAULT_PREC,
                                               OCI_STRING_DEFAULT_PREC,
                                               OCI_SIZE_BUFFER, (mtext *) temp);
                            
                            mbstowcs(def->buf.temp, temp, strlen(temp) + OCI_CVT_CHAR);
 #endif
                           str = def->buf.temp;
                        }

                        break;
                    }
                    case OCI_CDT_LONG:
                    {
                        OCI_Long *lg = OCI_GetLong(rs, index);

                        if (lg != NULL)
                            str = OCI_LongGetBuffer(lg);

                        break;

                    }
                    case OCI_CDT_RAW:
                    {
                        str = (dtext *) data;

                        break;

                    }
                    case OCI_CDT_LOB:
                    {
                        OCI_Lob *lob = OCI_GetLob(rs, index);
                        unsigned int len = 0;

                        len = OCI_LobRead(lob, def->buf.temp, OCI_SIZE_BUFFER);

                        def->buf.temp[len] = 0;

                        OCI_LobSeek(lob, 0, OCI_SEEK_SET);

                        str = def->buf.temp;

                        break;

                    }
                    case OCI_CDT_FILE:
                    {
                        OCI_File *file = OCI_GetFile(rs, index);
                        unsigned int len = 0;

                        len = OCI_FileRead(file, def->buf.temp, OCI_SIZE_BUFFER);

                        def->buf.temp[len] = 0;
            
                        OCI_FileSeek(file, 0, OCI_SEEK_SET);

                        str = def->buf.temp;

                        break;

                    }
                   default:
                    {
                        res = FALSE;
                    }
                }
            }
        }
    }

    OCI_RESULT(res);

    return str;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetString2
 * ------------------------------------------------------------------------ */

const dtext * OCI_API OCI_GetString2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetString(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetRaw
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetRaw(OCI_Resultset *rs, unsigned int index,
                                void *buffer, unsigned int len)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    boolean res     = TRUE;
    ub4 count       = len;

    OCI_CHECK_PTR(OCI_IPC_VOID, buffer, 0);

    res = (def != NULL);

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_RAW))
    {
        if (count > def->col.size)
            count = def->col.size;

        /* for RAWs, we copy the data in the destination buffer instead of 
           returning internal buffer as we do for strings */

        memcpy(buffer, OCI_DefineGetData(def), count);

    }

    OCI_RESULT(res);

    if (res == FALSE)
        count  = 0;

    return count;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetRaw2
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetRaw2(OCI_Resultset *rs, const mtext *name, 
                                 void *buffer, unsigned int len)
{
    return OCI_GetRaw(rs, OCI_GetDefineIndex(rs, name), buffer, len);
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDouble
 * ------------------------------------------------------------------------ */

double OCI_API OCI_GetDouble(OCI_Resultset *rs, unsigned int index)
{
    double value = 0.0;

    OCI_DefineGetNumber(rs, index, &value, OCI_NUM_DOUBLE, sizeof(value));

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDouble2
 * ------------------------------------------------------------------------ */

double OCI_API OCI_GetDouble2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetDouble(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDate
 * ------------------------------------------------------------------------ */

OCI_Date * OCI_API OCI_GetDate(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    OCI_Date *date  = NULL;
    
    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_DATETIME))
    {
         date =  OCI_DateInit(rs->stmt->con,
                             (OCI_Date **) &def->obj,
                             (OCIDate *) OCI_DefineGetData(def), FALSE,
                             (def->col.icode == SQLT_DAT));
    }

    OCI_RESULT(date != NULL);

    return date;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDate2
 * ------------------------------------------------------------------------ */

OCI_Date * OCI_API OCI_GetDate2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetDate(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetTimestamp
 * ------------------------------------------------------------------------ */

OCI_Timestamp * OCI_API OCI_GetTimestamp(OCI_Resultset *rs, unsigned int index)
{ 
    OCI_Define *def     = OCI_GetDefine(rs, index);
    OCI_Timestamp *tmsp = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_TIMESTAMP))
    {
        tmsp =  OCI_TimestampInit(rs->stmt->con,
                                  (OCI_Timestamp **) &def->obj,
                                  (OCIDateTime *) OCI_DefineGetData(def),
                                  def->col.subtype);
    }

    OCI_RESULT(tmsp != NULL);

    return tmsp;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetTimestamp2
 * ------------------------------------------------------------------------ */

OCI_Timestamp * OCI_API OCI_GetTimestamp2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetTimestamp(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetInterval
 * ------------------------------------------------------------------------ */

OCI_Interval * OCI_API OCI_GetInterval(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def   = OCI_GetDefine(rs, index);
    OCI_Interval *itv = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_INTERVAL))
    {
        itv = OCI_IntervalInit(rs->stmt->con,
                               (OCI_Interval **) &def->obj,
                               (OCIInterval *) OCI_DefineGetData(def),
                               def->col.subtype);
    }

    OCI_RESULT(itv != NULL);

    return itv;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetInterval2
 * ------------------------------------------------------------------------ */

OCI_Interval * OCI_API OCI_GetInterval2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetInterval(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_Object
 * ------------------------------------------------------------------------ */

OCI_Object * OCI_API OCI_GetObject(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    OCI_Object *obj =  NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.ocode == SQLT_NTY))
    {
        obj =  OCI_ObjectInit(rs->stmt->con,
                              (OCI_Object **) &def->obj,
                              OCI_DefineGetData(def), def->col.nty);
    }

    OCI_RESULT(obj != NULL);

    return obj;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetObject2
 * ------------------------------------------------------------------------ */

OCI_Object * OCI_API OCI_GetObject2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetObject(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetColl
 * ------------------------------------------------------------------------ */

OCI_Coll * OCI_API OCI_GetColl(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    OCI_Coll *coll  = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.ocode == SQLT_NTY) && 
        ( def->col.nty->ccode != 0))
    {
            coll = OCI_CollInit(rs->stmt->con, (OCI_Coll **) &def->obj,
                                OCI_DefineGetData(def), def->col.nty);
    }

    OCI_RESULT(coll != NULL);

    return coll;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetColl2
 * ------------------------------------------------------------------------ */

OCI_Coll * OCI_API OCI_GetColl2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetColl(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetStatement
 * ------------------------------------------------------------------------ */

OCI_Statement * OCI_API OCI_GetStatement(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def   = OCI_GetDefine(rs, index);
    OCI_Statement *st = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_CURSOR))
    {
        st = OCI_StatementInit(rs->stmt->con,
                               (OCI_Statement **) &def->obj,
                               (OCIStmt *) OCI_DefineGetData(def), def);
    }

    OCI_RESULT(st != NULL);

    return st;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetStatement2
 * ------------------------------------------------------------------------ */

OCI_Statement * OCI_API OCI_GetStatement2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetStatement(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetLob
 * ------------------------------------------------------------------------ */

OCI_Lob * OCI_API OCI_GetLob(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    OCI_Lob * lob   = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_LOB))
    {
        lob =  OCI_LobInit(rs->stmt->con,(OCI_Lob **) &def->obj,
                           (OCILobLocator *) OCI_DefineGetData(def),
                           def->col.subtype);
    }

    OCI_RESULT(lob != NULL);

    return lob;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetLob2
 * ------------------------------------------------------------------------ */

OCI_Lob * OCI_API OCI_GetLob2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetLob(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetFile
 * ------------------------------------------------------------------------ */

OCI_File * OCI_API OCI_GetFile(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    OCI_File *file  = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_FILE))
    {
        file = OCI_FileInit(rs->stmt->con,(OCI_File **) &def->obj,
                            (OCILobLocator *) OCI_DefineGetData(def),
                            def->col.subtype);
    }

    OCI_RESULT(file != NULL);

    return file;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetFile2
 * ------------------------------------------------------------------------ */

OCI_File * OCI_API OCI_GetFile2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetFile(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetLong
 * ------------------------------------------------------------------------ */

OCI_Long * OCI_API OCI_GetLong(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    OCI_Long *lg    = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_LONG))
    {
        lg = (OCI_Long *) OCI_DefineGetData(def);
    }

    OCI_RESULT(lg != NULL);

    return lg;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetLong2
 * ------------------------------------------------------------------------ */

OCI_Long * OCI_API OCI_GetLong2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetLong(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_IsNull
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_IsNull(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);

    OCI_RESULT(def != NULL);

    return (OCI_NOT_NULL(def) == FALSE);
}