resultset.c

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

            (
                res, rs->stmt->con, rs->stmt,
                
                OCIAttrGet((dvoid *) rs->stmt->stmt, (ub4) OCI_HTYPE_STMT, 
                           (dvoid *) &row_fetched, (ub4 *) NULL,
                           (ub4) OCI_ATTR_ROWS_FETCHED, rs->stmt->con->err)
            )
        }
        else
#endif
        {
            row_count   = OCI_GetAffectedRows(rs->stmt);
            row_fetched = row_count - rs->row_count;

        }

        if (rs->row_count < row_count)
            rs->row_count = row_count;

        if (row_fetched > 0)
            rs->row_fetched = row_fetched;

        if ((rs->fetch_status == OCI_NO_DATA) && (row_fetched == 0))  
        {
            if ((mode == OCI_SFD_NEXT) || (offset > 0))
                rs->eof = TRUE;

            if (offset < 0)
                rs->bof = TRUE;

            res = FALSE;
        }
    }
    else
        res = FALSE;

    return res;
}

/* ------------------------------------------------------------------------ *
 * OCI_FetchCustom
 * ------------------------------------------------------------------------ */

boolean OCI_FetchCustom(OCI_Resultset *rs, int mode, int offset)
{ 
    boolean res = TRUE;

    switch (mode)
    {
        case OCI_SFD_RELATIVE:
        {
            int offset_save = 0;

            if (((offset > 0) && (rs->eof == TRUE)) ||
                ((offset < 0) && (rs->bof == TRUE)) ||
                (offset == 0))
            {
                res = FALSE;
            }
            else
            {
                offset_save = offset;
                offset      = offset - rs->row_fetched + rs->row_cur;
                rs->row_cur = 1;   

                res = OCI_FetchData(rs, mode, offset);

                if (res == TRUE)
                    rs->row_abs += offset_save;
            }

            break;
       }
        case OCI_SFD_ABSOLUTE:
        {
            if (offset == 0)
            {
                res = FALSE;
            }
            else
            {
                rs->row_abs   = 1;
                rs->row_cur   = 1;         

                res = OCI_FetchData(rs, mode, offset);

                if (res == TRUE)
                {
                    rs->row_abs = offset;

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

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

    return res;
}

#ifdef OCI_CHECK_DATASTRINGS 

/* ------------------------------------------------------------------------ *
 * OCI_ResultsetExpandStrings
 * ------------------------------------------------------------------------ */

boolean OCI_ResultsetExpandStrings(OCI_Resultset *rs)
{
    int i, j;

    OCI_CHECK(rs == NULL, FALSE)

    for (i = 0; i < rs->nb_defs; i++)
    {
        OCI_Define *def = &rs->defs[i];

        if (def->col.type == OCI_CDT_TEXT)
        {
            for (j = (def->buf.count-1); j >= 0; j--)
            {
                OCI_ConvertString(((ub1*) def->buf.data) + (def->col.bufsize * j),
                                  def->col.bufsize / sizeof(dtext),
                                  sizeof(odtext), sizeof(dtext));
            }
        }
    }

    return TRUE;
}

#endif

/* ************************************************************************ *
 *                            PUBLIC FUNCTIONS
 * ************************************************************************ */

/* ------------------------------------------------------------------------ *
 * OCI_GetResultset
 * ------------------------------------------------------------------------ */

OCI_Resultset * OCI_API OCI_GetResultset(OCI_Statement *stmt)
{
    OCI_Resultset *rs = NULL;
    boolean res       = TRUE;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, NULL);

    OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_CLOSED, FALSE);
    OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_PREPARED, FALSE);

    /* if the sql statement does not return a result, we just return NULL and not 
       throwing any exception */

    if ((stmt->type != OCI_CST_SELECT) || (stmt->nb_outbinds == 0))
    {
        /* if the resultset exists, let's use it */

        if ((stmt->rsts != NULL) && (stmt->rsts[0] != NULL))
        {
            rs = stmt->rsts[0];
        }

        /* allocate resultset for select statements */

        if ((rs == NULL)  && (stmt->type == OCI_CST_SELECT))
        {
            /* allocate memory for one resultset handle */

            stmt->rsts = (OCI_Resultset **) OCI_MemAlloc(OCI_IPC_RESULTSET_ARRAY, 
                                                         sizeof(*stmt->rsts),
                                                         1, TRUE); 
            if (stmt->rsts != NULL)
            {
                stmt->nb_rs   = 1;
                stmt->cur_rs  = 0;
               
                /* create resultset object */

                rs = OCI_ResultsetCreate(stmt, stmt->fetch_size);

                if (rs != NULL)
                    stmt->rsts[0] = rs;
                else
                    res = FALSE;
            }
            else
                res = FALSE;
        }
    }

    OCI_RESULT(res);

    return rs;
}

/* ------------------------------------------------------------------------ v*
 * OCI_GetNextResultset
 * ------------------------------------------------------------------------ */

OCI_Resultset * OCI_API OCI_GetNextResultset(OCI_Statement *stmt)
{
    OCI_Resultset *rs = NULL;

    OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, FALSE);

    if (stmt->cur_rs < (stmt->nb_rs-1))
        rs = stmt->rsts[++stmt->cur_rs];
    
    OCI_RESULT(TRUE);

    return rs;
}

/* ------------------------------------------------------------------------ *
 * OCI_ResultsetFree
 * ------------------------------------------------------------------------ */

boolean OCI_ResultsetFree(OCI_Resultset *rs)
{
    boolean res = TRUE;
    ub4 i, j;

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

    for (i = 0; i < rs->nb_defs; i++)
    {
        OCI_Define *def = &(rs->defs[i]);

        /* free buffer objects */

        if (def->obj != NULL)
        {
            /* handy cast to set object state flag */

           ((OCI_Datatype *) def->obj)->hstate = OCI_OBJECT_FETCHED_DIRTY;

           switch (def->col.type)
            {
                case OCI_CDT_DATETIME:

                    OCI_DateFree((OCI_Date *) def->obj);
                    break;

                case OCI_CDT_LOB:

                    OCI_LobFree((OCI_Lob *) def->obj);
                    break;

               case OCI_CDT_FILE:

                    OCI_FileFree((OCI_File *) def->obj);
                    break;

               case OCI_CDT_CURSOR:

                    OCI_StatementClose((OCI_Statement *) def->obj);
                    OCI_FREE(def->obj);
                    break;

              case OCI_CDT_OBJECT:

                    OCI_ObjectFree((OCI_Object *) def->obj);
                    break;

              case OCI_CDT_COLLECTION:

                    OCI_CollFree((OCI_Coll *) def->obj);
                    break;

               case OCI_CDT_TIMESTAMP:

                    OCI_TimestampFree((OCI_Timestamp *) def->obj);
                    break;

               case OCI_CDT_INTERVAL:

                    OCI_IntervalFree((OCI_Interval *) def->obj);
                    break;
            }

            def->obj = NULL;
        }

        /* free OCI handles */

        if (def->col.dtype != 0)
        {
            for(j=0; j < def->buf.count; j++)
            {
                if (def->col.type == OCI_CDT_CURSOR)                
                {
                    OCI_HandleFree((dvoid *) def->buf.data[j], 
                                   (ub4    ) def->col.dtype);
                }
                else
                {
                    OCI_DescriptorFree((dvoid *) def->buf.data[j],
                                       (ub4    ) def->col.dtype);
                }
           
            }
        }

        /* free OCI long buffers */
               
        if (def->col.type == OCI_CDT_LONG && def->buf.data != NULL)
        {
            for(j=0; j < def->buf.count; j++)
            {         
                if (def->buf.data[j] != NULL)
                {
                   ((OCI_Datatype *) def->buf.data[j])->hstate = OCI_OBJECT_FETCHED_DIRTY;

                    OCI_LongFree((OCI_Long *) def->buf.data[j]);
                }
            }
        }

        /* free column pointers */

        OCI_FREE(def->col.name);

        /* free buffer pointers */

        OCI_FREE(def->buf.data);
        OCI_FREE(def->buf.inds);
        OCI_FREE(def->buf.lens);
        OCI_FREE(def->buf.temp);
   }

    /* free column map */

    if (rs->map != NULL)
    {
        OCI_HashFree(rs->map);
    }

    /* free defines (column array) */

    OCI_FREE(rs->defs);

    OCI_FREE(rs);

    OCI_RESULT(res);

    return res;
}

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

boolean OCI_API OCI_FetchPrev(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);
   
    if (rs->bof == FALSE)
    {
        if (rs->row_cur == 1)
        {
            if (rs->row_abs == 1)
            {
                rs->bof = TRUE;
            }
            else
            {
                int offset = 1 - (rs->fetch_size + rs->row_fetched); 
 
               // rs->fetch_status = OCI_SUCCESS;

                if (OCI_FetchData(rs, OCI_SFD_RELATIVE, offset) == TRUE)
                {
                    rs->row_cur = rs->fetch_size;  
                    rs->row_abs--;
                }
            }
        }
        else
        {
            rs->row_cur--;
            rs->row_abs--;
        }

        rs->eof = FALSE;

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

    OCI_RESULT(res);

    return res;    
}

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

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

    OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);

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

            if ((rs->bof == TRUE) || (rs->row_cur == rs->row_fetched))
            {
                if (rs->fetch_status == OCI_NO_DATA)
                {
                    rs->eof = TRUE;
                }
                else if (OCI_FetchData(rs, OCI_SFD_NEXT, 0) == 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++;
            }
        }
    }