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