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