resultset.c

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

           returning internal buffer as we do for strings */

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

    }

    OCI_RESULT(res);

    if (res == FALSE)
        count  = 0;

    return (unsigned int) 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.type == OCI_CDT_OBJECT))
    {
        obj =  OCI_ObjectInit(rs->stmt->con,
                              (OCI_Object **) &def->obj,
                              OCI_DefineGetData(def), def->col.typinf, NULL, -1,
                              TRUE);
    }

    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.type == OCI_CDT_COLLECTION))
    {
            coll = OCI_CollInit(rs->stmt->con, (OCI_Coll **) &def->obj,
                                OCI_DefineGetData(def), def->col.typinf);
    }

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

OCI_Ref * OCI_API OCI_GetRef(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = OCI_GetDefine(rs, index);
    OCI_Ref    *ref = NULL;

    if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_REF))
    {
            ref = OCI_RefInit(rs->stmt->con, def->col.typinf,
                              (OCI_Ref **) &def->obj, OCI_DefineGetData(def));

            /* if the ref object is retrieved from a register bind that has 
               no type info object associated, the type info object is retrieved
               at the first fetch call by pinning the ref and we affect the type 
               info object handle to the define object */

            if ((def->col.typinf == NULL) && (ref != NULL) && (ref->typinf != NULL))
            {
                def->col.typinf = ref->typinf;
            }
    }

    OCI_RESULT(ref != NULL);

    return ref;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetRef2
 * ------------------------------------------------------------------------ */

OCI_Ref * OCI_API OCI_GetRef2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetRef(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);
}

/* ------------------------------------------------------------------------ *
 * OCI_IsNull2
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_IsNull2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_IsNull(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_ResultsetGetStatment
 * ------------------------------------------------------------------------ */

OCI_Statement * OCI_API OCI_ResultsetGetStatement(OCI_Resultset *rs)
{
    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

    OCI_RESULT(TRUE);

    return rs->stmt;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetDataLength
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetDataLength(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def     = OCI_GetDefine(rs, index);
    unsigned int length = 0;
    boolean res         = FALSE;

    if ((def != NULL) && (rs->row_cur > 0)) 
    {
        length = (unsigned int) ((ub2 *) def->buf.lens)[rs->row_cur-1];
        res    = TRUE;
    }

    OCI_RESULT(res);

    return length;
}