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

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

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

Generated on Mon Dec 13 2010 22:32:02 for OCILIB (C Driver for Oracle) by  doxygen 1.7.2