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 boolean OCI_ResultsetGetAttrInfo
00670 (
00671 OCI_Resultset *rs,
00672 unsigned int index,
00673 size_t *p_size,
00674 int *p_type
00675 )
00676 {
00677 if (index >= rs->nb_defs)
00678 {
00679 *p_size = 0;
00680 *p_type = 0;
00681
00682 return FALSE;
00683 }
00684
00685 switch (rs->defs[index].col.type)
00686 {
00687 case OCI_CDT_NUMERIC:
00688 {
00689 int type = rs->defs[index].col.subtype;
00690
00691 if (type & OCI_NUM_SHORT)
00692 {
00693 *p_type = OCI_OFT_SHORT;
00694 *p_size = sizeof(short);
00695 }
00696 else if (type & OCI_NUM_INT)
00697 {
00698 *p_type = OCI_OFT_INT;
00699 *p_size = sizeof(int);
00700 }
00701 else if (type & OCI_NUM_BIGUINT)
00702 {
00703 *p_type = OCI_OFT_BIGINT;
00704 *p_size = sizeof(big_int);
00705 }
00706 else if (type & OCI_NUM_DOUBLE)
00707 {
00708 *p_type = OCI_OFT_DOUBLE;
00709 *p_size = sizeof(double);
00710 }
00711
00712 break;
00713 }
00714 default:
00715 {
00716 *p_size = sizeof(void *);
00717 *p_type = OCI_OFT_POINTER;
00718 }
00719 }
00720
00721 return TRUE;
00722 }
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732 OCI_Resultset * OCI_API OCI_GetResultset
00733 (
00734 OCI_Statement *stmt
00735 )
00736 {
00737 OCI_Resultset *rs = NULL;
00738 boolean res = TRUE;
00739
00740 OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, NULL);
00741
00742 OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_CLOSED, NULL);
00743 OCI_CHECK_STMT_STATUS(stmt, OCI_STMT_PREPARED, NULL);
00744
00745
00746
00747
00748 if ((stmt->type != OCI_CST_SELECT) || (stmt->nb_rbinds == 0))
00749 {
00750
00751
00752 if ((stmt->rsts != NULL) && (stmt->rsts[0] != NULL))
00753 {
00754 rs = stmt->rsts[0];
00755 }
00756
00757
00758
00759 if ((rs == NULL) && (stmt->type == OCI_CST_SELECT))
00760 {
00761
00762
00763 stmt->rsts = (OCI_Resultset **) OCI_MemAlloc(OCI_IPC_RESULTSET_ARRAY,
00764 sizeof(*stmt->rsts),
00765 (size_t) 1, TRUE);
00766 if (stmt->rsts != NULL)
00767 {
00768 stmt->nb_rs = 1;
00769 stmt->cur_rs = 0;
00770
00771
00772
00773 rs = OCI_ResultsetCreate(stmt, stmt->fetch_size);
00774
00775 if (rs != NULL)
00776 stmt->rsts[0] = rs;
00777 else
00778 res = FALSE;
00779 }
00780 else
00781 res = FALSE;
00782 }
00783 }
00784
00785 OCI_RESULT(res);
00786
00787 return rs;
00788 }
00789
00790
00791
00792
00793
00794 OCI_Resultset * OCI_API OCI_GetNextResultset
00795 (
00796 OCI_Statement *stmt
00797 )
00798 {
00799 OCI_Resultset *rs = NULL;
00800
00801 OCI_CHECK_PTR(OCI_IPC_STATEMENT, stmt, NULL);
00802
00803 if (stmt->cur_rs < (stmt->nb_rs-1))
00804 rs = stmt->rsts[++stmt->cur_rs];
00805
00806 OCI_RESULT(TRUE);
00807
00808 return rs;
00809 }
00810
00811
00812
00813
00814
00815 boolean OCI_ResultsetInit
00816 (
00817 OCI_Resultset *rs
00818 )
00819 {
00820 rs->bof = TRUE;
00821 rs->eof = FALSE;
00822 rs->fetch_status = OCI_SUCCESS;
00823 rs->row_count = 0;
00824 rs->row_cur = 0;
00825 rs->row_abs = 0;
00826 rs->row_fetched = 0;
00827
00828 return TRUE;
00829 }
00830
00831
00832
00833
00834
00835 boolean OCI_ResultsetFree
00836 (
00837 OCI_Resultset *rs
00838 )
00839 {
00840 boolean res = TRUE;
00841 ub4 i, j;
00842
00843 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
00844
00845 for (i = 0; i < rs->nb_defs; i++)
00846 {
00847 OCI_Define *def = &(rs->defs[i]);
00848
00849
00850
00851 if (def->obj != NULL)
00852 {
00853
00854
00855 ((OCI_Datatype *) def->obj)->hstate = OCI_OBJECT_FETCHED_DIRTY;
00856
00857 switch (def->col.type)
00858 {
00859 case OCI_CDT_DATETIME:
00860
00861 OCI_DateFree((OCI_Date *) def->obj);
00862 break;
00863
00864 case OCI_CDT_LOB:
00865
00866 OCI_LobFree((OCI_Lob *) def->obj);
00867 break;
00868
00869 case OCI_CDT_FILE:
00870
00871 OCI_FileFree((OCI_File *) def->obj);
00872 break;
00873
00874 case OCI_CDT_CURSOR:
00875
00876 OCI_StatementClose((OCI_Statement *) def->obj);
00877 OCI_FREE(def->obj);
00878 break;
00879
00880 case OCI_CDT_OBJECT:
00881
00882 OCI_ObjectFree((OCI_Object *) def->obj);
00883 break;
00884
00885 case OCI_CDT_COLLECTION:
00886
00887 OCI_CollFree((OCI_Coll *) def->obj);
00888 break;
00889
00890 case OCI_CDT_REF:
00891
00892 OCI_RefFree((OCI_Ref *) def->obj);
00893 break;
00894
00895 case OCI_CDT_TIMESTAMP:
00896
00897 OCI_TimestampFree((OCI_Timestamp *) def->obj);
00898 break;
00899
00900 case OCI_CDT_INTERVAL:
00901
00902 OCI_IntervalFree((OCI_Interval *) def->obj);
00903 break;
00904 }
00905
00906 def->obj = NULL;
00907 }
00908
00909
00910
00911 if (def->col.dtype != 0)
00912 {
00913 if (def->col.type == OCI_CDT_CURSOR)
00914 {
00915 for(j=0; j < def->buf.count; j++)
00916 {
00917 OCI_HandleFree((dvoid *) def->buf.data[j],
00918 (ub4 ) def->col.dtype);
00919 }
00920 }
00921 else
00922 {
00923 OCI_DescriptorArrayFree((dvoid *) def->buf.data,
00924 (ub4 ) def->col.dtype,
00925 (ub4 ) def->buf.count);
00926 }
00927 }
00928
00929
00930
00931 if (def->col.type == OCI_CDT_LONG && def->buf.data != NULL)
00932 {
00933 for(j=0; j < def->buf.count; j++)
00934 {
00935 if (def->buf.data[j] != NULL)
00936 {
00937 ((OCI_Datatype *) def->buf.data[j])->hstate = OCI_OBJECT_FETCHED_DIRTY;
00938
00939 OCI_LongFree((OCI_Long *) def->buf.data[j]);
00940 }
00941 }
00942 }
00943
00944
00945
00946 OCI_FREE(def->col.name);
00947
00948
00949
00950 OCI_FREE(def->buf.data);
00951 OCI_FREE(def->buf.inds);
00952 OCI_FREE(def->buf.obj_inds);
00953 OCI_FREE(def->buf.lens);
00954 OCI_FREE(def->buf.tmpbuf);
00955 }
00956
00957
00958
00959 if (rs->map != NULL)
00960 {
00961 OCI_HashFree(rs->map);
00962 }
00963
00964
00965
00966 OCI_FREE(rs->defs);
00967
00968 OCI_FREE(rs);
00969
00970 OCI_RESULT(res);
00971
00972 return res;
00973 }
00974
00975
00976
00977
00978
00979 boolean OCI_API OCI_FetchPrev
00980 (
00981 OCI_Resultset *rs
00982 )
00983 {
00984 boolean res = TRUE;
00985 boolean err = FALSE;
00986
00987 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
00988
00989 OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
00990
00991 #if OCI_VERSION_COMPILE >= OCI_9_0
00992
00993 OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
00994
00995 if (rs->bof == FALSE)
00996 {
00997 if (rs->row_cur == 1)
00998 {
00999 if (rs->row_abs == 1)
01000 {
01001 rs->bof = TRUE;
01002 }
01003 else
01004 {
01005 int offset = 0;
01006
01007 if (rs->fetch_size > rs->row_abs)
01008 offset = 1 - rs->row_abs;
01009 else
01010 offset = 1 - (rs->fetch_size + rs->row_fetched);
01011
01012 res = OCI_FetchData(rs, OCI_SFD_RELATIVE, offset, &err);
01013
01014 if (res == TRUE)
01015 {
01016 if (rs->fetch_size > rs->row_abs)
01017 rs->row_cur = rs->row_abs-1;
01018 else
01019 rs->row_cur = rs->fetch_size;
01020
01021 rs->row_abs--;
01022 }
01023 }
01024 }
01025 else
01026 {
01027 rs->row_cur--;
01028 rs->row_abs--;
01029 }
01030
01031 rs->eof = FALSE;
01032
01033 res = ((res == TRUE) && (rs->bof == FALSE));
01034 }
01035 else
01036 res = FALSE;
01037
01038 #else
01039
01040 res = FALSE;
01041
01042 #endif
01043
01044 OCI_RESULT(err == FALSE);
01045
01046 return res;
01047 }
01048
01049
01050
01051
01052
01053 boolean OCI_API OCI_FetchNext
01054 (
01055 OCI_Resultset *rs
01056 )
01057 {
01058 boolean res = TRUE;
01059 boolean err = FALSE;
01060
01061 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01062
01063 if (rs->eof == FALSE)
01064 {
01065 if (rs->stmt->nb_rbinds == 0)
01066 {
01067
01068
01069 if ((rs->row_cur == rs->row_fetched))
01070 {
01071 if (rs->fetch_status == OCI_NO_DATA)
01072 {
01073 rs->eof = TRUE;
01074 }
01075 else
01076 {
01077 res = OCI_FetchData(rs, OCI_SFD_NEXT, 0, &err);
01078
01079 if (res == TRUE)
01080 {
01081 rs->bof = FALSE;
01082 rs->row_cur = 1;
01083
01084 rs->row_abs++;
01085 }
01086 }
01087 }
01088 else
01089 {
01090 rs->row_cur++;
01091 rs->row_abs++;
01092 }
01093 }
01094 else
01095 {
01096
01097
01098 if (rs->row_abs == 0)
01099 {
01100
01101
01102 #ifdef OCI_CHECK_DATASTRINGS
01103
01104 OCI_ResultsetExpandStrings(rs);
01105
01106 #endif
01107
01108 }
01109
01110 if (rs->row_abs >= rs->row_count)
01111 {
01112 rs->eof = TRUE;
01113 }
01114 else
01115 {
01116 rs->row_cur++;
01117 rs->row_abs++;
01118 }
01119 }
01120 }
01121 else
01122 res = FALSE;
01123
01124 OCI_RESULT(err == FALSE);
01125
01126 return ((res == TRUE) && (rs->eof == FALSE));
01127 }
01128
01129
01130
01131
01132
01133 boolean OCI_API OCI_FetchFirst
01134 (
01135 OCI_Resultset *rs
01136 )
01137 {
01138 boolean res = TRUE;
01139 boolean err = FALSE;
01140
01141 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01142
01143 OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
01144
01145 #if OCI_VERSION_COMPILE >= OCI_9_0
01146
01147 OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
01148
01149 rs->bof = FALSE;
01150 rs->eof = FALSE;
01151
01152 rs->row_abs = 1;
01153 rs->row_cur = 1;
01154
01155 res = OCI_FetchData(rs, OCI_SFD_FIRST, 0, &err);
01156
01157 #else
01158
01159 res = FALSE;
01160 err = TRUE;
01161
01162 #endif
01163
01164 OCI_RESULT(err == FALSE);
01165
01166 return ((res == TRUE) && (rs->bof == FALSE));
01167 }
01168
01169
01170
01171
01172
01173 boolean OCI_API OCI_FetchLast
01174 (
01175 OCI_Resultset *rs
01176 )
01177 {
01178 boolean res = TRUE;
01179 boolean err = FALSE;
01180
01181 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01182
01183 OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
01184
01185 #if OCI_VERSION_COMPILE >= OCI_9_0
01186
01187 OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
01188
01189 rs->bof = FALSE;
01190 rs->eof = FALSE;
01191
01192 rs->row_abs = 0;
01193 rs->row_cur = 1;
01194
01195 res = OCI_FetchData(rs, OCI_SFD_LAST, 0, &err);
01196
01197 rs->row_abs = rs->row_count;
01198
01199 #else
01200
01201 res = FALSE;
01202 err = TRUE;
01203
01204 #endif
01205
01206 OCI_RESULT(err == FALSE);
01207
01208 return ((res == TRUE) && (rs->eof != TRUE));
01209 }
01210
01211
01212
01213
01214
01215 boolean OCI_API OCI_FetchSeek
01216 (
01217 OCI_Resultset *rs,
01218 unsigned int mode,
01219 int offset
01220 )
01221 {
01222 boolean res = TRUE;
01223 boolean err = FALSE;
01224
01225 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01226
01227 OCI_CHECK_SCROLLABLE_CURSOR_ENABLED(rs->stmt->con, FALSE);
01228
01229 #if OCI_VERSION_COMPILE >= OCI_9_0
01230
01231 OCI_CHECK_SCROLLABLE_CURSOR_ACTIVATED(rs->stmt, FALSE);
01232
01233 res = OCI_FetchCustom(rs, mode, offset, &err);
01234
01235 #else
01236
01237 OCI_NOT_USED(mode);
01238 OCI_NOT_USED(offset);
01239
01240 res = FALSE;
01241 err = TRUE;
01242
01243 #endif
01244
01245 OCI_RESULT(err == FALSE);
01246
01247 return res;
01248 }
01249
01250
01251
01252
01253
01254 unsigned int OCI_API OCI_GetRowCount
01255 (
01256 OCI_Resultset *rs
01257 )
01258 {
01259 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);
01260
01261 OCI_RESULT(TRUE);
01262
01263 return rs->row_count;
01264 }
01265
01266
01267
01268
01269
01270 unsigned int OCI_API OCI_GetCurrentRow
01271 (
01272 OCI_Resultset *rs
01273 )
01274 {
01275 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);
01276
01277 OCI_RESULT(TRUE);
01278
01279 return rs->row_abs;
01280 }
01281
01282
01283
01284
01285
01286 unsigned int OCI_API OCI_GetColumnCount
01287 (
01288 OCI_Resultset *rs
01289 )
01290 {
01291 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, 0);
01292
01293 OCI_RESULT(TRUE);
01294
01295 return rs->nb_defs;
01296 }
01297
01298
01299
01300
01301
01302 OCI_Column * OCI_API OCI_GetColumn
01303 (
01304 OCI_Resultset *rs,
01305 unsigned int index
01306 )
01307 {
01308 OCI_Define *def = NULL;
01309 OCI_Column *col = NULL;
01310
01311 def = OCI_GetDefine(rs, index);
01312
01313 if (def != NULL)
01314 col = &def->col;
01315
01316 OCI_RESULT(col != NULL);
01317
01318 return col;
01319
01320 }
01321
01322
01323
01324
01325
01326 OCI_Column * OCI_API OCI_GetColumn2
01327 (
01328 OCI_Resultset *rs,
01329 const mtext *name
01330 )
01331 {
01332 OCI_Define *def = NULL;
01333 OCI_Column *col = NULL;
01334
01335 def = OCI_GetDefine(rs, OCI_GetDefineIndex(rs, name));
01336
01337 if (def != NULL)
01338 col = &def->col;
01339
01340 OCI_RESULT(col != NULL);
01341
01342 return col;
01343 }
01344
01345
01346
01347
01348
01349 unsigned int OCI_API OCI_GetColumnIndex
01350 (
01351 OCI_Resultset *rs,
01352 const mtext *name
01353 )
01354 {
01355 int index = OCI_GetDefineIndex(rs, name);
01356
01357 OCI_RESULT(index >= 1);
01358
01359 if (index <= 0)
01360 index = 0;
01361
01362 return (unsigned int) index;
01363 }
01364
01365
01366
01367
01368
01369 boolean OCI_API OCI_SetStructNumericType
01370 (
01371 OCI_Resultset *rs,
01372 unsigned int index,
01373 unsigned int type
01374 )
01375 {
01376 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01377
01378 OCI_CHECK_BOUND(rs->stmt->con, index, 1, rs->nb_defs, FALSE);
01379
01380 OCI_CHECK_COMPAT(rs->stmt->con, rs->defs[index-1].col.type == OCI_CDT_NUMERIC, FALSE);
01381
01382 rs->defs[index-1].col.subtype = type;
01383
01384 OCI_RESULT(TRUE);
01385
01386 return TRUE;
01387 }
01388
01389
01390
01391
01392
01393 boolean OCI_API OCI_SetStructNumericType2
01394 (
01395 OCI_Resultset *rs,
01396 const mtext *name,
01397 unsigned int type
01398 )
01399 {
01400 return OCI_SetStructNumericType(rs, OCI_GetDefineIndex(rs, name), type);
01401 }
01402
01403
01404
01405
01406
01407 boolean OCI_API OCI_GetStruct
01408 (
01409 OCI_Resultset *rs,
01410 void *row_struct,
01411 void *row_struct_ind
01412 )
01413 {
01414 char *ptr = NULL;
01415 boolean *inds = NULL;
01416 boolean res = TRUE;
01417 size_t size = 0;
01418 size_t size1 = 0;
01419 size_t size2 = 0;
01420 int type1 = 0;
01421 int type2 = 0;
01422
01423 ub4 i;
01424
01425 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
01426 OCI_CHECK_PTR(OCI_IPC_VOID, row_struct, FALSE);
01427
01428 ptr = row_struct;
01429 inds = row_struct_ind;
01430
01431 if (ptr != NULL)
01432 {
01433 for (i = 1; i <= rs->nb_defs; i++)
01434 {
01435 OCI_ResultsetGetAttrInfo(rs, i-1, &size1, &type1);
01436 OCI_ResultsetGetAttrInfo(rs, i, &size2, &type2);
01437
01438 switch (rs->defs[i-1].col.type)
01439 {
01440 case OCI_CDT_NUMERIC:
01441 {
01442 OCI_DefineGetNumber(rs, i, ptr,
01443 rs->defs[i-1].col.subtype,
01444 (uword) size1);
01445
01446 break;
01447 }
01448 case OCI_CDT_TEXT:
01449 {
01450 dtext **str = (dtext **) ptr;
01451
01452 *str = (dtext * ) OCI_GetString(rs, i);
01453
01454 break;
01455 }
01456 case OCI_CDT_RAW:
01457 {
01458 void **buf = (void **) ptr;
01459
01460 *buf = OCI_DefineGetData(&rs->defs[i]);
01461
01462 break;
01463 }
01464 case OCI_CDT_LONG:
01465 {
01466 OCI_Long **lg = (OCI_Long **) ptr;
01467
01468 *lg = OCI_GetLong(rs, i);
01469
01470 break;
01471 }
01472 case OCI_CDT_DATETIME:
01473 {
01474 OCI_Date **date = (OCI_Date **) ptr;
01475
01476 *date = OCI_GetDate(rs, i);
01477
01478 break;
01479 }
01480 case OCI_CDT_CURSOR:
01481 {
01482 OCI_Statement **stmt = (OCI_Statement **) ptr;
01483
01484 *stmt = OCI_GetStatement(rs, i);
01485
01486 break;
01487 }
01488 case OCI_CDT_LOB:
01489 {
01490 OCI_Lob **lob = (OCI_Lob **) ptr;
01491
01492 *lob = OCI_GetLob(rs, i);
01493
01494 break;
01495 }
01496 case OCI_CDT_FILE:
01497 {
01498 OCI_File **file = (OCI_File **) ptr;
01499
01500 *file = OCI_GetFile(rs, i);
01501
01502 break;
01503 }
01504 case OCI_CDT_TIMESTAMP:
01505 {
01506 OCI_Timestamp **tmsp = (OCI_Timestamp **) ptr;
01507
01508 *tmsp = OCI_GetTimestamp(rs, i);
01509
01510 break;
01511 }
01512 case OCI_CDT_INTERVAL:
01513 {
01514 OCI_Interval **itv = (OCI_Interval **) ptr;
01515
01516 *itv = OCI_GetInterval(rs, i);
01517
01518 break;
01519 }
01520 case OCI_CDT_OBJECT:
01521 {
01522 OCI_Object **obj = (OCI_Object **) ptr;
01523
01524 *obj = OCI_GetObject(rs, i);
01525
01526 break;
01527 }
01528 case OCI_CDT_COLLECTION:
01529 {
01530 OCI_Coll **coll = (OCI_Coll **) ptr;
01531
01532 *coll = OCI_GetColl(rs, i);
01533
01534 break;
01535 }
01536 case OCI_CDT_REF:
01537 {
01538 OCI_Ref **ref = (OCI_Ref **) ptr;
01539
01540 *ref = OCI_GetRef(rs, i);
01541
01542 break;
01543 }
01544 }
01545
01546 if ((size2 > 0) && ((size + size1) % size2))
01547 {
01548 size1 = ROUNDUP(size1, size2);
01549 }
01550
01551 size += size1;
01552
01553 ptr = ((char *) row_struct) + size;
01554
01555
01556 if (inds != NULL)
01557 {
01558 *inds = OCI_NOT_NULL(&rs->defs[i-1]);
01559
01560 inds++;
01561 }
01562 }
01563 }
01564
01565 OCI_RESULT(res);
01566
01567 return res;
01568 }
01569
01570
01571
01572
01573
01574 short OCI_API OCI_GetShort
01575 (
01576 OCI_Resultset *rs,
01577 unsigned int index
01578 )
01579 {
01580 short value = 0;
01581
01582 OCI_DefineGetNumber(rs, index, &value, OCI_NUM_SHORT, sizeof(value));
01583
01584 return value;
01585 }
01586
01587
01588
01589
01590
01591 short OCI_API OCI_GetShort2
01592 (
01593 OCI_Resultset *rs,
01594 const mtext *name
01595 )
01596 {
01597 return OCI_GetShort(rs, OCI_GetDefineIndex(rs, name));
01598 }
01599
01600
01601
01602
01603
01604 unsigned short OCI_API OCI_GetUnsignedShort
01605 (
01606 OCI_Resultset *rs,
01607 unsigned int index
01608 )
01609 {
01610 unsigned short value = 0;
01611
01612 OCI_DefineGetNumber(rs, index, &value, OCI_NUM_USHORT, sizeof(value));
01613
01614 return value;
01615 }
01616
01617
01618
01619
01620
01621 unsigned short OCI_API OCI_GetUnsignedShort2
01622 (
01623 OCI_Resultset *rs,
01624 const mtext *name
01625 )
01626 {
01627 return OCI_GetUnsignedShort(rs, OCI_GetDefineIndex(rs, name));
01628 }
01629
01630
01631
01632
01633
01634 int OCI_API OCI_GetInt
01635 (
01636 OCI_Resultset *rs,
01637 unsigned int index
01638 )
01639 {
01640 int value = 0;
01641
01642 OCI_DefineGetNumber(rs, index, &value, OCI_NUM_INT, sizeof(value));
01643
01644 return value;
01645 }
01646
01647
01648
01649
01650
01651 int OCI_API OCI_GetInt2
01652 (
01653 OCI_Resultset *rs,
01654 const mtext *name
01655 )
01656 {
01657 return OCI_GetInt(rs, OCI_GetDefineIndex(rs, name));
01658 }
01659
01660
01661
01662
01663
01664 unsigned int OCI_API OCI_GetUnsignedInt
01665 (
01666 OCI_Resultset *rs,
01667 unsigned int index
01668 )
01669 {
01670 unsigned int value = 0;
01671
01672 OCI_DefineGetNumber(rs, index, &value, OCI_NUM_UINT, sizeof(value));
01673
01674 return value;
01675 }
01676
01677
01678
01679
01680
01681 unsigned int OCI_API OCI_GetUnsignedInt2
01682 (
01683 OCI_Resultset *rs,
01684 const mtext *name
01685 )
01686 {
01687 return OCI_GetUnsignedInt(rs, OCI_GetDefineIndex(rs, name));
01688 }
01689
01690
01691
01692
01693
01694 big_int OCI_API OCI_GetBigInt
01695 (
01696 OCI_Resultset *rs,
01697 unsigned int index
01698 )
01699 {
01700 big_int value = 0;
01701
01702 OCI_DefineGetNumber(rs, index, &value, OCI_NUM_BIGINT, sizeof(value));
01703
01704 return value;
01705 }
01706
01707
01708
01709
01710
01711 big_int OCI_API OCI_GetBigInt2
01712 (
01713 OCI_Resultset *rs,
01714 const mtext *name
01715 )
01716 {
01717 return OCI_GetBigInt(rs, OCI_GetDefineIndex(rs, name));
01718 }
01719
01720
01721
01722
01723
01724 big_uint OCI_API OCI_GetUnsignedBigInt
01725 (
01726 OCI_Resultset *rs,
01727 unsigned int index
01728 )
01729 {
01730 big_uint value = 0;
01731
01732 OCI_DefineGetNumber(rs, index, &value, OCI_NUM_BIGUINT, sizeof(value));
01733
01734 return value;
01735 }
01736
01737
01738
01739
01740
01741 big_uint OCI_API OCI_GetUnsignedBigInt2
01742 (
01743 OCI_Resultset *rs,
01744 const mtext *name
01745 )
01746 {
01747 return OCI_GetUnsignedBigInt(rs, OCI_GetDefineIndex(rs, name));
01748 }
01749
01750
01751
01752
01753
01754 const dtext * OCI_API OCI_GetString
01755 (
01756 OCI_Resultset *rs,
01757 unsigned int index
01758 )
01759 {
01760 OCI_Define *def = OCI_GetDefine(rs, index);
01761 dtext *str = NULL;
01762 boolean res = TRUE;
01763
01764 res = (def != NULL);
01765
01766 if ((res == TRUE) && (OCI_NOT_NULL(def) == TRUE))
01767 {
01768 void *data = OCI_DefineGetData(def);
01769
01770 if (def->col.type == OCI_CDT_TEXT)
01771 {
01772 str = (dtext *) data;
01773
01774
01775
01776
01777
01778 if (def->col.subtype == OCI_CLONG)
01779 {
01780 ub2* lens = (ub2 *) def->buf.lens;
01781
01782 str[lens[rs->row_cur-1]] = 0;
01783 }
01784 }
01785 else
01786 {
01787
01788
01789 if (res == TRUE)
01790 {
01791 switch (def->col.type)
01792 {
01793 case OCI_CDT_NUMERIC:
01794 {
01795 void *ostr1 = NULL;
01796 void *ostr2 = NULL;
01797 int osize1 = OCI_SIZE_FORMAT_NUML * (int) sizeof(mtext);
01798 int osize2 = OCI_SIZE_BUFFER * (int) sizeof(dtext);
01799 const mtext *fmt;
01800 int pos;
01801
01802 res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01803
01804 if (res == TRUE)
01805 {
01806
01807
01808 fmt = OCI_GetDefaultFormatNumeric(rs->stmt->con);
01809 ostr1 = OCI_GetInputMetaString(fmt, &osize1);
01810
01811 #ifndef OCI_CHARSET_MIXED
01812
01813 ostr2 = OCI_GetInputString(def->buf.tmpbuf, &osize2,
01814 sizeof(dtext), sizeof(omtext));
01815 #else
01816
01817 ostr2 = (void* ) def->buf.tmpbuf;
01818
01819 #endif
01820
01821
01822
01823 OCI_CALL1
01824 (
01825 res, rs->stmt->con, rs->stmt,
01826
01827 OCINumberToText(rs->stmt->con->err,
01828 (OCINumber *) data,
01829 (oratext *) ostr1,
01830 (ub4) osize1,
01831 (oratext *) NULL,
01832 (ub4) 0,
01833 (ub4 *) &osize2,
01834 (oratext *) ostr2)
01835 )
01836
01837 #ifndef OCI_CHARSET_MIXED
01838
01839 OCI_GetOutputString(ostr2, def->buf.tmpbuf, &osize2,
01840 sizeof(omtext), sizeof(dtext));
01841
01842 #else
01843
01844 OCI_ConvertString(ostr2, osize2/sizeof(omtext)+1,
01845 sizeof(omtext), sizeof(dtext));
01846
01847 osize2 = (osize2/sizeof(omtext)) * sizeof(dtext);
01848
01849 #endif
01850
01851
01852
01853
01854 pos = (osize2 / (int) sizeof(dtext)) - 1;
01855
01856 if (pos >= 0)
01857 {
01858 if ((def->buf.tmpbuf[pos] == DT('.')) ||
01859 (def->buf.tmpbuf[pos] == DT(',')))
01860 {
01861 def->buf.tmpbuf[pos] = 0;
01862 }
01863 }
01864
01865 OCI_ReleaseMetaString(ostr1);
01866
01867 #ifndef OCI_CHARSET_MIXED
01868
01869 OCI_ReleaseDataString(ostr2);
01870
01871 #endif
01872
01873 str = def->buf.tmpbuf;
01874 }
01875
01876 break;
01877 }
01878 case OCI_CDT_DATETIME:
01879 {
01880 OCI_Date *date = OCI_GetDate(rs, index);
01881 const mtext *fmt = OCI_GetDefaultFormatDate(rs->stmt->con);
01882
01883 if (date != NULL)
01884 {
01885 res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01886
01887 if (res == TRUE)
01888 {
01889 res = OCI_DateToText(date, fmt, OCI_SIZE_BUFFER,
01890 (mtext *) def->buf.tmpbuf);
01891
01892 #ifdef OCI_CHARSET_MIXED
01893
01894 OCI_ConvertString(def->buf.tmpbuf,
01895 (int) mtslen((mtext*) def->buf.tmpbuf),
01896 sizeof(mtext),
01897 sizeof(dtext));
01898
01899 #endif
01900
01901 str = def->buf.tmpbuf;
01902 }
01903 }
01904
01905 break;
01906 }
01907 case OCI_CDT_TIMESTAMP:
01908 {
01909 OCI_Timestamp *tmsp = OCI_GetTimestamp(rs, index);
01910 const mtext *fmt = OCI_GetDefaultFormatDate(rs->stmt->con);
01911
01912 if (tmsp != NULL)
01913 {
01914 res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01915
01916 if (res == TRUE)
01917 {
01918 OCI_TimestampToText(tmsp, fmt, OCI_SIZE_BUFFER,
01919 (mtext *) def->buf.tmpbuf, 0);
01920
01921 #ifdef OCI_CHARSET_MIXED
01922
01923 OCI_ConvertString(def->buf.tmpbuf,
01924 (int) mtslen((mtext*) def->buf.tmpbuf),
01925 sizeof(mtext),
01926 sizeof(dtext));
01927
01928 #endif
01929
01930 str = def->buf.tmpbuf;
01931 }
01932 }
01933
01934 break;
01935 }
01936 case OCI_CDT_INTERVAL:
01937 {
01938 OCI_Interval *itv = OCI_GetInterval(rs, index);
01939
01940 if (itv != NULL)
01941 {
01942 res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
01943
01944 if (res == TRUE)
01945 {
01946 OCI_IntervalToText(OCI_GetInterval(rs, index),
01947 OCI_STRING_DEFAULT_PREC,
01948 OCI_STRING_DEFAULT_PREC,
01949 OCI_SIZE_BUFFER,
01950 (mtext *) def->buf.tmpbuf);
01951
01952 #ifdef OCI_CHARSET_MIXED
01953
01954 OCI_ConvertString(def->buf.tmpbuf,
01955 (int) mtslen((mtext*) def->buf.tmpbuf),
01956 sizeof(mtext),
01957 sizeof(dtext));
01958 #endif
01959
01960 str = def->buf.tmpbuf;
01961 }
01962 }
01963
01964 break;
01965 }
01966 case OCI_CDT_LONG:
01967 {
01968 OCI_Long *lg = OCI_GetLong(rs, index);
01969
01970 if (lg != NULL)
01971 {
01972 str = OCI_LongGetBuffer(lg);
01973 }
01974
01975 break;
01976
01977 }
01978 case OCI_CDT_RAW:
01979 {
01980 str = (dtext *) data;
01981
01982 break;
01983
01984 }
01985 case OCI_CDT_LOB:
01986 {
01987 OCI_Lob *lob = OCI_GetLob(rs, index);
01988
01989 if (lob != NULL)
01990 {
01991 big_uint len = OCI_LobGetLength(lob);
01992
01993 if (lob->type == OCI_BLOB)
01994 {
01995 len /= sizeof(dtext);
01996 }
01997
01998 res = OCI_DefineRequestBuffer(def, (unsigned int) len);
01999
02000 if (res == TRUE)
02001 {
02002 res = OCI_LobRead(lob, def->buf.tmpbuf, (unsigned int) len) &&
02003 OCI_LobSeek(lob, 0, OCI_SEEK_SET);
02004
02005 str = def->buf.tmpbuf;
02006 }
02007 }
02008
02009 break;
02010
02011 }
02012 case OCI_CDT_FILE:
02013 {
02014 OCI_File *file = OCI_GetFile(rs, index);
02015
02016 if (file != NULL)
02017 {
02018 big_uint len = OCI_FileGetSize(file) / sizeof(dtext);
02019
02020 res = OCI_DefineRequestBuffer(def, (unsigned int) len);
02021
02022 if (res == TRUE)
02023 {
02024 res = OCI_FileRead(file, def->buf.tmpbuf, (unsigned int) len) &&
02025 OCI_FileSeek(file, 0, OCI_SEEK_SET);
02026
02027 memset(((char*) def->buf.tmpbuf) + len, 0, sizeof(dtext));
02028
02029 str = def->buf.tmpbuf;
02030 }
02031 }
02032
02033 break;
02034
02035 }
02036 case OCI_CDT_REF:
02037 {
02038 OCI_Ref *ref = OCI_GetRef(rs, index);
02039
02040 if (ref != NULL)
02041 {
02042 res = OCI_DefineRequestBuffer(def, OCI_SIZE_BUFFER);
02043
02044 if (res == TRUE)
02045 {
02046 OCI_RefToText(ref, OCI_SIZE_BUFFER, (mtext *) def->buf.tmpbuf);
02047
02048 #ifdef OCI_CHARSET_MIXED
02049
02050 OCI_ConvertString(def->buf.tmpbuf,
02051 (int) mtslen((mtext*) def->buf.tmpbuf),
02052 sizeof(mtext),
02053 sizeof(dtext));
02054
02055 #endif
02056
02057 str = def->buf.tmpbuf;
02058 }
02059 }
02060
02061 break;
02062 }
02063 default:
02064 {
02065 res = FALSE;
02066 }
02067 }
02068 }
02069 }
02070 }
02071
02072 OCI_RESULT(res);
02073
02074 return str;
02075 }
02076
02077
02078
02079
02080
02081 const dtext * OCI_API OCI_GetString2
02082 (
02083 OCI_Resultset *rs,
02084 const mtext *name
02085 )
02086 {
02087 return OCI_GetString(rs, OCI_GetDefineIndex(rs, name));
02088 }
02089
02090
02091
02092
02093
02094 unsigned int OCI_API OCI_GetRaw
02095 (
02096 OCI_Resultset *rs,
02097 unsigned int index,
02098 void *buffer,
02099 unsigned int len
02100 )
02101 {
02102 OCI_Define *def = OCI_GetDefine(rs, index);
02103 boolean res = TRUE;
02104 ub2 count = (ub2) len;
02105
02106 OCI_CHECK_PTR(OCI_IPC_VOID, buffer, 0);
02107
02108 res = (def != NULL);
02109
02110 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_RAW))
02111 {
02112 ub2 size = ((ub2*)def->buf.lens)[def->rs->row_cur-1];
02113
02114 if (count > size)
02115 count = size;
02116
02117
02118
02119
02120 memcpy(buffer, OCI_DefineGetData(def), (size_t) count);
02121
02122 }
02123
02124 OCI_RESULT(res);
02125
02126 if (res == FALSE)
02127 count = 0;
02128
02129 return (unsigned int) count;
02130 }
02131
02132
02133
02134
02135
02136 unsigned int OCI_API OCI_GetRaw2
02137 (
02138 OCI_Resultset *rs,
02139 const mtext *name,
02140 void *buffer,
02141 unsigned int len
02142 )
02143 {
02144 return OCI_GetRaw(rs, OCI_GetDefineIndex(rs, name), buffer, len);
02145 }
02146
02147
02148
02149
02150
02151 double OCI_API OCI_GetDouble
02152 (
02153 OCI_Resultset *rs,
02154 unsigned int index
02155 )
02156 {
02157 double value = 0.0;
02158
02159 OCI_DefineGetNumber(rs, index, &value, OCI_NUM_DOUBLE, sizeof(value));
02160
02161 return value;
02162 }
02163
02164
02165
02166
02167
02168 double OCI_API OCI_GetDouble2
02169 (
02170 OCI_Resultset *rs,
02171 const mtext *name
02172 )
02173 {
02174 return OCI_GetDouble(rs, OCI_GetDefineIndex(rs, name));
02175 }
02176
02177
02178
02179
02180
02181 OCI_Date * OCI_API OCI_GetDate
02182 (
02183 OCI_Resultset *rs,
02184 unsigned int index
02185 )
02186 {
02187 OCI_Define *def = OCI_GetDefine(rs, index);
02188 OCI_Date *date = NULL;
02189
02190 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_DATETIME))
02191 {
02192 date = OCI_DateInit(rs->stmt->con,
02193 (OCI_Date **) &def->obj,
02194 (OCIDate *) OCI_DefineGetData(def), FALSE,
02195 (def->col.icode == SQLT_DAT));
02196 }
02197
02198 OCI_RESULT(date != NULL);
02199
02200 return date;
02201 }
02202
02203
02204
02205
02206
02207 OCI_Date * OCI_API OCI_GetDate2
02208 (
02209 OCI_Resultset *rs,
02210 const mtext *name
02211 )
02212 {
02213 return OCI_GetDate(rs, OCI_GetDefineIndex(rs, name));
02214 }
02215
02216
02217
02218
02219
02220 OCI_Timestamp * OCI_API OCI_GetTimestamp
02221 (
02222 OCI_Resultset *rs,
02223 unsigned int index
02224 )
02225 {
02226 OCI_Define *def = OCI_GetDefine(rs, index);
02227 OCI_Timestamp *tmsp = NULL;
02228
02229 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_TIMESTAMP))
02230 {
02231 tmsp = OCI_TimestampInit(rs->stmt->con,
02232 (OCI_Timestamp **) &def->obj,
02233 (OCIDateTime *) OCI_DefineGetData(def),
02234 def->col.subtype);
02235 }
02236
02237 OCI_RESULT(tmsp != NULL);
02238
02239 return tmsp;
02240 }
02241
02242
02243
02244
02245
02246 OCI_Timestamp * OCI_API OCI_GetTimestamp2
02247 (
02248 OCI_Resultset *rs,
02249 const mtext *name
02250 )
02251 {
02252 return OCI_GetTimestamp(rs, OCI_GetDefineIndex(rs, name));
02253 }
02254
02255
02256
02257
02258
02259 OCI_Interval * OCI_API OCI_GetInterval
02260 (
02261 OCI_Resultset *rs,
02262 unsigned int index
02263 )
02264 {
02265 OCI_Define *def = OCI_GetDefine(rs, index);
02266 OCI_Interval *itv = NULL;
02267
02268 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_INTERVAL))
02269 {
02270 itv = OCI_IntervalInit(rs->stmt->con,
02271 (OCI_Interval **) &def->obj,
02272 (OCIInterval *) OCI_DefineGetData(def),
02273 def->col.subtype);
02274 }
02275
02276 OCI_RESULT(itv != NULL);
02277
02278 return itv;
02279 }
02280
02281
02282
02283
02284
02285 OCI_Interval * OCI_API OCI_GetInterval2
02286 (
02287 OCI_Resultset *rs,
02288 const mtext *name
02289 )
02290 {
02291 return OCI_GetInterval(rs, OCI_GetDefineIndex(rs, name));
02292 }
02293
02294
02295
02296
02297
02298 OCI_Object * OCI_API OCI_GetObject
02299 (
02300 OCI_Resultset *rs,
02301 unsigned int index
02302 )
02303 {
02304 OCI_Define *def = OCI_GetDefine(rs, index);
02305 OCI_Object *obj = NULL;
02306
02307 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_OBJECT))
02308 {
02309 obj = OCI_ObjectInit(rs->stmt->con,
02310 (OCI_Object **) &def->obj,
02311 OCI_DefineGetData(def), def->col.typinf, NULL, -1,
02312 TRUE);
02313 }
02314
02315 OCI_RESULT(obj != NULL);
02316
02317 return obj;
02318 }
02319
02320
02321
02322
02323
02324 OCI_Object * OCI_API OCI_GetObject2
02325 (
02326 OCI_Resultset *rs,
02327 const mtext *name
02328 )
02329 {
02330 return OCI_GetObject(rs, OCI_GetDefineIndex(rs, name));
02331 }
02332
02333
02334
02335
02336
02337 OCI_Coll * OCI_API OCI_GetColl
02338 (
02339 OCI_Resultset *rs,
02340 unsigned int index
02341 )
02342 {
02343 OCI_Define *def = OCI_GetDefine(rs, index);
02344 OCI_Coll *coll = NULL;
02345
02346 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_COLLECTION))
02347 {
02348 coll = OCI_CollInit(rs->stmt->con, (OCI_Coll **) &def->obj,
02349 OCI_DefineGetData(def), def->col.typinf);
02350 }
02351
02352 OCI_RESULT(coll != NULL);
02353
02354 return coll;
02355 }
02356
02357
02358
02359
02360
02361 OCI_Coll * OCI_API OCI_GetColl2
02362 (
02363 OCI_Resultset *rs,
02364 const mtext *name
02365 )
02366 {
02367 return OCI_GetColl(rs, OCI_GetDefineIndex(rs, name));
02368 }
02369
02370
02371
02372
02373
02374 OCI_Ref * OCI_API OCI_GetRef
02375 (
02376 OCI_Resultset *rs,
02377 unsigned int index
02378 )
02379 {
02380 OCI_Define *def = OCI_GetDefine(rs, index);
02381 OCI_Ref *ref = NULL;
02382
02383 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_REF))
02384 {
02385 ref = OCI_RefInit(rs->stmt->con, def->col.typinf,
02386 (OCI_Ref **) &def->obj, OCI_DefineGetData(def));
02387
02388
02389
02390
02391
02392
02393 if ((def->col.typinf == NULL) && (ref != NULL) && (ref->typinf != NULL))
02394 {
02395 def->col.typinf = ref->typinf;
02396 }
02397 }
02398
02399 OCI_RESULT(ref != NULL);
02400
02401 return ref;
02402 }
02403
02404
02405
02406
02407
02408 OCI_Ref * OCI_API OCI_GetRef2
02409 (
02410 OCI_Resultset *rs,
02411 const mtext *name
02412 )
02413 {
02414 return OCI_GetRef(rs, OCI_GetDefineIndex(rs, name));
02415 }
02416
02417
02418
02419
02420
02421 OCI_Statement * OCI_API OCI_GetStatement
02422 (
02423 OCI_Resultset *rs,
02424 unsigned int index
02425 )
02426 {
02427 OCI_Define *def = OCI_GetDefine(rs, index);
02428 OCI_Statement *st = NULL;
02429
02430 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_CURSOR))
02431 {
02432 st = OCI_StatementInit(rs->stmt->con,
02433 (OCI_Statement **) &def->obj,
02434 (OCIStmt *) OCI_DefineGetData(def), def);
02435 }
02436
02437 OCI_RESULT(st != NULL);
02438
02439 return st;
02440 }
02441
02442
02443
02444
02445
02446 OCI_Statement * OCI_API OCI_GetStatement2
02447 (
02448 OCI_Resultset *rs,
02449 const mtext *name
02450 )
02451 {
02452 return OCI_GetStatement(rs, OCI_GetDefineIndex(rs, name));
02453 }
02454
02455
02456
02457
02458
02459 OCI_Lob * OCI_API OCI_GetLob
02460 (
02461 OCI_Resultset *rs,
02462 unsigned int index
02463 )
02464 {
02465 OCI_Define *def = OCI_GetDefine(rs, index);
02466 OCI_Lob * lob = NULL;
02467
02468 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_LOB))
02469 {
02470 lob = OCI_LobInit(rs->stmt->con,(OCI_Lob **) &def->obj,
02471 (OCILobLocator *) OCI_DefineGetData(def),
02472 def->col.subtype);
02473 }
02474
02475 OCI_RESULT(lob != NULL);
02476
02477 return lob;
02478 }
02479
02480
02481
02482
02483
02484 OCI_Lob * OCI_API OCI_GetLob2
02485 (
02486 OCI_Resultset *rs,
02487 const mtext *name
02488 )
02489 {
02490 return OCI_GetLob(rs, OCI_GetDefineIndex(rs, name));
02491 }
02492
02493
02494
02495
02496
02497 OCI_File * OCI_API OCI_GetFile
02498 (
02499 OCI_Resultset *rs,
02500 unsigned int index
02501 )
02502 {
02503 OCI_Define *def = OCI_GetDefine(rs, index);
02504 OCI_File *file = NULL;
02505
02506 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_FILE))
02507 {
02508 file = OCI_FileInit(rs->stmt->con,(OCI_File **) &def->obj,
02509 (OCILobLocator *) OCI_DefineGetData(def),
02510 def->col.subtype);
02511 }
02512
02513 OCI_RESULT(file != NULL);
02514
02515 return file;
02516 }
02517
02518
02519
02520
02521
02522 OCI_File * OCI_API OCI_GetFile2
02523 (
02524 OCI_Resultset *rs,
02525 const mtext *name
02526 )
02527 {
02528 return OCI_GetFile(rs, OCI_GetDefineIndex(rs, name));
02529 }
02530
02531
02532
02533
02534
02535 OCI_Long * OCI_API OCI_GetLong
02536 (
02537 OCI_Resultset *rs,
02538 unsigned int index
02539 )
02540 {
02541 OCI_Define *def = OCI_GetDefine(rs, index);
02542 OCI_Long *lg = NULL;
02543
02544 if ((OCI_NOT_NULL(def) == TRUE) && (def->col.type == OCI_CDT_LONG))
02545 {
02546 lg = (OCI_Long *) OCI_DefineGetData(def);
02547 }
02548
02549 OCI_RESULT(lg != NULL);
02550
02551 return lg;
02552 }
02553
02554
02555
02556
02557
02558 OCI_Long * OCI_API OCI_GetLong2
02559 (
02560 OCI_Resultset *rs,
02561 const mtext *name
02562 )
02563 {
02564 return OCI_GetLong(rs, OCI_GetDefineIndex(rs, name));
02565 }
02566
02567
02568
02569
02570
02571 boolean OCI_API OCI_IsNull
02572 (
02573 OCI_Resultset *rs,
02574 unsigned int index
02575 )
02576 {
02577 OCI_Define *def = OCI_GetDefine(rs, index);
02578
02579 OCI_RESULT(def != NULL);
02580
02581 return (OCI_NOT_NULL(def) == FALSE);
02582 }
02583
02584
02585
02586
02587
02588 boolean OCI_API OCI_IsNull2
02589 (
02590 OCI_Resultset *rs,
02591 const mtext *name
02592 )
02593 {
02594 return OCI_IsNull(rs, OCI_GetDefineIndex(rs, name));
02595 }
02596
02597
02598
02599
02600
02601 OCI_Statement * OCI_API OCI_ResultsetGetStatement
02602 (
02603 OCI_Resultset *rs
02604 )
02605 {
02606 OCI_CHECK_PTR(OCI_IPC_RESULTSET, rs, FALSE);
02607
02608 OCI_RESULT(TRUE);
02609
02610 return rs->stmt;
02611 }
02612
02613
02614
02615
02616
02617 unsigned int OCI_API OCI_GetDataLength
02618 (
02619 OCI_Resultset *rs,
02620 unsigned int index
02621 )
02622 {
02623 OCI_Define *def = OCI_GetDefine(rs, index);
02624 unsigned int length = 0;
02625 boolean res = FALSE;
02626
02627 if ((def != NULL) && (rs->row_cur > 0))
02628 {
02629 length = (unsigned int) ((ub2 *) def->buf.lens)[rs->row_cur-1];
02630 res = TRUE;
02631 }
02632
02633 OCI_RESULT(res);
02634
02635 return length;
02636 }
02637