resultset.c

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

/* ------------------------------------------------------------------------ *
 * OCI_FetchPrev
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_FetchPrev(OCI_Resultset *rs)
{
    boolean res = TRUE;
    boolean err = FALSE;

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

    OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);

    if (rs->bof == FALSE)
    {
        if (rs->row_cur == 1)
        {
            if (rs->row_abs == 1)
            {
                rs->bof = TRUE;
            }
            else
            {
                int offset = 0;
                
                if (rs->fetch_size > rs->row_abs)
                    offset = 1 - rs->row_abs;  
                else
                    offset = 1 - (rs->fetch_size + rs->row_fetched);

                res = OCI_FetchData(rs, OCI_SFD_RELATIVE, offset, &err);

                if (res == TRUE)
                {
                    if (rs->fetch_size > rs->row_abs)
                        rs->row_cur = rs->row_abs-1;
                    else
                        rs->row_cur = rs->fetch_size;

                    rs->row_abs--;
                }
            }
        }
        else
        {
            rs->row_cur--;
            rs->row_abs--;
        }

        rs->eof = FALSE;

        res = ((res == TRUE) && (rs->bof == FALSE));
    }
    else
        res = FALSE;

#else

    res = FALSE;

#endif

    OCI_RESULT(err);

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_FetchNext
 * ------------------------------------------------------------------------ */

boolean OCI_API OCI_FetchNext(OCI_Resultset *rs)
{
    boolean res = TRUE;
    boolean err = FALSE;

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

    if (rs->eof == FALSE)
    {
        if (rs->stmt->nb_rbinds == 0)
        {
            /* for regular resultsets */

            if ((rs->row_cur == rs->row_fetched))
            {
                if (rs->fetch_status == OCI_NO_DATA)
                {
                    rs->eof = TRUE;
                }
                else
                {
                    res = OCI_FetchData(rs, OCI_SFD_NEXT, 0, &err);

                    if (res == TRUE)
                    {
                        rs->bof     = FALSE;
                        rs->row_cur = 1;

                        rs->row_abs++;
                    }
                }
            }
            else
            {
                rs->row_cur++;
                rs->row_abs++;
            }
        }
        else
        {
            /* for resultset from returning into clause */

            if (rs->row_abs == 0)
            {
                /* check string buffer once for Unicode build */

            #ifdef OCI_CHECK_DATASTRINGS

                OCI_ResultsetExpandStrings(rs);

            #endif

            }

            if (rs->row_abs >= rs->row_count)
            {
                rs->eof = TRUE;
            }
            else
            {
                rs->row_cur++;
                rs->row_abs++;
            }
        }
    }
    else
        res = FALSE;

    OCI_RESULT(err);

    return ((res == TRUE) && (rs->eof == FALSE));
}

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

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

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

    OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    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, &err);

#else

    res = FALSE;
    err = TRUE;

#endif

    OCI_RESULT(err);

    return ((res == TRUE) && (rs->bof == FALSE));
}

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

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

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

    OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    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, &err);

    rs->row_abs = rs->row_count;

#else

    res = FALSE;
    err = TRUE;

#endif

    OCI_RESULT(err);

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

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

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

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

    OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);

#if OCI_VERSION_COMPILE >= OCI_9

    OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);

    res = OCI_FetchCustom(rs, mode, offset, &err);

#else

    OCI_NOT_USED(mode);
    OCI_NOT_USED(offset);

    res = FALSE;
    err = TRUE;

#endif

    OCI_RESULT(err);

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