OCILIB (C Driver for Oracle) 3.12.1
|
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 }