• Main Page
  • Modules
  • Data Structures
  • Files
  • File List

D:/Perso/dev/ocilib/ocilib/src/resultset.c

00001 /*
00002     +-----------------------------------------------------------------------------------------+
00003     |                                                                                         |
00004     |                               OCILIB - C Driver for Oracle                              |
00005     |                                                                                         |
00006     |                                (C Wrapper for Oracle OCI)                               |
00007     |                                                                                         |
00008     |                              Website : http://www.ocilib.net                            |
00009     |                                                                                         |
00010     |             Copyright (c) 2007-2010 Vincent ROGIER <vince.rogier@ocilib.net>            |
00011     |                                                                                         |
00012     +-----------------------------------------------------------------------------------------+
00013     |                                                                                         |
00014     |             This library is free software; you can redistribute it and/or               |
00015     |             modify it under the terms of the GNU Lesser General Public                  |
00016     |             License as published by the Free Software Foundation; either                |
00017     |             version 2 of the License, or (at your option) any later version.            |
00018     |                                                                                         |
00019     |             This library is distributed in the hope that it will be useful,             |
00020     |             but WITHOUT ANY WARRANTY; without even the implied warranty of              |
00021     |             MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU           |
00022     |             Lesser General Public License for more details.                             |
00023     |                                                                                         |
00024     |             You should have received a copy of the GNU Lesser General Public            |
00025     |             License along with this library; if not, write to the Free                  |
00026     |             Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.          |
00027     |                                                                                         |
00028     +-----------------------------------------------------------------------------------------+
00029 */
00030 
00031 /* --------------------------------------------------------------------------------------------- *
00032  * $Id: resultset.c, v 3.8.0 2010-10-24 21:53 Vincent Rogier $
00033  * --------------------------------------------------------------------------------------------- */
00034 
00035 #include "ocilib_internal.h"
00036 
00037 /* ********************************************************************************************* *
00038  *                             PRIVATE FUNCTIONS
00039  * ********************************************************************************************* */
00040 
00041 /* --------------------------------------------------------------------------------------------- *
00042  * OCI_ResultsetCreate
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 OCI_Resultset * OCI_ResultsetCreate
00046 (
00047     OCI_Statement *stmt,
00048     int            size
00049 )
00050 {
00051     OCI_Resultset* rs = NULL;
00052     boolean res       = TRUE;
00053     ub4 nb            = 0;
00054     ub4 i;
00055 
00056     /* allocate resultset structure */
00057 
00058     rs = (OCI_Resultset *) OCI_MemAlloc(OCI_IPC_RESULTSET, sizeof(*rs),
00059                                         (size_t) 1, TRUE);
00060 
00061     /* set attributes */
00062 
00063     if (rs != NULL)
00064     {
00065         rs->stmt         = stmt;
00066         rs->bof          = TRUE;
00067         rs->eof          = FALSE;
00068         rs->fetch_size   = size;
00069         rs->fetch_status = OCI_SUCCESS;
00070         rs->row_count    = 0;
00071         rs->row_cur      = 0;
00072         rs->row_abs      = 0;
00073 
00074         /* is the resultset created from a SQL select statement ? */
00075 
00076         if (stmt->type == OCI_CST_SELECT)
00077         {
00078             OCI_CALL1
00079             (
00080                 res, stmt->con, stmt,
00081 
00082                 OCIAttrGet((void *) stmt->stmt, (ub4) OCI_HTYPE_STMT,
00083                            (void *) &nb, (ub4 *) NULL,
00084                            (ub4) OCI_ATTR_PARAM_COUNT, stmt->con->err)
00085             )
00086         }
00087         else
00088         {
00089             nb = stmt->nb_rbinds;
00090         }
00091 
00092         /* allocate columns array */
00093 
00094         if (res == TRUE)
00095         {
00096             rs->defs = (OCI_Define *) OCI_MemAlloc(OCI_IPC_DEFINE,
00097                                                    sizeof(*rs->defs),
00098                                                    (size_t) nb, TRUE);
00099 
00100             res = (rs->defs != NULL);
00101         }
00102 
00103         /* describe select list */
00104 
00105         if ((res == TRUE) && (stmt->type == OCI_CST_SELECT))
00106         {
00107             for (i=0; i < nb; i++)
00108             {
00109                 OCI_Define *def = &rs->defs[i];
00110 
00111                 def->buf.count   = size;
00112                 def->buf.sizelen = sizeof(ub2);
00113 
00114                 def->rs = rs;
00115 
00116                 rs->nb_defs++;
00117 
00118                 /* get column description */
00119 
00120                 if (res == TRUE)
00121                     res = OCI_ColumnDescribe(&def->col, rs->stmt->con,
00122                                              rs->stmt, rs->stmt->stmt,
00123                                              rs->nb_defs, OCI_DESC_RESULTSET);
00124 
00125                 /* mapping to OCILIB internal types */
00126 
00127                 if (res == TRUE)
00128                     res = OCI_ColumnMap(&def->col, rs->stmt);
00129 
00130                 /* allocation of internal buffers for resultset content */
00131 
00132                 if (res == TRUE)
00133                     res = OCI_DefineAlloc(def);
00134 
00135                 /* register OCILIB result buffers to OCI */
00136 
00137                 if (res == TRUE)
00138                     res = OCI_DefineDef(def);
00139 
00140                 if (res == FALSE)
00141                     break;
00142             }
00143         }
00144         else
00145         {
00146             /* get info from register binds */
00147 
00148             for (i=0; i < stmt->nb_rbinds; i++)
00149             {
00150                 OCI_Bind *bnd   = stmt->rbinds[i];
00151                 OCI_Define *def = &rs->defs[bnd->dynpos];
00152 
00153                 def->buf.count   = size;
00154                 def->buf.sizelen = sizeof(ub4);
00155 
00156                 def->rs = rs;
00157 
00158                 rs->nb_defs++;
00159 
00160                 /* columns info */
00161 
00162                 def->col.ocode   = bnd->code;
00163                 def->col.name    = mtsdup(bnd->name);
00164                 def->col.size    = (ub2) bnd->size;
00165                 def->col.type    = bnd->type;
00166                 def->col.subtype = bnd->subtype;
00167 
00168                 /* check national attribute for nclobs */
00169 
00170                 if (bnd->type == OCI_CDT_LOB && bnd->subtype == OCI_NCLOB)
00171                     def->col.csfrm = SQLCS_NCHAR;
00172 
00173                 /* adjust column size from bind attributes */
00174 
00175                 if (def->col.type == OCI_CDT_TEXT)
00176                     def->col.size = (ub2) (def->col.size / ((ub2) sizeof(dtext)) - 1);
00177 
00178                 /* for integer types, set the bufsize here in order to
00179                    retrieve later the integer type (short, integer, big_int)
00180                    depending on the integer size */
00181 
00182                 if (def->col.type == OCI_CDT_NUMERIC)
00183                     def->col.bufsize = def->col.size;
00184 
00185                 /* preset bufsize here to let OCI_ColumnMap() know we don't
00186                    want the column to mapped to SQLT_ODT */
00187 
00188                 if (def->col.ocode == SQLT_DAT)
00189                     def->col.bufsize = def->col.size;
00190 
00191                 /* map column : failure means unsupported type */
00192 
00193                 if (res == TRUE)
00194                     res = OCI_ColumnMap(&def->col, rs->stmt);
00195 
00196                 /* allocation of internal buffers for resultset content */
00197 
00198                 if (res == TRUE)
00199                     res = OCI_DefineAlloc(def);
00200 
00201                 if (res == FALSE)
00202                     break;
00203             }
00204         }
00205     }
00206 
00207     return rs;
00208 }
00209 
00210 /* --------------------------------------------------------------------------------------------- *
00211  * OCI_FetchPieces
00212  * --------------------------------------------------------------------------------------------- */
00213 
00214 boolean OCI_FetchPieces
00215 (
00216     OCI_Resultset *rs
00217 )
00218 {
00219     boolean res = TRUE;
00220 
00221     ub4 type, iter, dx;
00222     ub1 in_out, piece;
00223     void *handle;
00224     ub4 i, j;
00225 
00226     OCI_CHECK(rs == NULL, FALSE);
00227 
00228     /* reset long objects */
00229 
00230     for (i = 0; i < rs->nb_defs; i++)
00231     {
00232         OCI_Define *def = &rs->defs[i];
00233 
00234         if (def->col.type == OCI_CDT_LONG)
00235         {
00236             for (j = 0; j < def->buf.count; j++)
00237             {
00238                 OCI_LongInit(rs->stmt, (OCI_Long **) &def->buf.data[j],
00239                              def, def->col.subtype);
00240             }
00241         }
00242     }
00243 
00244     /* dynamic fetch */
00245 
00246     while ((res == TRUE) && (rs->fetch_status == OCI_NEED_DATA))
00247     {
00248         piece  = OCI_NEXT_PIECE;
00249         iter   = 0;
00250         handle = NULL;
00251 
00252         /* get piece information */
00253 
00254         OCI_CALL1
00255         (
00256             res, rs->stmt->con, rs->stmt,
00257 
00258             OCIStmtGetPieceInfo(rs->stmt->stmt, rs->stmt->con->err,
00259                                 &handle,  &type, &in_out, &iter, &dx, &piece)
00260         )
00261 
00262         /* search for the given column */
00263 
00264         for (i = 0; (res == TRUE) && (i < rs->nb_defs); i++)
00265         {
00266             OCI_Define *def = &(rs->defs[i]);
00267 
00268             if (def->col.type == OCI_CDT_LONG && def->buf.handle == handle)
00269             {
00270                 /* get the long object for the given internal row */
00271 
00272                 OCI_Long *lg = (OCI_Long *) def->buf.data[iter];
00273 
00274                 unsigned int nb_alloc      = 0;
00275                 unsigned int trailing_size = 0;
00276                 unsigned int char_fact     = sizeof(dtext)/sizeof(odtext);
00277 
00278                 /* setup up piece size */
00279 
00280                 ub4 bufsize = rs->stmt->long_size;
00281 
00282                 if (char_fact == 0)
00283                     char_fact = 1;
00284 
00285                 if (lg->type == OCI_CLONG)
00286                     bufsize += (ub4) sizeof(odtext);
00287 
00288                 nb_alloc = (lg->maxsize / bufsize);
00289 
00290                 if (lg->type == OCI_CLONG)
00291                     trailing_size = sizeof(odtext) * nb_alloc;
00292 
00293                 /* check buffer */
00294 
00295                 if (lg->buffer == NULL)
00296                 {
00297                     lg->maxsize = bufsize;
00298 
00299                     lg->buffer = (ub1 *) OCI_MemAlloc(OCI_IPC_LONG_BUFFER,
00300                                                       (size_t) lg->maxsize,
00301                                                       (size_t) 1, FALSE);
00302 
00303                     lg->buffer[0] = 0;
00304                 }
00305                 else if ((lg->size*char_fact) >= (lg->maxsize - trailing_size))
00306                 {
00307                     lg->maxsize = (lg->size*char_fact) + trailing_size + bufsize;
00308 
00309                     lg->buffer = (ub1 *) OCI_MemRealloc(lg->buffer,
00310                                                         (size_t) OCI_IPC_LONG_BUFFER,
00311                                                         (size_t) lg->maxsize, 1);
00312                 }
00313 
00314                 res = (lg->buffer != NULL);
00315 
00316                 /* update piece info */
00317 
00318                 if (res == TRUE)
00319                 {
00320                     if (lg->type == OCI_CLONG)
00321                         lg->piecesize -= (ub4) sizeof(odtext);
00322 
00323                     lg->piecesize = (bufsize / sizeof(dtext)) * sizeof(odtext);
00324 
00325                     OCI_CALL1
00326                     (
00327                         res, rs->stmt->con, rs->stmt,
00328 
00329                         OCIStmtSetPieceInfo((dvoid *) handle,
00330                                             (ub4) OCI_HTYPE_DEFINE,
00331                                             lg->stmt->con->err,
00332                                             (dvoid *) (lg->buffer + (size_t) lg->size),
00333                                             &lg->piecesize, piece,
00334                                             lg->def->buf.inds, (ub2 *) NULL)
00335                     )
00336 
00337                 }
00338 
00339                 break;
00340             }
00341         }
00342 
00343         /* fetch data */
00344 
00345         #if defined(OCI_STMT_SCROLLABLE_READONLY)
00346 
00347         if (OCILib.use_scrollable_cursors == TRUE)
00348         {
00349             rs->fetch_status = OCIStmtFetch2(rs->stmt->stmt, rs->stmt->con->err,
00350                                              rs->fetch_size, (ub2) OCI_FETCH_NEXT,
00351                                              (sb4) 0, (ub4) OCI_DEFAULT);
00352         }
00353         else
00354         #endif
00355         {
00356             rs->fetch_status = OCIStmtFetch(rs->stmt->stmt, rs->stmt->con->err,
00357                                             rs->fetch_size, (ub2) OCI_FETCH_NEXT,
00358                                             (ub4) OCI_DEFAULT);
00359         }
00360 
00361         /* check for return value of fetch call */
00362 
00363         if (rs->fetch_status == OCI_ERROR)
00364         {
00365             OCI_ExceptionOCI(rs->stmt->con->err, rs->stmt->con, rs->stmt, FALSE);
00366             res = FALSE;
00367         }
00368         else if (rs->fetch_status == OCI_SUCCESS_WITH_INFO)
00369         {
00370             OCI_ExceptionOCI(rs->stmt->con->err, rs->stmt->con, rs->stmt, TRUE);
00371             res = TRUE;
00372         }
00373         else
00374         {
00375             /* search for the given column */
00376 
00377             for (i = 0; i < rs->nb_defs; i++)
00378             {
00379                 OCI_Define *def = &rs->defs[i];
00380 
00381                 if (def->col.type == OCI_CDT_LONG && def->buf.handle == handle)
00382                 {
00383                     /* get the long object for the given internal row */
00384 
00385                     OCI_Long *lg = (OCI_Long *) def->buf.data[iter];
00386 
00387                     lg->size += lg->piecesize;
00388 
00389                     break;
00390                 }
00391             }
00392         }
00393     }
00394 
00395     /* for LONG columns, set the zero terminal string */
00396 
00397     for (i = 0; i < rs->nb_defs; i++)
00398     {
00399         OCI_Define *def = &rs->defs[i];
00400 
00401         if (def->col.type == OCI_CDT_LONG && def->col.subtype == OCI_CLONG)
00402         {
00403             for (j = 0; j < def->buf.count; j++)
00404             {
00405                 OCI_Long *lg = (OCI_Long *) def->buf.data[j];
00406 
00407                 if (lg->buffer != NULL)
00408                     ((odtext *)lg->buffer)[lg->size/sizeof(odtext)] = 0;
00409 
00410                 OCI_ConvertString(lg->buffer, (lg->size / sizeof(odtext))+1, sizeof(odtext),
00411                                   sizeof(dtext));
00412             }
00413         }
00414     }
00415 
00416     return res;
00417 }
00418 
00419 /* --------------------------------------------------------------------------------------------- *
00420  * OCI_FetchData
00421  * --------------------------------------------------------------------------------------------- */
00422 
00423 boolean OCI_FetchData
00424 (
00425     OCI_Resultset *rs,
00426     int            mode,
00427     int            offset,
00428     boolean       *err
00429 )
00430 {
00431     boolean res = TRUE;
00432 
00433     /* let's initialize the error flag to TRUE until the process completes */
00434 
00435     *err = TRUE;
00436 
00437     /* internal fetch */
00438 
00439     #if defined(OCI_STMT_SCROLLABLE_READONLY)
00440 
00441     if (OCILib.use_scrollable_cursors == TRUE)
00442     {
00443         rs->fetch_status = OCIStmtFetch2(rs->stmt->stmt, rs->stmt->con->err,
00444                                          rs->fetch_size, (ub2) mode, (sb4) offset,
00445                                          (ub4) OCI_DEFAULT);
00446     }
00447     else
00448     #endif
00449     {
00450         rs->fetch_status = OCIStmtFetch(rs->stmt->stmt, rs->stmt->con->err,
00451                                         rs->fetch_size, (ub2) OCI_FETCH_NEXT,
00452                                         (ub4) OCI_DEFAULT);
00453     }
00454 
00455     /* check failure */
00456 
00457     if (rs->fetch_status == OCI_ERROR)
00458     {
00459         OCI_ExceptionOCI(rs->stmt->con->err, rs->stmt->con, rs->stmt, FALSE);
00460         res = FALSE;
00461     }
00462     else if (rs->fetch_status == OCI_SUCCESS_WITH_INFO)
00463     {
00464         OCI_ExceptionOCI(rs->stmt->con->err, rs->stmt->con, rs->stmt, TRUE);
00465         res = TRUE;
00466     }
00467 
00468     /* do we need to do a piecewise fetch */
00469 
00470     if (rs->fetch_status == OCI_NEED_DATA)
00471         res = OCI_FetchPieces(rs);
00472 
00473     /* check string buffer for Unicode builds that need buffer expansion */
00474 
00475     #ifdef OCI_CHECK_DATASTRINGS
00476 
00477     OCI_ResultsetExpandStrings(rs);
00478 
00479     #endif
00480 
00481     /* check for success */
00482 
00483     res = ((res == TRUE) && ((rs->fetch_status == OCI_SUCCESS) ||
00484                              (rs->fetch_status == OCI_NO_DATA) ||
00485                              (rs->fetch_status == OCI_SUCCESS_WITH_INFO)));
00486 
00487     /* update internal fetch status and variables */
00488 
00489     if (res == TRUE)
00490     {
00491         ub4 row_count   = 0;
00492         ub4 row_fetched = 0;
00493 
00494         if (rs->fetch_status == OCI_SUCCESS_WITH_INFO)
00495         {
00496             OCI_ExceptionOCI(rs->stmt->con->err, rs->stmt->con, rs->stmt, TRUE);
00497         }
00498 
00499         #if defined(OCI_STMT_SCROLLABLE_READONLY)
00500 
00501         if (rs->stmt->exec_mode  == OCI_SFM_SCROLLABLE)
00502         {
00503             OCI_CALL1
00504             (
00505                 res, rs->stmt->con, rs->stmt,
00506 
00507                 OCIAttrGet((dvoid *) rs->stmt->stmt, (ub4) OCI_HTYPE_STMT,
00508                            (dvoid *) &row_count, (ub4 *) NULL,
00509                            (ub4) OCI_ATTR_CURRENT_POSITION, rs->stmt->con->err)
00510             )
00511 
00512             OCI_CALL1
00513             (
00514                 res, rs->stmt->con, rs->stmt,
00515 
00516                 OCIAttrGet((dvoid *) rs->stmt->stmt, (ub4) OCI_HTYPE_STMT,
00517                            (dvoid *) &row_fetched, (ub4 *) NULL,
00518                            (ub4) OCI_ATTR_ROWS_FETCHED, rs->stmt->con->err)
00519             )
00520         }
00521         else
00522         #endif
00523         {
00524             row_count   = OCI_GetAffectedRows(rs->stmt);
00525             row_fetched = row_count - rs->row_count;
00526 
00527         }
00528 
00529         if (rs->row_count < row_count)
00530             rs->row_count = row_count;
00531 
00532         if (row_fetched > 0)
00533             rs->row_fetched = row_fetched;
00534 
00535         /* so far, no OCI error occurred, let's clear the error flag */
00536 
00537         *err = FALSE;
00538 
00539         /* check if internal fetch was successful */
00540 
00541         if ((rs->fetch_status == OCI_NO_DATA) && (row_fetched == 0))
00542         {
00543             if ((mode == OCI_SFD_NEXT) || (offset > 0))
00544                 rs->eof = TRUE;
00545 
00546             if (offset < 0)
00547                 rs->bof = TRUE;
00548 
00549             res = FALSE;
00550         }
00551     }
00552 
00553     return res;
00554 }
00555 
00556 /* --------------------------------------------------------------------------------------------- *
00557  * OCI_FetchCustom
00558  * --------------------------------------------------------------------------------------------- */
00559 
00560 boolean OCI_FetchCustom
00561 (
00562     OCI_Resultset *rs,
00563     int            mode,
00564     int            offset,
00565     boolean       *err
00566 )
00567 {
00568     boolean res = TRUE;
00569 
00570     switch (mode)
00571     {
00572     case OCI_SFD_RELATIVE:
00573     {
00574         int offset_save = 0;
00575 
00576         if (((offset > 0) && (rs->eof == TRUE)) ||
00577             ((offset < 0) && (rs->bof == TRUE)) ||
00578             (offset == 0))
00579         {
00580             res = FALSE;
00581         }
00582         else
00583         {
00584             offset_save = offset;
00585             offset      = offset - rs->row_fetched + rs->row_cur;
00586             rs->row_cur = 1;
00587 
00588             res = OCI_FetchData(rs, mode, offset, err);
00589 
00590             if (res == TRUE)
00591                 rs->row_abs += offset_save;
00592         }
00593 
00594         break;
00595     }
00596     case OCI_SFD_ABSOLUTE:
00597     {
00598         if (offset == 0)
00599         {
00600             res = FALSE;
00601         }
00602         else
00603         {
00604             rs->row_abs = 1;
00605             rs->row_cur = 1;
00606 
00607             res = OCI_FetchData(rs, mode, offset, err);
00608 
00609             if (res == TRUE)
00610             {
00611                 rs->row_abs = offset;
00612 
00613                 rs->bof = FALSE;
00614                 rs->eof = FALSE;
00615             }
00616         }
00617 
00618         break;
00619     }
00620     default:
00621     {
00622         res = FALSE;
00623     }
00624     }
00625 
00626     return res;
00627 }
00628 
00629 #ifdef OCI_CHECK_DATASTRINGS
00630 
00631 /* --------------------------------------------------------------------------------------------- *
00632  * OCI_ResultsetExpandStrings
00633  * --------------------------------------------------------------------------------------------- */
00634 
00635 boolean OCI_ResultsetExpandStrings
00636 (
00637     OCI_Resultset *rs
00638 )
00639 {
00640     ub4 i;
00641     int j;
00642 
00643     OCI_CHECK(rs == NULL, FALSE)
00644 
00645     for (i = 0; i < rs->nb_defs; i++)
00646     {
00647         OCI_Define *def = &rs->defs[i];
00648 
00649         if (def->col.type == OCI_CDT_TEXT)
00650         {
00651             for (j = (int) (def->buf.count-1); j >= 0; j--)
00652             {
00653                 OCI_ConvertString(((ub1*) def->buf.data) + (def->col.bufsize * j),
00654                                   def->col.bufsize / sizeof(dtext), sizeof(odtext),
00655                                   sizeof(dtext));
00656             }
00657         }
00658     }
00659 
00660     return TRUE;
00661 }
00662 
00663 #endif
00664 
00665 /* --------------------------------------------------------------------------------------------- *
00666  * OCI_ResultsetGetAttrSize
00667  * --------------------------------------------------------------------------------------------- */
00668 
00669 size_t OCI_ResultsetGetAttrSize
00670 (
00671     OCI_Resultset *rs,
00672     unsigned int   index
00673 )
00674 {
00675     size_t size = 0;
00676 
00677     if (index >= rs->nb_defs)
00678         return 0;
00679 
00680     switch (rs->defs[index].col.type)
00681     {
00682     case OCI_CDT_NUMERIC:
00683     {
00684         unsigned int type = rs->defs[index].col.subtype;
00685 
00686         if (type & OCI_NUM_SHORT)
00687             size = sizeof(short);
00688         else if (type & OCI_NUM_INT)
00689             size = sizeof(int);
00690         else if (type & OCI_NUM_DOUBLE)
00691             size = sizeof(double);
00692         else
00693             size = sizeof(big_int);
00694 
00695         break;
00696     }
00697     case OCI_CDT_TEXT:
00698     case OCI_CDT_RAW:
00699     case OCI_CDT_LONG:
00700     case OCI_CDT_DATETIME:
00701     case OCI_CDT_CURSOR:
00702     case OCI_CDT_LOB:
00703     case OCI_CDT_FILE:
00704     case OCI_CDT_TIMESTAMP:
00705     case OCI_CDT_INTERVAL:
00706     case OCI_CDT_OBJECT:
00707     case OCI_CDT_COLLECTION:
00708     case OCI_CDT_REF:
00709 
00710         size = sizeof(void *);
00711         break;
00712     }
00713 
00714     return size;
00715 }
00716 
00717 /* --------------------------------------------------------------------------------------------- *
00718  * OCI_ResultsetGetStructSize
00719  * --------------------------------------------------------------------------------------------- */
00720 
00721 size_t OCI_ResultsetGetStructSize
00722 (
00723     OCI_Resultset *rs
00724 )
00725 {
00726     size_t size1  = 0;
00727     size_t offset = 0;
00728     size_t size2  = 0;
00729     ub2 i;
00730 
00731     for (i = 0; i < rs->nb_defs; i++)
00732     {
00733         size1 = OCI_ResultsetGetAttrSize(rs, i);
00734         size2 = OCI_ResultsetGetAttrSize(rs, i+1);
00735 
00736         offset += size1;
00737 
00738         if ((size1 != size2) && (size2 == sizeof(void *)))
00739             offset = ROUNDUP(offset);
00740     }
00741 
00742     return offset;
00743 }
00744 
00745 /* ********************************************************************************************* *
00746  *                            PUBLIC FUNCTIONS
00747  * ********************************************************************************************* */
00748 
00749 /* --------------------------------------------------------------------------------------------- *
00750  * OCI_GetResultset
00751  * --------------------------------------------------------------------------------------------- */
00752 
00753 OCI_Resultset * OCI_API OCI_GetResultset
00754 (
00755     OCI_Statement *stmt
00756 )
00757 {
00758     OCI_Resultset *rs = NULL;
00759     boolean res       = TRUE;
00760 
00761     OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, NULL);
00762 
00763     OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_CLOSED, NULL);
00764     OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_PREPARED, NULL);
00765 
00766     /* if the sql statement does not return a result, we just return NULL and not
00767        throwing any exception */
00768 
00769     if ((stmt->type != OCI_CST_SELECT) || (stmt->nb_rbinds == 0))
00770     {
00771         /* if the resultset exists, let's use it */
00772 
00773         if ((stmt->rsts != NULL) && (stmt->rsts[0] != NULL))
00774         {
00775             rs = stmt->rsts[0];
00776         }
00777 
00778         /* allocate resultset for select statements */
00779 
00780         if ((rs == NULL)  && (stmt->type == OCI_CST_SELECT))
00781         {
00782             /* allocate memory for one resultset handle */
00783 
00784             stmt->rsts = (OCI_Resultset **) OCI_MemAlloc(OCI_IPC_RESULTSET_ARRAY,
00785                                                          sizeof(*stmt->rsts),
00786                                                          (size_t) 1, TRUE);
00787             if (stmt->rsts != NULL)
00788             {
00789                 stmt->nb_rs  = 1;
00790                 stmt->cur_rs = 0;
00791 
00792                 /* create resultset object */
00793 
00794                 rs = OCI_ResultsetCreate(stmt, stmt->fetch_size);
00795 
00796                 if (rs != NULL)
00797                     stmt->rsts[0] = rs;
00798                 else
00799                     res = FALSE;
00800             }
00801             else
00802                 res = FALSE;
00803         }
00804     }
00805 
00806     OCI_RESULT(res);
00807 
00808     return rs;
00809 }
00810 
00811 /* ------------------------------------------------------------------------ v*
00812  * OCI_GetNextResultset
00813  * --------------------------------------------------------------------------------------------- */
00814 
00815 OCI_Resultset * OCI_API OCI_GetNextResultset
00816 (
00817     OCI_Statement *stmt
00818 )
00819 {
00820     OCI_Resultset *rs = NULL;
00821 
00822     OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, NULL);
00823 
00824     if (stmt->cur_rs < (stmt->nb_rs-1))
00825         rs = stmt->rsts[++stmt->cur_rs];
00826 
00827     OCI_RESULT(TRUE);
00828 
00829     return rs;
00830 }
00831 
00832 /* --------------------------------------------------------------------------------------------- *
00833  * OCI_ResultsetInit
00834  * --------------------------------------------------------------------------------------------- */
00835 
00836 boolean OCI_ResultsetInit
00837 (
00838     OCI_Resultset *rs
00839 )
00840 {
00841     rs->bof          = TRUE;
00842     rs->eof          = FALSE;
00843     rs->fetch_status = OCI_SUCCESS;
00844     rs->row_count    = 0;
00845     rs->row_cur      = 0;
00846     rs->row_abs      = 0;
00847     rs->row_fetched  = 0;
00848 
00849     return TRUE;
00850 }
00851 
00852 /* --------------------------------------------------------------------------------------------- *
00853  * OCI_ResultsetFree
00854  * --------------------------------------------------------------------------------------------- */
00855 
00856 boolean OCI_ResultsetFree
00857 (
00858     OCI_Resultset *rs
00859 )
00860 {
00861     boolean res = TRUE;
00862     ub4 i, j;
00863 
00864     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
00865 
00866     for (i = 0; i < rs->nb_defs; i++)
00867     {
00868         OCI_Define *def = &(rs->defs[i]);
00869 
00870         /* free buffer objects */
00871 
00872         if (def->obj != NULL)
00873         {
00874             /* handy cast to set object state flag */
00875 
00876             ((OCI_Datatype *) def->obj)->hstate = OCI_OBJECT_FETCHED_DIRTY;
00877 
00878             switch (def->col.type)
00879             {
00880             case OCI_CDT_DATETIME:
00881 
00882                 OCI_DateFree((OCI_Date *) def->obj);
00883                 break;
00884 
00885             case OCI_CDT_LOB:
00886 
00887                 OCI_LobFree((OCI_Lob *) def->obj);
00888                 break;
00889 
00890             case OCI_CDT_FILE:
00891 
00892                 OCI_FileFree((OCI_File *) def->obj);
00893                 break;
00894 
00895             case OCI_CDT_CURSOR:
00896 
00897                 OCI_StatementClose((OCI_Statement *) def->obj);
00898                 OCI_FREE(def->obj);
00899                 break;
00900 
00901             case OCI_CDT_OBJECT:
00902 
00903                 OCI_ObjectFree((OCI_Object *) def->obj);
00904                 break;
00905 
00906             case OCI_CDT_COLLECTION:
00907 
00908                 OCI_CollFree((OCI_Coll *) def->obj);
00909                 break;
00910 
00911             case OCI_CDT_REF:
00912 
00913                 OCI_RefFree((OCI_Ref *) def->obj);
00914                 break;
00915 
00916             case OCI_CDT_TIMESTAMP:
00917 
00918                 OCI_TimestampFree((OCI_Timestamp *) def->obj);
00919                 break;
00920 
00921             case OCI_CDT_INTERVAL:
00922 
00923                 OCI_IntervalFree((OCI_Interval *) def->obj);
00924                 break;
00925             }
00926 
00927             def->obj = NULL;
00928         }
00929 
00930         /* free OCI handles */
00931 
00932         if (def->col.dtype != 0)
00933         {
00934             if (def->col.type == OCI_CDT_CURSOR)
00935             {
00936                 for(j=0; j < def->buf.count; j++)
00937                 {
00938                     OCI_HandleFree((dvoid *) def->buf.data[j],
00939                                    (ub4    ) def->col.dtype);
00940                 }
00941             }
00942             else
00943             {
00944                 OCI_DescriptorArrayFree((dvoid *) def->buf.data,
00945                                         (ub4    ) def->col.dtype,
00946                                         (ub4    ) def->buf.count);
00947             }
00948         }
00949 
00950         /* free OCI long buffers */
00951 
00952         if (def->col.type == OCI_CDT_LONG && def->buf.data != NULL)
00953         {
00954             for(j=0; j < def->buf.count; j++)
00955             {
00956                 if (def->buf.data[j] != NULL)
00957                 {
00958                     ((OCI_Datatype *) def->buf.data[j])->hstate = OCI_OBJECT_FETCHED_DIRTY;
00959 
00960                     OCI_LongFree((OCI_Long *) def->buf.data[j]);
00961                 }
00962             }
00963         }
00964 
00965         /* free column pointers */
00966 
00967         OCI_FREE(def->col.name);
00968 
00969         /* free buffer pointers */
00970 
00971         OCI_FREE(def->buf.data);
00972         OCI_FREE(def->buf.inds);
00973         OCI_FREE(def->buf.obj_inds);
00974         OCI_FREE(def->buf.lens);
00975         OCI_FREE(def->buf.tmpbuf);
00976     }
00977 
00978     /* free column map */
00979 
00980     if (rs->map != NULL)
00981     {
00982         OCI_HashFree(rs->map);
00983     }
00984 
00985     /* free defines (column array) */
00986 
00987     OCI_FREE(rs->defs);
00988 
00989     OCI_FREE(rs);
00990 
00991     OCI_RESULT(res);
00992 
00993     return res;
00994 }
00995 
00996 /* --------------------------------------------------------------------------------------------- *
00997  * OCI_FetchPrev
00998  * --------------------------------------------------------------------------------------------- */
00999 
01000 boolean OCI_API OCI_FetchPrev
01001 (
01002     OCI_Resultset *rs
01003 )
01004 {
01005     boolean res = TRUE;
01006     boolean err = FALSE;
01007 
01008     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01009 
01010     OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
01011 
01012     #if OCI_VERSION_COMPILE >= OCI_9_0
01013 
01014     OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
01015 
01016     if (rs->bof == FALSE)
01017     {
01018         if (rs->row_cur == 1)
01019         {
01020             if (rs->row_abs == 1)
01021             {
01022                 rs->bof = TRUE;
01023             }
01024             else
01025             {
01026                 int offset = 0;
01027 
01028                 if (rs->fetch_size > rs->row_abs)
01029                     offset = 1 - rs->row_abs;
01030                 else
01031                     offset = 1 - (rs->fetch_size + rs->row_fetched);
01032 
01033                 res = OCI_FetchData(rs, OCI_SFD_RELATIVE, offset, &err);
01034 
01035                 if (res == TRUE)
01036                 {
01037                     if (rs->fetch_size > rs->row_abs)
01038                         rs->row_cur = rs->row_abs-1;
01039                     else
01040                         rs->row_cur = rs->fetch_size;
01041 
01042                     rs->row_abs--;
01043                 }
01044             }
01045         }
01046         else
01047         {
01048             rs->row_cur--;
01049             rs->row_abs--;
01050         }
01051 
01052         rs->eof = FALSE;
01053 
01054         res = ((res == TRUE) && (rs->bof == FALSE));
01055     }
01056     else
01057         res = FALSE;
01058 
01059     #else
01060 
01061     res = FALSE;
01062 
01063     #endif
01064 
01065     OCI_RESULT(err);
01066 
01067     return res;
01068 }
01069 
01070 /* --------------------------------------------------------------------------------------------- *
01071  * OCI_FetchNext
01072  * --------------------------------------------------------------------------------------------- */
01073 
01074 boolean OCI_API OCI_FetchNext
01075 (
01076     OCI_Resultset *rs
01077 )
01078 {
01079     boolean res = TRUE;
01080     boolean err = FALSE;
01081 
01082     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01083 
01084     if (rs->eof == FALSE)
01085     {
01086         if (rs->stmt->nb_rbinds == 0)
01087         {
01088             /* for regular resultsets */
01089 
01090             if ((rs->row_cur == rs->row_fetched))
01091             {
01092                 if (rs->fetch_status == OCI_NO_DATA)
01093                 {
01094                     rs->eof = TRUE;
01095                 }
01096                 else
01097                 {
01098                     res = OCI_FetchData(rs, OCI_SFD_NEXT, 0, &err);
01099 
01100                     if (res == TRUE)
01101                     {
01102                         rs->bof     = FALSE;
01103                         rs->row_cur = 1;
01104 
01105                         rs->row_abs++;
01106                     }
01107                 }
01108             }
01109             else
01110             {
01111                 rs->row_cur++;
01112                 rs->row_abs++;
01113             }
01114         }
01115         else
01116         {
01117             /* for resultset from returning into clause */
01118 
01119             if (rs->row_abs == 0)
01120             {
01121                 /* check string buffer once for Unicode build */
01122 
01123                 #ifdef OCI_CHECK_DATASTRINGS
01124 
01125                 OCI_ResultsetExpandStrings(rs);
01126 
01127                 #endif
01128 
01129             }
01130 
01131             if (rs->row_abs >= rs->row_count)
01132             {
01133                 rs->eof = TRUE;
01134             }
01135             else
01136             {
01137                 rs->row_cur++;
01138                 rs->row_abs++;
01139             }
01140         }
01141     }
01142     else
01143         res = FALSE;
01144 
01145     OCI_RESULT(err);
01146 
01147     return ((res == TRUE) && (rs->eof == FALSE));
01148 }
01149 
01150 /* --------------------------------------------------------------------------------------------- *
01151  * OCI_FetchFirst
01152  * --------------------------------------------------------------------------------------------- */
01153 
01154 boolean OCI_API OCI_FetchFirst
01155 (
01156     OCI_Resultset *rs
01157 )
01158 {
01159     boolean res = TRUE;
01160     boolean err = FALSE;
01161 
01162     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01163 
01164     OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
01165 
01166     #if OCI_VERSION_COMPILE >= OCI_9_0
01167 
01168     OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
01169 
01170     rs->bof = FALSE;
01171     rs->eof = FALSE;
01172 
01173     rs->row_abs = 1;
01174     rs->row_cur = 1;
01175 
01176     res = OCI_FetchData(rs, OCI_SFD_FIRST, 0, &err);
01177 
01178     #else
01179 
01180     res = FALSE;
01181     err = TRUE;
01182 
01183     #endif
01184 
01185     OCI_RESULT(err);
01186 
01187     return ((res == TRUE) && (rs->bof == FALSE));
01188 }
01189 
01190 /* --------------------------------------------------------------------------------------------- *
01191  * OCI_FetchLast
01192  * --------------------------------------------------------------------------------------------- */
01193 
01194 boolean OCI_API OCI_FetchLast
01195 (
01196     OCI_Resultset *rs
01197 )
01198 {
01199     boolean res = TRUE;
01200     boolean err = FALSE;
01201 
01202     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01203 
01204     OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
01205 
01206     #if OCI_VERSION_COMPILE >= OCI_9_0
01207 
01208     OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
01209 
01210     rs->bof = FALSE;
01211     rs->eof = FALSE;
01212 
01213     rs->row_abs = 0;
01214     rs->row_cur = 1;
01215 
01216     res = OCI_FetchData(rs, OCI_SFD_LAST, 0, &err);
01217 
01218     rs->row_abs = rs->row_count;
01219 
01220     #else
01221 
01222     res = FALSE;
01223     err = TRUE;
01224 
01225     #endif
01226 
01227     OCI_RESULT(err);
01228 
01229     return ((res == TRUE) && (rs->eof != TRUE));
01230 }
01231 
01232 /* --------------------------------------------------------------------------------------------- *
01233  * OCI_FetchSeek
01234  * --------------------------------------------------------------------------------------------- */
01235 
01236 boolean OCI_API OCI_FetchSeek
01237 (
01238     OCI_Resultset *rs,
01239     unsigned int   mode,
01240     int            offset
01241 )
01242 {
01243     boolean res = TRUE;
01244     boolean err = FALSE;
01245 
01246     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01247 
01248     OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
01249 
01250     #if OCI_VERSION_COMPILE >= OCI_9_0
01251 
01252     OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
01253 
01254     res = OCI_FetchCustom(rs, mode, offset, &err);
01255 
01256     #else
01257 
01258     OCI_NOT_USED(mode);
01259     OCI_NOT_USED(offset);
01260 
01261     res = FALSE;
01262     err = TRUE;
01263 
01264     #endif
01265 
01266     OCI_RESULT(err);
01267 
01268     return res;
01269 }
01270 
01271 /* --------------------------------------------------------------------------------------------- *
01272  * OCI_GetRowCount
01273  * --------------------------------------------------------------------------------------------- */
01274 
01275 unsigned int OCI_API OCI_GetRowCount
01276 (
01277     OCI_Resultset *rs
01278 )
01279 {
01280     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);
01281 
01282     OCI_RESULT(TRUE);
01283 
01284     return rs->row_count;
01285 }
01286 
01287 /* --------------------------------------------------------------------------------------------- *
01288  * OCI_GetRowCount
01289  * --------------------------------------------------------------------------------------------- */
01290 
01291 unsigned int OCI_API OCI_GetCurrentRow
01292 (
01293     OCI_Resultset *rs
01294 )
01295 {
01296     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);
01297 
01298     OCI_RESULT(TRUE);
01299 
01300     return rs->row_abs;
01301 }
01302 
01303 /* --------------------------------------------------------------------------------------------- *
01304  * OCI_GetColumnCount
01305  * --------------------------------------------------------------------------------------------- */
01306 
01307 unsigned int OCI_API OCI_GetColumnCount
01308 (
01309     OCI_Resultset *rs
01310 )
01311 {
01312     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);
01313 
01314     OCI_RESULT(TRUE);
01315 
01316     return rs->nb_defs;
01317 }
01318 
01319 /* --------------------------------------------------------------------------------------------- *
01320  * OCI_GetColumn
01321  * --------------------------------------------------------------------------------------------- */
01322 
01323 OCI_Column * OCI_API OCI_GetColumn
01324 (
01325     OCI_Resultset *rs,
01326     unsigned int   index
01327 )
01328 {
01329     OCI_Define *def = NULL;
01330     OCI_Column *col = NULL;
01331 
01332     def = OCI_GetDefine(rs, index);
01333 
01334     if (def != NULL)
01335         col = &def->col;
01336 
01337     OCI_RESULT(col != NULL);
01338 
01339     return col;
01340 
01341 }
01342 
01343 /* --------------------------------------------------------------------------------------------- *
01344  * OCI_GetColumn2
01345  * --------------------------------------------------------------------------------------------- */
01346 
01347 OCI_Column * OCI_API OCI_GetColumn2
01348 (
01349     OCI_Resultset *rs,
01350     const mtext   *name
01351 )
01352 {
01353     OCI_Define *def = NULL;
01354     OCI_Column *col = NULL;
01355 
01356     def = OCI_GetDefine(rs, OCI_GetDefineIndex(rs, name));
01357 
01358     if (def != NULL)
01359         col = &def->col;
01360 
01361     OCI_RESULT(col != NULL);
01362 
01363     return col;
01364 }
01365 
01366 /* --------------------------------------------------------------------------------------------- *
01367  * OCI_GetColumnIndex
01368  * --------------------------------------------------------------------------------------------- */
01369 
01370 unsigned int OCI_API OCI_GetColumnIndex
01371 (
01372     OCI_Resultset *rs,
01373     const mtext   *name
01374 )
01375 {
01376     int index = OCI_GetDefineIndex(rs, name);
01377 
01378     OCI_RESULT(index >= 1);
01379 
01380     if (index <= 0)
01381         index = 0;
01382 
01383     return (unsigned int) index;
01384 }
01385 
01386 /* --------------------------------------------------------------------------------------------- *
01387  * OCI_SetStructNumericType
01388  * --------------------------------------------------------------------------------------------- */
01389 
01390 boolean OCI_API OCI_SetStructNumericType
01391 (
01392     OCI_Resultset *rs,
01393     unsigned int   index,
01394     unsigned int   type
01395 )
01396 {
01397     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01398 
01399     OCI_CHECK_BOUND(rs->stmt->con, index,  1,  rs->nb_defs, FALSE);
01400 
01401     OCI_CHECK_COMPAT(rs->stmt->con, rs->defs[index-1].col.type == OCI_CDT_NUMERIC, FALSE);
01402 
01403     rs->defs[index-1].col.subtype = type;
01404 
01405     OCI_RESULT(TRUE);
01406 
01407     return TRUE;
01408 }
01409 
01410 /* --------------------------------------------------------------------------------------------- *
01411  * OCI_SetStructNumericType2
01412  * --------------------------------------------------------------------------------------------- */
01413 
01414 boolean OCI_API OCI_SetStructNumericType2
01415 (
01416     OCI_Resultset *rs,
01417     const mtext   *name,
01418     unsigned int   type
01419 )
01420 {
01421     return OCI_SetStructNumericType(rs, OCI_GetDefineIndex(rs, name), type);
01422 }
01423 
01424 /* --------------------------------------------------------------------------------------------- *
01425  * OCI_GetStruct
01426  * --------------------------------------------------------------------------------------------- */
01427 
01428 boolean OCI_API OCI_GetStruct
01429 (
01430     OCI_Resultset *rs,
01431     void          *row_struct,
01432     void          *row_struct_ind
01433 )
01434 {
01435     char *ptr     = NULL;
01436     boolean *inds = NULL;
01437     boolean res   = TRUE;
01438     size_t size   = 0;
01439     ub4 i;
01440 
01441     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01442     OCI_CHECK_PTR(OCI_IPC_VOID, row_struct, FALSE);
01443 
01444     ptr  = row_struct;
01445     inds = row_struct_ind;
01446 
01447     if (ptr != NULL)
01448     {
01449         for (i = 1; i <= rs->nb_defs; i++)
01450         {
01451             size = OCI_ResultsetGetAttrSize(rs, i-1);
01452 
01453             switch (rs->defs[i-1].col.type)
01454             {
01455             case OCI_CDT_NUMERIC:
01456             {
01457                 OCI_DefineGetNumber(rs, i, ptr,
01458                                     rs->defs[i-1].col.subtype,
01459                                     (uword) size);
01460 
01461                 break;
01462             }
01463             case OCI_CDT_TEXT:
01464             {
01465                 dtext **str = (dtext **) ptr;
01466 
01467                 *str =  (dtext * ) OCI_GetString(rs, i);
01468 
01469                 break;
01470             }
01471             case OCI_CDT_RAW:
01472             {
01473                 void **buf = (void **) ptr;
01474 
01475                 *buf = OCI_DefineGetData(&rs->defs[i]);
01476 
01477                 break;
01478             }
01479             case OCI_CDT_LONG:
01480             {
01481                 OCI_Long **lg = (OCI_Long **) ptr;
01482 
01483                 *lg = OCI_GetLong(rs, i);
01484 
01485                 break;
01486             }
01487             case OCI_CDT_DATETIME:
01488             {
01489                 OCI_Date **date = (OCI_Date **) ptr;
01490 
01491                 *date = OCI_GetDate(rs, i);
01492 
01493                 break;
01494             }
01495             case OCI_CDT_CURSOR:
01496             {
01497                 OCI_Statement **stmt = (OCI_Statement **) ptr;
01498 
01499                 *stmt = OCI_GetStatement(rs, i);
01500 
01501                 break;
01502             }
01503             case OCI_CDT_LOB:
01504             {
01505                 OCI_Lob **lob = (OCI_Lob **) ptr;
01506 
01507                 *lob = OCI_GetLob(rs, i);
01508 
01509                 break;
01510             }
01511             case OCI_CDT_FILE:
01512             {
01513                 OCI_File **file = (OCI_File **) ptr;
01514 
01515                 *file = OCI_GetFile(rs, i);
01516 
01517                 break;
01518             }
01519             case OCI_CDT_TIMESTAMP:
01520             {
01521                 OCI_Timestamp **tmsp = (OCI_Timestamp **) ptr;
01522 
01523                 *tmsp = OCI_GetTimestamp(rs, i);
01524 
01525                 break;
01526             }
01527             case OCI_CDT_INTERVAL:
01528             {
01529                 OCI_Interval **itv = (OCI_Interval **) ptr;
01530 
01531                 *itv = OCI_GetInterval(rs, i);
01532 
01533                 break;
01534             }
01535             case OCI_CDT_OBJECT:
01536             {
01537                 OCI_Object **obj = (OCI_Object **) ptr;
01538 
01539                 *obj = OCI_GetObject(rs, i);
01540 
01541                 break;
01542             }
01543             case OCI_CDT_COLLECTION:
01544             {
01545                 OCI_Coll **coll = (OCI_Coll **) ptr;
01546 
01547                 *coll = OCI_GetColl(rs, i);
01548 
01549                 break;
01550             }
01551             case OCI_CDT_REF:
01552             {
01553                 OCI_Ref **ref = (OCI_Ref **) ptr;
01554 
01555                 *ref = OCI_GetRef(rs, i);
01556 
01557                 break;
01558             }
01559             }
01560 
01561             ptr += size;
01562 
01563             if (inds != NULL)
01564             {
01565                 *inds = OCI_NOT_NULL(&rs->defs[i-1]);
01566 
01567                 inds++;
01568             }
01569         }
01570     }
01571 
01572     OCI_RESULT(res);
01573 
01574     return res;
01575 }
01576 
01577 /* --------------------------------------------------------------------------------------------- *
01578  * OCI_GetShort
01579  * --------------------------------------------------------------------------------------------- */
01580 
01581 short OCI_API OCI_GetShort
01582 (
01583     OCI_Resultset *rs,
01584     unsigned int   index
01585 )
01586 {
01587     short value = 0;
01588 
01589     OCI_DefineGetNumber(rs, index, &value, OCI_NUM_SHORT, sizeof(value));
01590 
01591     return value;
01592 }
01593 
01594 /* --------------------------------------------------------------------------------------------- *
01595  * OCI_GetShort2
01596  * --------------------------------------------------------------------------------------------- */
01597 
01598 short OCI_API OCI_GetShort2
01599 (
01600     OCI_Resultset *rs,
01601     const mtext   *name
01602 )
01603 {
01604     return OCI_GetShort(rs, OCI_GetDefineIndex(rs, name));
01605 }
01606 
01607 /* --------------------------------------------------------------------------------------------- *
01608  * OCI_GetUnsignedShort
01609  * --------------------------------------------------------------------------------------------- */
01610 
01611 unsigned short OCI_API OCI_GetUnsignedShort
01612 (
01613     OCI_Resultset *rs,
01614     unsigned int   index
01615 )
01616 {
01617     unsigned short value = 0;
01618 
01619     OCI_DefineGetNumber(rs, index, &value, OCI_NUM_USHORT, sizeof(value));
01620 
01621     return value;
01622 }
01623 
01624 /* --------------------------------------------------------------------------------------------- *
01625  * OCI_GetUnsignedShort2
01626  * --------------------------------------------------------------------------------------------- */
01627 
01628 unsigned short OCI_API OCI_GetUnsignedShort2
01629 (
01630     OCI_Resultset *rs,
01631     const mtext   *name
01632 )
01633 {
01634     return OCI_GetUnsignedShort(rs, OCI_GetDefineIndex(rs, name));
01635 }
01636 
01637 /* --------------------------------------------------------------------------------------------- *
01638  * OCI_GetInt
01639  * --------------------------------------------------------------------------------------------- */
01640 
01641 int OCI_API OCI_GetInt
01642 (
01643     OCI_Resultset *rs,
01644     unsigned int   index
01645 )
01646 {
01647     int value = 0;
01648 
01649     OCI_DefineGetNumber(rs, index, &value, OCI_NUM_INT, sizeof(value));
01650 
01651     return value;
01652 }
01653 
01654 /* --------------------------------------------------------------------------------------------- *
01655  * OCI_GetInt2
01656  * --------------------------------------------------------------------------------------------- */
01657 
01658 int OCI_API OCI_GetInt2
01659 (
01660     OCI_Resultset *rs,
01661     const mtext   *name
01662 )
01663 {
01664     return OCI_GetInt(rs, OCI_GetDefineIndex(rs, name));
01665 }
01666 
01667 /* --------------------------------------------------------------------------------------------- *
01668  * OCI_GetUnsignedInt
01669  * --------------------------------------------------------------------------------------------- */
01670 
01671 unsigned int OCI_API OCI_GetUnsignedInt
01672 (
01673     OCI_Resultset *rs,
01674     unsigned int   index
01675 )
01676 {
01677     unsigned int value = 0;
01678 
01679     OCI_DefineGetNumber(rs, index, &value, OCI_NUM_UINT, sizeof(value));
01680 
01681     return value;
01682 }
01683 
01684 /* --------------------------------------------------------------------------------------------- *
01685  * OCI_GetUnsignedInt2
01686  * --------------------------------------------------------------------------------------------- */
01687 
01688 unsigned int OCI_API OCI_GetUnsignedInt2
01689 (
01690     OCI_Resultset *rs,
01691     const mtext   *name
01692 )
01693 {
01694     return OCI_GetUnsignedInt(rs, OCI_GetDefineIndex(rs, name));
01695 }
01696 
01697 /* --------------------------------------------------------------------------------------------- *
01698  * OCI_GetBigInt
01699  * --------------------------------------------------------------------------------------------- */
01700 
01701 big_int OCI_API OCI_GetBigInt
01702 (
01703     OCI_Resultset *rs,
01704     unsigned int   index
01705 )
01706 {
01707     big_int value = 0;
01708 
01709     OCI_DefineGetNumber(rs, index, &value, OCI_NUM_BIGINT, sizeof(value));
01710 
01711     return value;
01712 }
01713 
01714 /* --------------------------------------------------------------------------------------------- *
01715  * OCI_GetBigInt2
01716  * --------------------------------------------------------------------------------------------- */
01717 
01718 big_int OCI_API OCI_GetBigInt2
01719 (
01720     OCI_Resultset *rs,
01721     const mtext   *name
01722 )
01723 {
01724     return OCI_GetBigInt(rs, OCI_GetDefineIndex(rs, name));
01725 }
01726 
01727 /* --------------------------------------------------------------------------------------------- *
01728  * OCI_GetUnsignedBigInt
01729  * --------------------------------------------------------------------------------------------- */
01730 
01731 big_uint OCI_API OCI_GetUnsignedBigInt
01732 (
01733     OCI_Resultset *rs,
01734     unsigned int   index
01735 )
01736 {
01737     big_uint value = 0;
01738 
01739     OCI_DefineGetNumber(rs, index, &value, OCI_NUM_BIGUINT, sizeof(value));
01740 
01741     return value;
01742 }
01743 
01744 /* --------------------------------------------------------------------------------------------- *
01745  * OCI_GetUnsignedInt2
01746  * --------------------------------------------------------------------------------------------- */
01747 
01748 big_uint OCI_API OCI_GetUnsignedBigInt2
01749 (
01750     OCI_Resultset *rs,
01751     const mtext   *name
01752 )
01753 {
01754     return OCI_GetUnsignedBigInt(rs, OCI_GetDefineIndex(rs, name));
01755 }
01756 
01757 /* --------------------------------------------------------------------------------------------- *
01758  * OCI_GetString
01759  * --------------------------------------------------------------------------------------------- */
01760 
01761 const dtext * OCI_API OCI_GetString
01762 (
01763     OCI_Resultset *rs,
01764     unsigned int   index
01765 )
01766 {
01767     OCI_Define *def = OCI_GetDefine(rs, index);
01768     dtext *str      = NULL;
01769     boolean res     = TRUE;
01770 
01771     res = (def != NULL);
01772 
01773     if ((res == TRUE) && (OCI_NOT_NULL(def) == TRUE))
01774     {
01775         void *data = OCI_DefineGetData(def);
01776 
01777         if (def->col.type == OCI_CDT_TEXT)
01778         {
01779             str = (dtext *) data;
01780 
01781             /* for long mapped to string, the zero terminal character is not
01782                always added by Oracle ? or OCILIB issue ? Anyway we check the
01783                length returned by Oracle and set it properly */
01784 
01785             if (def->col.subtype == OCI_CLONG)
01786             {
01787                 ub2* lens = (ub2 *) def->buf.lens;
01788 
01789                 str[lens[rs->row_cur-1]] = 0;
01790             }
01791         }
01792         else
01793         {
01794             /* tries an implicit conversion if possible */
01795 
01796             if (res == TRUE)
01797             {
01798                 switch (def->col.type)
01799                 {
01800                 case OCI_CDT_NUMERIC:
01801                 {
01802                     void *ostr1 = NULL;
01803                     void *ostr2 = NULL;
01804                     int osize1  = OCI_SIZE_FORMAT_NUML * (int) sizeof(mtext);
01805                     int osize2  = OCI_SIZE_BUFFER      * (int) sizeof(dtext);
01806                     const mtext *fmt;
01807                     int pos;
01808 
01809                     res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01810 
01811                     if (res == TRUE)
01812                     {
01813                         /* init output buffer in case of OCI failure */
01814 
01815                         fmt   = OCI_GetDefaultFormatNumeric(rs->stmt->con);
01816                         ostr1 = OCI_GetInputMetaString(fmt, &osize1);
01817 
01818                         #ifndef OCI_CHARSET_MIXED
01819 
01820                         ostr2 = OCI_GetInputString(def->buf.tmpbuf, &osize2,
01821                                                    sizeof(dtext), sizeof(omtext));
01822                         #else
01823 
01824                         ostr2 = (void* ) def->buf.tmpbuf;
01825 
01826                         #endif
01827 
01828                         /* check for decimal character */
01829 
01830                         OCI_CALL1
01831                         (
01832                             res, rs->stmt->con, rs->stmt,
01833 
01834                             OCINumberToText(rs->stmt->con->err,
01835                                             (OCINumber *) data,
01836                                             (oratext *) ostr1,
01837                                             (ub4) osize1,
01838                                             (oratext *) NULL,
01839                                             (ub4) 0,
01840                                             (ub4 *) &osize2,
01841                                             (oratext *) ostr2)
01842                         )
01843 
01844                         #ifndef OCI_CHARSET_MIXED
01845 
01846                         OCI_GetOutputString(ostr2, def->buf.tmpbuf, &osize2,
01847                                             sizeof(omtext), sizeof(dtext));
01848 
01849                         #else
01850 
01851                         OCI_ConvertString(ostr2, osize2/sizeof(omtext)+1,
01852                                           sizeof(omtext), sizeof(dtext));
01853 
01854                         osize2 = (osize2/sizeof(omtext)) * sizeof(dtext);
01855 
01856                         #endif
01857 
01858                         /* do we need to suppress last '.' or ',' from integers
01859                          **/
01860 
01861                         pos = (osize2 / (int) sizeof(dtext)) - 1;
01862 
01863                         if (pos >= 0)
01864                         {
01865                             if ((def->buf.tmpbuf[pos] == DT('.')) ||
01866                                 (def->buf.tmpbuf[pos] == DT(',')))
01867                             {
01868                                 def->buf.tmpbuf[pos] = 0;
01869                             }
01870                         }
01871 
01872                         OCI_ReleaseMetaString(ostr1);
01873 
01874                         #ifndef OCI_CHARSET_MIXED
01875 
01876                         OCI_ReleaseDataString(ostr2);
01877 
01878                         #endif
01879 
01880                         str = def->buf.tmpbuf;
01881                     }
01882 
01883                     break;
01884                 }
01885                 case OCI_CDT_DATETIME:
01886                 {
01887                     OCI_Date *date   = OCI_GetDate(rs, index);
01888                     const mtext *fmt = OCI_GetDefaultFormatDate(rs->stmt->con);
01889 
01890                     if (date != NULL)
01891                     {
01892                         res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01893 
01894                         if (res == TRUE)
01895                         {
01896                             res = OCI_DateToText(date, fmt, OCI_SIZE_BUFFER,
01897                                                  (mtext *) def->buf.tmpbuf);
01898 
01899                             #ifdef OCI_CHARSET_MIXED
01900 
01901                             OCI_ConvertString(def->buf.tmpbuf,
01902                                               (int) mtslen((mtext*) def->buf.tmpbuf),
01903                                               sizeof(mtext),
01904                                               sizeof(dtext));
01905 
01906                             #endif
01907 
01908                             str = def->buf.tmpbuf;
01909                         }
01910                     }
01911 
01912                     break;
01913                 }
01914                 case OCI_CDT_TIMESTAMP:
01915                 {
01916                     OCI_Timestamp *tmsp = OCI_GetTimestamp(rs, index);
01917                     const mtext *fmt    = OCI_GetDefaultFormatDate(rs->stmt->con);
01918 
01919                     if (tmsp != NULL)
01920                     {
01921                         res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01922 
01923                         if (res == TRUE)
01924                         {
01925                             OCI_TimestampToText(tmsp, fmt, OCI_SIZE_BUFFER,
01926                                                 (mtext *) def->buf.tmpbuf,  0);
01927 
01928                             #ifdef OCI_CHARSET_MIXED
01929 
01930                             OCI_ConvertString(def->buf.tmpbuf,
01931                                               (int) mtslen((mtext*) def->buf.tmpbuf),
01932                                               sizeof(mtext),
01933                                               sizeof(dtext));
01934 
01935                             #endif
01936 
01937                             str = def->buf.tmpbuf;
01938                         }
01939                     }
01940 
01941                     break;
01942                 }
01943                 case OCI_CDT_INTERVAL:
01944                 {
01945                     OCI_Interval *itv = OCI_GetInterval(rs, index);
01946 
01947                     if (itv != NULL)
01948                     {
01949                         res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01950 
01951                         if (res == TRUE)
01952                         {
01953                             OCI_IntervalToText(OCI_GetInterval(rs, index),
01954                                                OCI_STRING_DEFAULT_PREC,
01955                                                OCI_STRING_DEFAULT_PREC,
01956                                                OCI_SIZE_BUFFER,
01957                                                (mtext *) def->buf.tmpbuf);
01958 
01959                             #ifdef OCI_CHARSET_MIXED
01960 
01961                             OCI_ConvertString(def->buf.tmpbuf,
01962                                               (int) mtslen((mtext*) def->buf.tmpbuf),
01963                                               sizeof(mtext),
01964                                               sizeof(dtext));
01965                             #endif
01966 
01967                             str = def->buf.tmpbuf;
01968                         }
01969                     }
01970 
01971                     break;
01972                 }
01973                 case OCI_CDT_LONG:
01974                 {
01975                     OCI_Long *lg = OCI_GetLong(rs, index);
01976 
01977                     if (lg != NULL)
01978                     {
01979                         str = OCI_LongGetBuffer(lg);
01980                     }
01981 
01982                     break;
01983 
01984                 }
01985                 case OCI_CDT_RAW:
01986                 {
01987                     str = (dtext *) data;
01988 
01989                     break;
01990 
01991                 }
01992                 case OCI_CDT_LOB:
01993                 {
01994                     OCI_Lob *lob = OCI_GetLob(rs, index);
01995 
01996                     if (lob != NULL)
01997                     {
01998                         big_uint len = OCI_LobGetLength(lob);
01999 
02000                         if (lob->type == OCI_BLOB)
02001                         {
02002                             len /= sizeof(dtext);
02003                         }
02004 
02005                         res = OCI_DefineRequestBuffer(def, (unsigned int) len);
02006 
02007                         if (res == TRUE)
02008                         {
02009                             res = OCI_LobRead(lob, def->buf.tmpbuf, (unsigned int) len) &&
02010                                   OCI_LobSeek(lob, 0, OCI_SEEK_SET);
02011 
02012                             str = def->buf.tmpbuf;
02013                         }
02014                     }
02015 
02016                     break;
02017 
02018                 }
02019                 case OCI_CDT_FILE:
02020                 {
02021                     OCI_File *file = OCI_GetFile(rs, index);
02022 
02023                     if (file != NULL)
02024                     {
02025                         big_uint len = OCI_FileGetSize(file) / sizeof(dtext);
02026 
02027                         res = OCI_DefineRequestBuffer(def, (unsigned int) len);
02028 
02029                         if (res == TRUE)
02030                         {
02031                             res = OCI_FileRead(file, def->buf.tmpbuf, (unsigned int) len) &&
02032                                   OCI_FileSeek(file, 0, OCI_SEEK_SET);
02033 
02034                             memset(((char*) def->buf.tmpbuf) + len, 0, sizeof(dtext));
02035 
02036                             str = def->buf.tmpbuf;
02037                         }
02038                     }
02039 
02040                     break;
02041 
02042                 }
02043                 case OCI_CDT_REF:
02044                 {
02045                     OCI_Ref *ref = OCI_GetRef(rs, index);
02046 
02047                     if (ref != NULL)
02048                     {
02049                         res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
02050 
02051                         if (res == TRUE)
02052                         {
02053                             OCI_RefToText(ref, OCI_SIZE_BUFFER, (mtext *) def->buf.tmpbuf);
02054 
02055                             #ifdef OCI_CHARSET_MIXED
02056 
02057                             OCI_ConvertString(def->buf.tmpbuf,
02058                                               (int) mtslen((mtext*) def->buf.tmpbuf),
02059                                               sizeof(mtext),
02060                                               sizeof(dtext));
02061 
02062                             #endif
02063 
02064                             str = def->buf.tmpbuf;
02065                         }
02066                     }
02067 
02068                     break;
02069                 }
02070                 default:
02071                 {
02072                     res = FALSE;
02073                 }
02074                 }
02075             }
02076         }
02077     }
02078 
02079     OCI_RESULT(res);
02080 
02081     return str;
02082 }
02083 
02084 /* --------------------------------------------------------------------------------------------- *
02085  * OCI_GetString2
02086  * --------------------------------------------------------------------------------------------- */
02087 
02088 const dtext * OCI_API OCI_GetString2
02089 (
02090     OCI_Resultset *rs,
02091     const mtext   *name
02092 )
02093 {
02094     return OCI_GetString(rs, OCI_GetDefineIndex(rs, name));
02095 }
02096 
02097 /* --------------------------------------------------------------------------------------------- *
02098  * OCI_GetRaw
02099  * --------------------------------------------------------------------------------------------- */
02100 
02101 unsigned int OCI_API OCI_GetRaw
02102 (
02103     OCI_Resultset *rs,
02104     unsigned int   index,
02105     void          *buffer,
02106     unsigned int   len
02107 )
02108 {
02109     OCI_Define *def = OCI_GetDefine(rs, index);
02110     boolean res     = TRUE;
02111     ub2 count       = (ub2) len;
02112 
02113     OCI_CHECK_PTR(OCI_IPC_VOID, buffer, 0);
02114 
02115     res = (def != NULL);
02116 
02117     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_RAW))
02118     {
02119         ub2 size = ((ub2*)def->buf.lens)[def->rs->row_cur-1];
02120 
02121         if (count > size)
02122             count = size;
02123 
02124         /* for RAWs, we copy the data in the destination buffer instead of
02125            returning internal buffer as we do for strings */
02126 
02127         memcpy(buffer, OCI_DefineGetData(def), (size_t) count);
02128 
02129     }
02130 
02131     OCI_RESULT(res);
02132 
02133     if (res == FALSE)
02134         count = 0;
02135 
02136     return (unsigned int) count;
02137 }
02138 
02139 /* --------------------------------------------------------------------------------------------- *
02140  * OCI_GetRaw2
02141  * --------------------------------------------------------------------------------------------- */
02142 
02143 unsigned int OCI_API OCI_GetRaw2
02144 (
02145     OCI_Resultset *rs,
02146     const mtext   *name,
02147     void          *buffer,
02148     unsigned int   len
02149 )
02150 {
02151     return OCI_GetRaw(rs, OCI_GetDefineIndex(rs, name), buffer, len);
02152 }
02153 
02154 /* --------------------------------------------------------------------------------------------- *
02155  * OCI_GetDouble
02156  * --------------------------------------------------------------------------------------------- */
02157 
02158 double OCI_API OCI_GetDouble
02159 (
02160     OCI_Resultset *rs,
02161     unsigned int   index
02162 )
02163 {
02164     double value = 0.0;
02165 
02166     OCI_DefineGetNumber(rs, index, &value, OCI_NUM_DOUBLE, sizeof(value));
02167 
02168     return value;
02169 }
02170 
02171 /* --------------------------------------------------------------------------------------------- *
02172  * OCI_GetDouble2
02173  * --------------------------------------------------------------------------------------------- */
02174 
02175 double OCI_API OCI_GetDouble2
02176 (
02177     OCI_Resultset *rs,
02178     const mtext   *name
02179 )
02180 {
02181     return OCI_GetDouble(rs, OCI_GetDefineIndex(rs, name));
02182 }
02183 
02184 /* --------------------------------------------------------------------------------------------- *
02185  * OCI_GetDate
02186  * --------------------------------------------------------------------------------------------- */
02187 
02188 OCI_Date * OCI_API OCI_GetDate
02189 (
02190     OCI_Resultset *rs,
02191     unsigned int   index
02192 )
02193 {
02194     OCI_Define *def = OCI_GetDefine(rs, index);
02195     OCI_Date *date  = NULL;
02196 
02197     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_DATETIME))
02198     {
02199         date =  OCI_DateInit(rs->stmt->con,
02200                              (OCI_Date **) &def->obj,
02201                              (OCIDate *) OCI_DefineGetData(def), FALSE,
02202                              (def->col.icode == SQLT_DAT));
02203     }
02204 
02205     OCI_RESULT(date != NULL);
02206 
02207     return date;
02208 }
02209 
02210 /* --------------------------------------------------------------------------------------------- *
02211  * OCI_GetDate2
02212  * --------------------------------------------------------------------------------------------- */
02213 
02214 OCI_Date * OCI_API OCI_GetDate2
02215 (
02216     OCI_Resultset *rs,
02217     const mtext   *name
02218 )
02219 {
02220     return OCI_GetDate(rs, OCI_GetDefineIndex(rs, name));
02221 }
02222 
02223 /* --------------------------------------------------------------------------------------------- *
02224  * OCI_GetTimestamp
02225  * --------------------------------------------------------------------------------------------- */
02226 
02227 OCI_Timestamp * OCI_API OCI_GetTimestamp
02228 (
02229     OCI_Resultset *rs,
02230     unsigned int   index
02231 )
02232 {
02233     OCI_Define *def     = OCI_GetDefine(rs, index);
02234     OCI_Timestamp *tmsp = NULL;
02235 
02236     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_TIMESTAMP))
02237     {
02238         tmsp =  OCI_TimestampInit(rs->stmt->con,
02239                                   (OCI_Timestamp **) &def->obj,
02240                                   (OCIDateTime *) OCI_DefineGetData(def),
02241                                   def->col.subtype);
02242     }
02243 
02244     OCI_RESULT(tmsp != NULL);
02245 
02246     return tmsp;
02247 }
02248 
02249 /* --------------------------------------------------------------------------------------------- *
02250  * OCI_GetTimestamp2
02251  * --------------------------------------------------------------------------------------------- */
02252 
02253 OCI_Timestamp * OCI_API OCI_GetTimestamp2
02254 (
02255     OCI_Resultset *rs,
02256     const mtext   *name
02257 )
02258 {
02259     return OCI_GetTimestamp(rs, OCI_GetDefineIndex(rs, name));
02260 }
02261 
02262 /* --------------------------------------------------------------------------------------------- *
02263  * OCI_GetInterval
02264  * --------------------------------------------------------------------------------------------- */
02265 
02266 OCI_Interval * OCI_API OCI_GetInterval
02267 (
02268     OCI_Resultset *rs,
02269     unsigned int   index
02270 )
02271 {
02272     OCI_Define *def   = OCI_GetDefine(rs, index);
02273     OCI_Interval *itv = NULL;
02274 
02275     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_INTERVAL))
02276     {
02277         itv = OCI_IntervalInit(rs->stmt->con,
02278                                (OCI_Interval **) &def->obj,
02279                                (OCIInterval *) OCI_DefineGetData(def),
02280                                def->col.subtype);
02281     }
02282 
02283     OCI_RESULT(itv != NULL);
02284 
02285     return itv;
02286 }
02287 
02288 /* --------------------------------------------------------------------------------------------- *
02289  * OCI_GetInterval2
02290  * --------------------------------------------------------------------------------------------- */
02291 
02292 OCI_Interval * OCI_API OCI_GetInterval2
02293 (
02294     OCI_Resultset *rs,
02295     const mtext   *name
02296 )
02297 {
02298     return OCI_GetInterval(rs, OCI_GetDefineIndex(rs, name));
02299 }
02300 
02301 /* --------------------------------------------------------------------------------------------- *
02302  * OCI_Object
02303  * --------------------------------------------------------------------------------------------- */
02304 
02305 OCI_Object * OCI_API OCI_GetObject
02306 (
02307     OCI_Resultset *rs,
02308     unsigned int   index
02309 )
02310 {
02311     OCI_Define *def = OCI_GetDefine(rs, index);
02312     OCI_Object *obj =  NULL;
02313 
02314     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_OBJECT))
02315     {
02316         obj =  OCI_ObjectInit(rs->stmt->con,
02317                               (OCI_Object **) &def->obj,
02318                               OCI_DefineGetData(def), def->col.typinf, NULL, -1,
02319                               TRUE);
02320     }
02321 
02322     OCI_RESULT(obj != NULL);
02323 
02324     return obj;
02325 }
02326 
02327 /* --------------------------------------------------------------------------------------------- *
02328  * OCI_GetObject2
02329  * --------------------------------------------------------------------------------------------- */
02330 
02331 OCI_Object * OCI_API OCI_GetObject2
02332 (
02333     OCI_Resultset *rs,
02334     const mtext   *name
02335 )
02336 {
02337     return OCI_GetObject(rs, OCI_GetDefineIndex(rs, name));
02338 }
02339 
02340 /* --------------------------------------------------------------------------------------------- *
02341  * OCI_GetColl
02342  * --------------------------------------------------------------------------------------------- */
02343 
02344 OCI_Coll * OCI_API OCI_GetColl
02345 (
02346     OCI_Resultset *rs,
02347     unsigned int   index
02348 )
02349 {
02350     OCI_Define *def = OCI_GetDefine(rs, index);
02351     OCI_Coll *coll  = NULL;
02352 
02353     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_COLLECTION))
02354     {
02355         coll = OCI_CollInit(rs->stmt->con, (OCI_Coll **) &def->obj,
02356                             OCI_DefineGetData(def), def->col.typinf);
02357     }
02358 
02359     OCI_RESULT(coll != NULL);
02360 
02361     return coll;
02362 }
02363 
02364 /* --------------------------------------------------------------------------------------------- *
02365  * OCI_GetColl2
02366  * --------------------------------------------------------------------------------------------- */
02367 
02368 OCI_Coll * OCI_API OCI_GetColl2
02369 (
02370     OCI_Resultset *rs,
02371     const mtext   *name
02372 )
02373 {
02374     return OCI_GetColl(rs, OCI_GetDefineIndex(rs, name));
02375 }
02376 
02377 /* --------------------------------------------------------------------------------------------- *
02378  * OCI_GetRef
02379  * --------------------------------------------------------------------------------------------- */
02380 
02381 OCI_Ref * OCI_API OCI_GetRef
02382 (
02383     OCI_Resultset *rs,
02384     unsigned int   index
02385 )
02386 {
02387     OCI_Define *def = OCI_GetDefine(rs, index);
02388     OCI_Ref *ref    = NULL;
02389 
02390     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_REF))
02391     {
02392         ref = OCI_RefInit(rs->stmt->con, def->col.typinf,
02393                           (OCI_Ref **) &def->obj, OCI_DefineGetData(def));
02394 
02395         /* if the ref object is retrieved from a register bind that has
02396            no type info object associated, the type info object is retrieved
02397            at the first fetch call by pinning the ref and we affect the type
02398            info object handle to the define object */
02399 
02400         if ((def->col.typinf == NULL) && (ref != NULL) && (ref->typinf != NULL))
02401         {
02402             def->col.typinf = ref->typinf;
02403         }
02404     }
02405 
02406     OCI_RESULT(ref != NULL);
02407 
02408     return ref;
02409 }
02410 
02411 /* --------------------------------------------------------------------------------------------- *
02412  * OCI_GetRef2
02413  * --------------------------------------------------------------------------------------------- */
02414 
02415 OCI_Ref * OCI_API OCI_GetRef2
02416 (
02417     OCI_Resultset *rs,
02418     const mtext   *name
02419 )
02420 {
02421     return OCI_GetRef(rs, OCI_GetDefineIndex(rs, name));
02422 }
02423 
02424 /* --------------------------------------------------------------------------------------------- *
02425  * OCI_GetStatement
02426  * --------------------------------------------------------------------------------------------- */
02427 
02428 OCI_Statement * OCI_API OCI_GetStatement
02429 (
02430     OCI_Resultset *rs,
02431     unsigned int   index
02432 )
02433 {
02434     OCI_Define *def   = OCI_GetDefine(rs, index);
02435     OCI_Statement *st = NULL;
02436 
02437     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_CURSOR))
02438     {
02439         st = OCI_StatementInit(rs->stmt->con,
02440                                (OCI_Statement **) &def->obj,
02441                                (OCIStmt *) OCI_DefineGetData(def), def);
02442     }
02443 
02444     OCI_RESULT(st != NULL);
02445 
02446     return st;
02447 }
02448 
02449 /* --------------------------------------------------------------------------------------------- *
02450  * OCI_GetStatement2
02451  * --------------------------------------------------------------------------------------------- */
02452 
02453 OCI_Statement * OCI_API OCI_GetStatement2
02454 (
02455     OCI_Resultset *rs,
02456     const mtext   *name
02457 )
02458 {
02459     return OCI_GetStatement(rs, OCI_GetDefineIndex(rs, name));
02460 }
02461 
02462 /* --------------------------------------------------------------------------------------------- *
02463  * OCI_GetLob
02464  * --------------------------------------------------------------------------------------------- */
02465 
02466 OCI_Lob * OCI_API OCI_GetLob
02467 (
02468     OCI_Resultset *rs,
02469     unsigned int   index
02470 )
02471 {
02472     OCI_Define *def = OCI_GetDefine(rs, index);
02473     OCI_Lob * lob   = NULL;
02474 
02475     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_LOB))
02476     {
02477         lob =  OCI_LobInit(rs->stmt->con,(OCI_Lob **) &def->obj,
02478                            (OCILobLocator *) OCI_DefineGetData(def),
02479                            def->col.subtype);
02480     }
02481 
02482     OCI_RESULT(lob != NULL);
02483 
02484     return lob;
02485 }
02486 
02487 /* --------------------------------------------------------------------------------------------- *
02488  * OCI_GetLob2
02489  * --------------------------------------------------------------------------------------------- */
02490 
02491 OCI_Lob * OCI_API OCI_GetLob2
02492 (
02493     OCI_Resultset *rs,
02494     const mtext   *name
02495 )
02496 {
02497     return OCI_GetLob(rs, OCI_GetDefineIndex(rs, name));
02498 }
02499 
02500 /* --------------------------------------------------------------------------------------------- *
02501  * OCI_GetFile
02502  * --------------------------------------------------------------------------------------------- */
02503 
02504 OCI_File * OCI_API OCI_GetFile
02505 (
02506     OCI_Resultset *rs,
02507     unsigned int   index
02508 )
02509 {
02510     OCI_Define *def = OCI_GetDefine(rs, index);
02511     OCI_File *file  = NULL;
02512 
02513     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_FILE))
02514     {
02515         file = OCI_FileInit(rs->stmt->con,(OCI_File **) &def->obj,
02516                             (OCILobLocator *) OCI_DefineGetData(def),
02517                             def->col.subtype);
02518     }
02519 
02520     OCI_RESULT(file != NULL);
02521 
02522     return file;
02523 }
02524 
02525 /* --------------------------------------------------------------------------------------------- *
02526  * OCI_GetFile2
02527  * --------------------------------------------------------------------------------------------- */
02528 
02529 OCI_File * OCI_API OCI_GetFile2
02530 (
02531     OCI_Resultset *rs,
02532     const mtext   *name
02533 )
02534 {
02535     return OCI_GetFile(rs, OCI_GetDefineIndex(rs, name));
02536 }
02537 
02538 /* --------------------------------------------------------------------------------------------- *
02539  * OCI_GetLong
02540  * --------------------------------------------------------------------------------------------- */
02541 
02542 OCI_Long * OCI_API OCI_GetLong
02543 (
02544     OCI_Resultset *rs,
02545     unsigned int   index
02546 )
02547 {
02548     OCI_Define *def = OCI_GetDefine(rs, index);
02549     OCI_Long *lg    = NULL;
02550 
02551     if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_LONG))
02552     {
02553         lg = (OCI_Long *) OCI_DefineGetData(def);
02554     }
02555 
02556     OCI_RESULT(lg != NULL);
02557 
02558     return lg;
02559 }
02560 
02561 /* --------------------------------------------------------------------------------------------- *
02562  * OCI_GetLong2
02563  * --------------------------------------------------------------------------------------------- */
02564 
02565 OCI_Long * OCI_API OCI_GetLong2
02566 (
02567     OCI_Resultset *rs,
02568     const mtext   *name
02569 )
02570 {
02571     return OCI_GetLong(rs, OCI_GetDefineIndex(rs, name));
02572 }
02573 
02574 /* --------------------------------------------------------------------------------------------- *
02575  * OCI_IsNull
02576  * --------------------------------------------------------------------------------------------- */
02577 
02578 boolean OCI_API OCI_IsNull
02579 (
02580     OCI_Resultset *rs,
02581     unsigned int   index
02582 )
02583 {
02584     OCI_Define *def = OCI_GetDefine(rs, index);
02585 
02586     OCI_RESULT(def != NULL);
02587 
02588     return (OCI_NOT_NULL(def) == FALSE);
02589 }
02590 
02591 /* --------------------------------------------------------------------------------------------- *
02592  * OCI_IsNull2
02593  * --------------------------------------------------------------------------------------------- */
02594 
02595 boolean OCI_API OCI_IsNull2
02596 (
02597     OCI_Resultset *rs,
02598     const mtext   *name
02599 )
02600 {
02601     return OCI_IsNull(rs, OCI_GetDefineIndex(rs, name));
02602 }
02603 
02604 /* --------------------------------------------------------------------------------------------- *
02605  * OCI_ResultsetGetStatment
02606  * --------------------------------------------------------------------------------------------- */
02607 
02608 OCI_Statement * OCI_API OCI_ResultsetGetStatement
02609 (
02610     OCI_Resultset *rs
02611 )
02612 {
02613     OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
02614 
02615     OCI_RESULT(TRUE);
02616 
02617     return rs->stmt;
02618 }
02619 
02620 /* --------------------------------------------------------------------------------------------- *
02621  * OCI_GetDataLength
02622  * --------------------------------------------------------------------------------------------- */
02623 
02624 unsigned int OCI_API OCI_GetDataLength
02625 (
02626     OCI_Resultset *rs,
02627     unsigned int   index
02628 )
02629 {
02630     OCI_Define *def     = OCI_GetDefine(rs, index);
02631     unsigned int length = 0;
02632     boolean res         = FALSE;
02633 
02634     if ((def != NULL) && (rs->row_cur > 0))
02635     {
02636         length = (unsigned int) ((ub2 *) def->buf.lens)[rs->row_cur-1];
02637         res    = TRUE;
02638     }
02639 
02640     OCI_RESULT(res);
02641 
02642     return length;
02643 }
02644 

Generated on Sun Oct 24 2010 22:02:55 for OCILIB (C Driver for Oracle) by  doxygen 1.7.1