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