resultset.c

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

    else
        res = FALSE;

    OCI_RESULT(res);

    return (rs->eof == FALSE);         
}

/* ------------------------------------------------------------------------ *
 * OCI_FetchFirst
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_FetchFirst(OCI_Resultset *rs)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
  
    OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
    OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);

    rs->bof       = FALSE;
    rs->eof       = FALSE;

    rs->row_abs   = 1;
    rs->row_cur   = 1;

    res = OCI_FetchData(rs, OCI_SFD_FIRST, 0);

    OCI_RESULT(res);

    return (rs->bof == FALSE);  
}

/* ------------------------------------------------------------------------ *
 * OCI_FetchLast
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_FetchLast(OCI_Resultset *rs)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
  
    OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
    OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);

    rs->bof       = FALSE;
    rs->eof       = FALSE;

    rs->row_abs   = 0;
    rs->row_cur   = 1;

    res = OCI_FetchData(rs, OCI_SFD_LAST, 0);

    rs->row_abs = rs->row_count;

    OCI_RESULT(res);

    return (rs->eof != TRUE);  
}

/* ------------------------------------------------------------------------ *
 * OCI_FetchSeek
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_FetchSeek(OCI_Resultset *rs, unsigned int mode, int offset)
{
    boolean res = TRUE;

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
  
    OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
    OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);

    res = OCI_FetchCustom(rs, mode, offset);

    OCI_RESULT(res);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetRowCount
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetRowCount(OCI_Resultset *rs)
{
    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);

    OCI_RESULT(TRUE);

    return rs->row_count;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetRowCount
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetCurrentRow(OCI_Resultset *rs)
{
    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);

    OCI_RESULT(TRUE);

    return rs->row_abs;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetColumnCount
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetColumnCount(OCI_Resultset *rs)
{
    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);

    OCI_RESULT(TRUE);

    return rs->nb_defs;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetColumn
 * ------------------------------------------------------------------------ */

OCI_Column * OCI_API OCI_GetColumn(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def = NULL;
    OCI_Column *col = NULL;

    def = OCI_GetDefine(rs, index);

    if (def != NULL)
        col = &def->col;

    OCI_RESULT(col != NULL);

    return col;

}

/* ------------------------------------------------------------------------ *
 * OCI_GetColumn2
 * ------------------------------------------------------------------------ */

OCI_Column * OCI_API OCI_GetColumn2(OCI_Resultset *rs, const mtext *name)
{
    OCI_Define *def = NULL;
    OCI_Column *col = NULL;

    def = OCI_GetDefine(rs, OCI_GetDefineIndex(rs, name));

    if (def != NULL)
        col = &def->col;

    OCI_RESULT(col != NULL);

    return col;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetColumnIndex
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetColumnIndex(OCI_Resultset *rs, const mtext *name)
{
   unsigned int index = OCI_GetDefineIndex(rs, name);

   OCI_RESULT(index >= 1);

   return index;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetShort
 * ------------------------------------------------------------------------ */

short OCI_API OCI_GetShort(OCI_Resultset *rs, unsigned int index)
{
    short value = 0;

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

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetShort2
 * ------------------------------------------------------------------------ */

short OCI_API OCI_GetShort2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetShort(rs, OCI_GetDefineIndex(rs, name));
}
    
/* ------------------------------------------------------------------------ *
 * OCI_GetUnsignedShort
 * ------------------------------------------------------------------------ */

unsigned short OCI_API OCI_GetUnsignedShort(OCI_Resultset *rs, unsigned int index)
{
    unsigned short value = 0;

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

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetUnsignedShort2
 * ------------------------------------------------------------------------ */

unsigned short OCI_API OCI_GetUnsignedShort2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetUnsignedShort(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetInt
 * ------------------------------------------------------------------------ */

int OCI_API OCI_GetInt(OCI_Resultset *rs, unsigned int index)
{
    int value = 0;

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

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetInt2
 * ------------------------------------------------------------------------ */

int OCI_API OCI_GetInt2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetInt(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetUnsignedInt
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetUnsignedInt(OCI_Resultset *rs, unsigned int index)
{
    unsigned int value = 0;

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

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetUnsignedInt2
 * ------------------------------------------------------------------------ */

unsigned int OCI_API OCI_GetUnsignedInt2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetUnsignedInt(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetBigInt
 * ------------------------------------------------------------------------ */

big_int OCI_API OCI_GetBigInt(OCI_Resultset *rs, unsigned int index)
{
    big_int value = 0;

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

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetBigInt2
 * ------------------------------------------------------------------------ */

big_int OCI_API OCI_GetBigInt2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetBigInt(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetUnsignedBigInt
 * ------------------------------------------------------------------------ */

big_uint OCI_API OCI_GetUnsignedBigInt(OCI_Resultset *rs, unsigned int index)
{
    big_uint value = 0;

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

    return value;
}

/* ------------------------------------------------------------------------ *
 * OCI_GetUnsignedInt2
 * ------------------------------------------------------------------------ */

big_uint OCI_API OCI_GetUnsignedBigInt2(OCI_Resultset *rs, const mtext *name)
{
    return OCI_GetUnsignedBigInt(rs, OCI_GetDefineIndex(rs, name));
}

/* ------------------------------------------------------------------------ *
 * OCI_GetString
 * ------------------------------------------------------------------------ */

const dtext * OCI_API OCI_GetString(OCI_Resultset *rs, unsigned int index)
{
    OCI_Define *def  = OCI_GetDefine(rs, index);
    dtext *str       = NULL;  
    boolean res      = TRUE;

    res = (def != NULL);

    if ((res == TRUE) && (OCI_NOT_NULL(def) == TRUE))
    {
        void *data   = OCI_DefineGetData(def);

        if (def->col.type == OCI_CDT_TEXT)
        {
            str = (dtext *) data;

            /* for long mapped to string, the zero ternimal character is not 
               always added by Oracle ? or OCILIB issue ? Anyway we check the
               length returned by Oracle et set it properly */

            if (def->col.subtype == OCI_CLONG)
            {
                ub2* lens = (ub2 *) def->buf.lens;

                str[lens[rs->row_cur-1] / sizeof(dtext)] = 0; 
            }
        }
        else
        {
            /* tries an implicit conversion if possible */

            if (def->buf.temp == NULL)
            {
                def->buf.temp = (dtext *) OCI_MemAlloc(OCI_IPC_STRING, 
                                                       sizeof(dtext),
                                                       (OCI_SIZE_BUFFER+1), 
                                                       FALSE);

                res = (def->buf.temp != NULL);
            }
            
            if (res == TRUE)
            {
                def->buf.temp[0] = 0;

                switch (def->col.type)
                {
                    case OCI_CDT_NUMERIC:
                    {
                        mtext *buf  = NULL;
                        void *ostr1 = NULL;
                        void *ostr2 = NULL;
                        int  osize1 = OCI_SIZE_FORMAT_NUML * sizeof(mtext);
                        int  osize2 = OCI_SIZE_BUFFER      * sizeof(mtext);
                        const mtext *fmt;

#ifdef OCI_CHARSET_MIXED

                        mtext temp[OCI_SIZE_BUFFER+1];

                        temp[0] = 0;

                        buf = temp;
#else
                        buf = def->buf.temp; 
#endif

                        /* init output buffer in case of OCI failure */
                     
                        buf[0] = 0;

                        fmt = OCI_GetDefaultFormatNumeric(rs->stmt->con);

                        ostr1 = OCI_GetInputMetaString(fmt, &osize1);
                        ostr2 = OCI_GetInputDataString(buf, &osize2);

                        /* check for decimal character */

                        OCI_CALL1
                        (
                            res, rs->stmt->con, rs->stmt,

                            OCINumberToText(rs->stmt->con->err, 
                                            (OCINumber *) data,
                                            (oratext *) ostr1,
                                            (ub4) osize1,
                                            (oratext *) NULL, 
                                            (ub4) 0,
                                            (ub4 *) &osize2, 
                                            (oratext *) ostr2)
                        )

                        OCI_GetOutputDataString(ostr2, buf, &osize2);

                        /* do we need to suppress last '.' or ',' from integers */

                        if ((buf[osize2-1] == DT('.')) ||
                            (buf[osize2-1] == DT(',')))
                        {
                            buf[osize2-1] = 0;
                        }

                        OCI_ReleaseMetaString(ostr1);
                        OCI_ReleaseDataString(ostr2);

#ifdef OCI_CHARSET_MIXED

                        mbstowcs(def->buf.temp, temp, strlen(temp) + OCI_CVT_CHAR);

 #endif
                        if (res == TRUE)
                            str = def->buf.temp;

                        break;
                    }
                    case OCI_CDT_DATETIME:
                    {
                        OCI_Date *date   = OCI_GetDate(rs, index);
                        const mtext *fmt = OCI_GetDefaultFormatDate(rs->stmt->con); 

                        if (date != NULL)
                        {
#ifndef OCI_CHARSET_MIXED
                             res = OCI_DateToText(date, fmt, OCI_SIZE_BUFFER, 
                                                  (mtext *) def->buf.temp);
#else

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

                            mtext temp[OCI_SIZE_BUFFER+1];

                            temp[0] = 0;

                            res = OCI_DateToText(date, fmt, OCI_SIZE_BUFFER, temp);

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

                            str = def->buf.temp;
                        }

                        break;
                    }
                    case OCI_CDT_TIMESTAMP:
                    {
                        OCI_Timestamp *tmsp = OCI_GetTimestamp(rs, index);
                        const mtext *fmt    = OCI_GetDefaultFormatDate(rs->stmt->con); 

                        if (tmsp != NULL)
                        {
#ifndef OCI_CHARSET_MIXED

                            OCI_TimestampToText(tmsp, fmt, OCI_SIZE_BUFFER,
                                                (mtext *) def->buf.temp,  0);
#else

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

                            mtext temp[OCI_SIZE_BUFFER+1];