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