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_DirPath * OCI_API OCI_DirPathCreate
00046 (
00047 OCI_TypeInfo *typinf,
00048 const mtext *partition,
00049 unsigned int nb_cols,
00050 unsigned int nb_rows
00051 )
00052 {
00053 OCI_DirPath *dp = NULL;
00054
00055 void *ostr = NULL;
00056 int osize = -1;
00057
00058 boolean res = TRUE;
00059
00060 OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00061
00062 OCI_CHECK_COMPAT(typinf->con, typinf->type != OCI_TIF_TYPE, NULL);
00063 OCI_CHECK_BOUND(typinf->con, nb_cols, 1, typinf->nb_cols, NULL);
00064
00065
00066
00067 dp = (OCI_DirPath *) OCI_MemAlloc(OCI_IPC_DIRPATH, sizeof(*dp),
00068 (size_t) 1, TRUE);
00069
00070 if (dp != NULL)
00071 {
00072 dp->con = typinf->con;
00073 dp->status = OCI_DPS_NOT_PREPARED;
00074 dp->typinf = typinf;
00075 dp->nb_rows = (ub2) nb_rows;
00076 dp->nb_cols = (ub2) nb_cols;
00077 dp->nb_cur = (ub2) dp->nb_rows;
00078 dp->err_col = 0;
00079 dp->err_row = 0;
00080 dp->nb_prcsd = 0;
00081
00082
00083
00084 if (res == TRUE)
00085 {
00086 res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) OCILib.env,
00087 (dvoid **) (void *) &dp->ctx,
00088 (ub4) OCI_HTYPE_DIRPATH_CTX,
00089 (size_t) 0, (dvoid **) NULL));
00090 }
00091
00092
00093
00094 if (res == TRUE)
00095 {
00096 osize = -1;
00097 ostr = OCI_GetInputMetaString(dp->typinf->name, &osize);
00098
00099 OCI_CALL2
00100 (
00101 res, dp->con,
00102
00103 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
00104 (dvoid *) ostr, (ub4) osize,
00105 (ub4) OCI_ATTR_NAME, dp->con->err)
00106 )
00107
00108 OCI_ReleaseMetaString(ostr);
00109 }
00110
00111
00112
00113 if ((res == TRUE) && (dp->typinf->schema != NULL) && (dp->typinf->schema[0] != 0))
00114 {
00115 osize = -1;
00116 ostr = OCI_GetInputMetaString(dp->typinf->schema, &osize);
00117
00118 OCI_CALL2
00119 (
00120 res, dp->con,
00121
00122 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
00123 (dvoid *) ostr, (ub4) osize,
00124 (ub4) OCI_ATTR_SCHEMA_NAME, dp->con->err)
00125 )
00126
00127 OCI_ReleaseMetaString(ostr);
00128 }
00129
00130
00131
00132 if ((res == TRUE) && (partition != NULL) && (partition[0] != 0))
00133 {
00134 osize = -1;
00135 ostr = OCI_GetInputMetaString(partition, &osize);
00136
00137 OCI_CALL2
00138 (
00139 res, dp->con,
00140
00141 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
00142 (dvoid *) ostr, (ub4) osize,
00143 (ub4) OCI_ATTR_SUB_NAME, dp->con->err)
00144 )
00145
00146 OCI_ReleaseMetaString(ostr);
00147 }
00148
00149 if (OCILib.version_runtime >= OCI_9_0)
00150 {
00151 ub4 num_rows = dp->nb_rows;
00152
00153
00154
00155 OCI_CALL2
00156 (
00157 res, dp->con,
00158
00159 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
00160 (dvoid *) &num_rows, (ub4) sizeof(num_rows),
00161 (ub4) OCI_ATTR_NUM_ROWS, dp->con->err)
00162 )
00163 }
00164
00165
00166
00167 OCI_CALL2
00168 (
00169 res, dp->con,
00170
00171 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
00172 (dvoid *) &dp->nb_cols, (ub4) sizeof(dp->nb_cols),
00173 (ub4) OCI_ATTR_NUM_COLS, dp->con->err)
00174 )
00175
00176
00177
00178 if (res == TRUE)
00179 {
00180 dp->cols = (void *) OCI_MemAlloc(OCI_IPC_DP_COL_ARRAY,
00181 sizeof(OCI_DirPathColumn),
00182 (size_t) dp->nb_cols, TRUE);
00183
00184 res = (dp->cols != NULL);
00185 }
00186 }
00187 else
00188 res = FALSE;
00189
00190
00191
00192 if (res == FALSE)
00193 {
00194 OCI_DirPathFree(dp);
00195 dp = NULL;
00196 }
00197
00198 OCI_RESULT(res);
00199
00200 return dp;
00201 }
00202
00203
00204
00205
00206
00207 boolean OCI_API OCI_DirPathFree
00208 (
00209 OCI_DirPath *dp
00210 )
00211 {
00212 ub2 i;
00213
00214 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
00215
00216 for (i = 0; i < dp->nb_cols; i++)
00217 {
00218 OCI_FREE(dp->cols[i].data);
00219 OCI_FREE(dp->cols[i].lens);
00220 OCI_FREE(dp->cols[i].flags);
00221 OCI_FREE(dp->cols[i].format);
00222 }
00223
00224 OCI_FREE(dp->cols);
00225
00226 OCI_HandleFree(dp->strm, OCI_HTYPE_DIRPATH_STREAM);
00227 OCI_HandleFree(dp->arr, OCI_HTYPE_DIRPATH_COLUMN_ARRAY);
00228 OCI_HandleFree(dp->ctx, OCI_HTYPE_DIRPATH_CTX);
00229
00230 OCI_FREE(dp);
00231
00232 OCI_RESULT(TRUE);
00233
00234 return TRUE;
00235 }
00236
00237
00238
00239
00240
00241 boolean OCI_API OCI_DirPathSetColumn
00242 (
00243 OCI_DirPath *dp,
00244 unsigned int index,
00245 const mtext *name,
00246 unsigned int maxsize,
00247 const mtext *format
00248 )
00249 {
00250 OCI_DirPathColumn *dpcol = NULL;
00251 OCI_Column *col = NULL;
00252 OCIParam *hattr = NULL;
00253 OCIParam *hlist = NULL;
00254 void *ostr = NULL;
00255 int osize = -1;
00256 boolean res = TRUE;
00257 ub2 i;
00258
00259 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
00260 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_NOT_PREPARED, FALSE);
00261 OCI_CHECK_PTR(OCI_IPC_STRING, name, FALSE);
00262 OCI_CHECK_BOUND(dp->con, index, 1, dp->nb_cols, FALSE);
00263
00264
00265
00266 for (i = 0; i < dp->typinf->nb_cols; i++)
00267 {
00268 if (mtscasecmp(name, dp->typinf->cols[i].name) == 0)
00269 {
00270 break;
00271 }
00272 }
00273
00274
00275
00276 if (i >= dp->typinf->nb_cols)
00277 {
00278 OCI_ExceptionDirPathColNotFound(dp, name, dp->typinf->name);
00279
00280 res = FALSE;
00281 }
00282
00283
00284
00285 if (res == TRUE)
00286 {
00287 col = &dp->typinf->cols[i];
00288 dpcol = &dp->cols[index-1];
00289
00290
00291
00292 dpcol->maxsize = (ub2) maxsize;
00293 dpcol->bufsize = (ub2) maxsize + 1;
00294 dpcol->sqlcode = SQLT_CHR;
00295 dpcol->type = OCI_DDT_TEXT;
00296 dpcol->index = i;
00297 dpcol->format_size = 0;
00298
00299 switch (col->type)
00300 {
00301 case OCI_CDT_TEXT:
00302
00303 dpcol->maxsize *= sizeof(dtext);
00304 dpcol->bufsize *= sizeof(dtext);
00305
00306 if (OCILib.nls_utf8 == TRUE)
00307 {
00308 dpcol->bufsize *= UTF8_BYTES_PER_CHAR;
00309 }
00310
00311 break;
00312
00313 case OCI_CDT_NUMERIC:
00314
00315 if ((format != NULL) && (format[0] != 0))
00316 {
00317 dpcol->format = mtsdup(format);
00318 dpcol->format_size = (ub4) mtslen(format);
00319 dpcol->type = OCI_DDT_NUMBER;
00320 dpcol->sqlcode = SQLT_NUM;
00321 dpcol->bufsize = sizeof(OCINumber);
00322 dpcol->maxsize = sizeof(OCINumber);
00323 }
00324 else
00325 {
00326 dpcol->type = OCI_DDT_OTHERS;
00327 }
00328
00329 break;
00330
00331 case OCI_CDT_DATETIME:
00332 case OCI_CDT_TIMESTAMP:
00333 case OCI_CDT_INTERVAL:
00334
00335 dpcol->type = OCI_DDT_OTHERS;
00336
00337 if ((format != NULL) && (format[0] != 0))
00338 {
00339 dpcol->format = mtsdup(format);
00340 dpcol->format_size = (ub4) mtslen(format);
00341 dpcol->maxsize = (ub2) dpcol->format_size;
00342 dpcol->bufsize *= sizeof(dtext);
00343 }
00344
00345 break;
00346
00347 case OCI_CDT_LOB:
00348
00349 if (col->subtype == OCI_BLOB)
00350 {
00351 dpcol->type = OCI_DDT_BINARY;
00352 dpcol->sqlcode = SQLT_BIN;
00353 }
00354
00355 break;
00356
00357 case OCI_CDT_LONG:
00358
00359 if (col->subtype == OCI_BLONG)
00360 {
00361 dpcol->type = OCI_DDT_BINARY;
00362 dpcol->sqlcode = SQLT_BIN;
00363 }
00364
00365 break;
00366
00367 case OCI_CDT_RAW:
00368
00369 dpcol->type = OCI_DDT_BINARY;
00370 dpcol->sqlcode = SQLT_BIN;
00371
00372 break;
00373
00374 default:
00375
00376 res = FALSE;
00377 OCI_ExceptionDatatypeNotSupported(dp->con, NULL, col->ocode);
00378
00379 break;
00380 }
00381 }
00382
00383
00384
00385 if (res == TRUE)
00386 {
00387
00388
00389 OCI_CALL2
00390 (
00391 res, dp->con,
00392
00393 OCIAttrGet(dp->ctx, OCI_HTYPE_DIRPATH_CTX, &hlist,
00394 NULL, OCI_ATTR_LIST_COLUMNS, dp->con->err)
00395 )
00396
00397
00398
00399 OCI_CALL2
00400 (
00401 res, dp->con,
00402
00403 OCIParamGet((dvoid *) hlist, OCI_DTYPE_PARAM, dp->con->err,
00404 (dvoid** ) (dvoid *) &hattr, (ub4) index)
00405 )
00406
00407
00408
00409 if (res == TRUE)
00410 {
00411 osize = -1;
00412 ostr = OCI_GetInputMetaString(name, &osize);
00413
00414 OCI_CALL2
00415 (
00416 res, dp->con,
00417
00418 OCIAttrSet((dvoid *) hattr, (ub4) OCI_DTYPE_PARAM,
00419 (dvoid *) ostr, (ub4) osize,
00420 (ub4) OCI_ATTR_NAME, dp->con->err)
00421 )
00422
00423 OCI_ReleaseMetaString(ostr);
00424 }
00425
00426
00427
00428 OCI_CALL2
00429 (
00430 res, dp->con,
00431
00432 OCIAttrSet((dvoid *) hattr, (ub4) OCI_DTYPE_PARAM,
00433 (dvoid *) &dpcol->sqlcode, sizeof(dpcol->sqlcode),
00434 (ub4) OCI_ATTR_DATA_TYPE, dp->con->err)
00435 )
00436
00437
00438
00439 OCI_CALL2
00440 (
00441 res, dp->con,
00442
00443 OCIAttrSet((dvoid *) hattr, (ub4) OCI_DTYPE_PARAM,
00444 (dvoid *) &dpcol->maxsize, sizeof(dpcol->maxsize),
00445 (ub4) OCI_ATTR_DATA_SIZE, dp->con->err)
00446 )
00447
00448
00449
00450 if (col->prec != 0)
00451 {
00452 OCI_CALL2
00453 (
00454 res, dp->con,
00455
00456 OCIAttrSet((dvoid *) hattr, (ub4) OCI_DTYPE_PARAM,
00457 (dvoid *) &col->prec, sizeof(col->prec),
00458 (ub4) OCI_ATTR_PRECISION, dp->con->err)
00459 )
00460 }
00461
00462
00463
00464 if (col->scale != 0)
00465 {
00466 OCI_CALL2
00467 (
00468 res, dp->con,
00469
00470 OCIAttrSet((dvoid *) hattr, (ub4) OCI_DTYPE_PARAM,
00471 (dvoid *) &col->scale, sizeof(col->scale),
00472 (ub4) OCI_ATTR_SCALE, dp->con->err)
00473 )
00474 }
00475
00476
00477
00478 if ((res == TRUE) && (dpcol->type != OCI_DDT_NUMBER) &&
00479 (dpcol->format != NULL) && (dpcol->format[0] != 0))
00480 {
00481 osize = -1;
00482 ostr = OCI_GetInputMetaString(dpcol->format, &osize);
00483
00484 OCI_CALL2
00485 (
00486 res, dp->con,
00487
00488 OCIAttrSet((dvoid *) hattr, (ub4) OCI_DTYPE_PARAM,
00489 (dvoid *) ostr, (ub4) osize,
00490 (ub4) OCI_ATTR_DATEFORMAT, dp->con->err)
00491 )
00492
00493 OCI_ReleaseMetaString(ostr);
00494 }
00495
00496 #ifdef OCI_CHARSET_WIDE
00497
00498
00499
00500 if (dpcol->type == OCI_DDT_TEXT)
00501 {
00502 ub2 csid = OCI_UTF16ID;
00503
00504 OCI_CALL2
00505 (
00506 res, dp->con,
00507
00508 OCIAttrSet((dvoid *) hattr, (ub4) OCI_DTYPE_PARAM,
00509 (dvoid *) &csid, (ub4) sizeof(csid),
00510 (ub4) OCI_ATTR_CHARSET_ID, dp->con->err)
00511 )
00512 }
00513
00514 #endif
00515
00516
00517
00518 OCIDescriptorFree(hattr, OCI_DTYPE_PARAM);
00519 }
00520
00521 OCI_RESULT(res);
00522
00523 return res;
00524 }
00525
00526
00527
00528
00529
00530 boolean OCI_API OCI_DirPathPrepare
00531 (
00532 OCI_DirPath *dp
00533 )
00534 {
00535 boolean res = TRUE;
00536 ub2 i;
00537
00538 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
00539 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_NOT_PREPARED, FALSE);
00540
00541
00542
00543 OCI_CALL2
00544 (
00545 res, dp->con,
00546
00547 OCIDirPathPrepare(dp->ctx, dp->con->cxt, dp->con->err)
00548 )
00549
00550
00551
00552 if (res == TRUE)
00553 {
00554 res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) dp->ctx,
00555 (dvoid **) (void *) &dp->arr,
00556 (ub4) OCI_HTYPE_DIRPATH_COLUMN_ARRAY,
00557 (size_t) 0, (dvoid **) NULL));
00558 }
00559
00560
00561
00562 if (res == TRUE)
00563 {
00564 res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) dp->ctx,
00565 (dvoid **) (void *) &dp->strm,
00566 (ub4) OCI_HTYPE_DIRPATH_STREAM,
00567 (size_t) 0, (dvoid **) NULL));
00568 }
00569
00570
00571
00572 if (res == TRUE)
00573 {
00574 ub4 num_rows = 0;
00575 ub4 size = sizeof(num_rows);
00576
00577 OCI_CALL2
00578 (
00579 res, dp->con,
00580
00581 OCIAttrGet(dp->arr, OCI_HTYPE_DIRPATH_COLUMN_ARRAY, &num_rows,
00582 &size, OCI_ATTR_NUM_ROWS, dp->con->err)
00583 )
00584
00585 dp->nb_cur = (ub2) num_rows;
00586 dp->nb_rows = (ub2) num_rows;
00587 }
00588
00589
00590
00591 if (res == TRUE)
00592 {
00593
00594 for (i = 0; i < dp->nb_cols; i++)
00595 {
00596 OCI_DirPathColumn *col = &dp->cols[i];
00597
00598
00599
00600 col->data = (ub1 *) OCI_MemAlloc(OCI_IPC_BUFF_ARRAY,
00601 (size_t) col->bufsize,
00602 (size_t) dp->nb_cur, TRUE);
00603
00604 if (col->data == NULL)
00605 {
00606 res = FALSE;
00607 break;
00608 }
00609
00610
00611
00612 col->lens = (ub4 *) OCI_MemAlloc(OCI_IPC_BUFF_ARRAY, sizeof(ub4),
00613 (size_t) dp->nb_cur, TRUE);
00614
00615 if (col->lens == NULL)
00616 {
00617 res = FALSE;
00618 break;
00619 }
00620
00621
00622
00623 col->flags = (ub1 *) OCI_MemAlloc(OCI_IPC_BUFF_ARRAY, sizeof(ub1),
00624 (size_t) dp->nb_cur, TRUE);
00625
00626 if (col->flags == NULL)
00627 {
00628 res = FALSE;
00629 break;
00630 }
00631 }
00632 }
00633
00634 if (res == TRUE)
00635 dp->status = OCI_DPS_PREPARED;
00636
00637 OCI_RESULT(res);
00638
00639 return res;
00640 }
00641
00642
00643
00644
00645
00646 boolean OCI_API OCI_DirPathSetEntry
00647 (
00648 OCI_DirPath *dp,
00649 unsigned int row,
00650 unsigned int index,
00651 void *value,
00652 unsigned int size,
00653 boolean complete
00654 )
00655 {
00656 boolean res = TRUE;
00657 OCI_DirPathColumn *dpcol = NULL;
00658 OCI_Column *col = NULL;
00659
00660 ub1 *data;
00661 ub1 flag;
00662
00663 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
00664
00665 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_PREPARED, FALSE);
00666 OCI_CHECK_BOUND(dp->con, index, 1, dp->nb_cols, FALSE);
00667 OCI_CHECK_BOUND(dp->con, row, 1, dp->nb_cur, FALSE);
00668
00669 dpcol = &dp->cols[index-1];
00670 col = &dp->typinf->cols[dpcol->index];
00671
00672
00673
00674 if (size > dpcol->maxsize)
00675 size = (unsigned int) dpcol->maxsize;
00676
00677
00678
00679 if (value == NULL)
00680 {
00681 flag = OCI_DIRPATH_COL_NULL;
00682 }
00683 else if (complete == TRUE)
00684 {
00685 flag = OCI_DIRPATH_COL_COMPLETE;
00686 }
00687 else
00688 {
00689 flag = OCI_DIRPATH_COL_PARTIAL;
00690 }
00691
00692
00693
00694
00695 if (dpcol->sqlcode == SQLT_CHR)
00696 {
00697 size *= (unsigned int) sizeof(dtext);
00698 }
00699
00700
00701
00702 data = ((ub1 *) dpcol->data) + (size_t) ((row-1) * dpcol->bufsize);
00703
00704 #if defined(OCI_CHECK_DATASTRINGS)
00705
00706
00707
00708 if (dpcol->type == OCI_DDT_TEXT)
00709 {
00710 int osize = -1;
00711
00712 OCI_GetOutputString(value, data, &size, sizeof(dtext), sizeof(odtext));
00713 }
00714 else
00715
00716 #endif
00717
00718 #if defined(OCI_USERDATA_WIDE)
00719
00720
00721
00722
00723 if (dpcol->type == OCI_DDT_OTHERS)
00724 {
00725 size = (unsigned int) wcstombs((char *) data, value, dpcol->bufsize - 1);
00726 }
00727 else
00728
00729 #endif
00730
00731
00732
00733
00734 if (dpcol->type == OCI_DDT_NUMBER)
00735 {
00736 OCINumber *num = (OCINumber *) data;
00737
00738 res = OCI_NumberConvertStr(dp->con, num, (dtext *) value, size,
00739 dpcol->format, dpcol->format_size);
00740
00741 if (res == TRUE)
00742 {
00743 size = (unsigned int) num->OCINumberPart[0];
00744 }
00745 }
00746 else
00747 {
00748
00749 #if defined(OCI_CHARSET_MIXED)
00750
00751
00752
00753
00754
00755
00756
00757
00758 if (dpcol->type == OCI_DDT_TEXT)
00759 {
00760 size = (unsigned int) wcstombs((char *) data, value, dpcol->bufsize - 1);
00761 }
00762 else
00763 #endif
00764 {
00765 memcpy(data, value, (size_t) size);
00766 }
00767
00768 }
00769
00770 dpcol->lens[row-1] = size;
00771 dpcol->flags[row-1] = flag;
00772
00773 OCI_RESULT(res);
00774
00775 return res;
00776 }
00777
00778
00779
00780
00781
00782 boolean OCI_API OCI_DirPathReset
00783 (
00784 OCI_DirPath *dp
00785 )
00786 {
00787 boolean res = TRUE;
00788
00789 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
00790
00791
00792
00793 OCI_CALL2
00794 (
00795 res, dp->con,
00796
00797 OCIDirPathColArrayReset(dp->arr, dp->con->err)
00798 )
00799
00800
00801
00802 OCI_CALL2
00803 (
00804 res, dp->con,
00805
00806 OCIDirPathStreamReset(dp->strm, dp->con->err)
00807 )
00808
00809 OCI_RESULT(res);
00810
00811 return res;
00812 }
00813
00814
00815
00816
00817
00818 unsigned int OCI_API OCI_DirPathConvert
00819 (
00820 OCI_DirPath *dp
00821 )
00822 {
00823 unsigned int res = OCI_DPR_COMPLETE;
00824 OCI_DirPathColumn *dpcol = NULL;
00825 sword ret = OCI_SUCCESS;
00826 ub1 *data;
00827 ub4 size;
00828 ub1 flag;
00829 ub2 i, j;
00830
00831 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, OCI_DPR_ERROR);
00832
00833 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_PREPARED, OCI_DPR_ERROR);
00834
00835 dp->err_col = 0;
00836 dp->nb_prcsd = 0;
00837
00838
00839
00840 for (i = 0; (i < dp->nb_cols) && (res == TRUE); i++)
00841 {
00842 dpcol = &(dp->cols[i]);
00843
00844 for (j = (ub2) 0; (j < dp->nb_cur) && (res == TRUE); j++)
00845 {
00846
00847
00848 data = ((ub1 *) dpcol->data) + (size_t) (j * dpcol->bufsize);
00849 size = dpcol->lens[j];
00850 flag = dpcol->flags[j];
00851
00852 if (dpcol->sqlcode == SQLT_NUM)
00853 {
00854 OCINumber *num = (OCINumber *) data;
00855
00856 data = &num->OCINumberPart[1];
00857 }
00858
00859
00860
00861 OCI_CALL2
00862 (
00863 res, dp->con,
00864
00865 OCIDirPathColArrayEntrySet(dp->arr, dp->con->err, (ub4) j,
00866 (ub2) (i), (ub1*) data,
00867 (ub4) size, flag)
00868 )
00869 }
00870 }
00871
00872 if (res == TRUE)
00873 {
00874
00875
00876 ret = OCIDirPathColArrayToStream(dp->arr, dp->ctx, dp->strm, dp->con->err,
00877 (ub4) dp->nb_cur, (ub4) 0);
00878
00879 switch (ret)
00880 {
00881 case OCI_SUCCESS:
00882 {
00883 dp->status = OCI_DPS_CONVERTED;
00884 dp->err_col = 0;
00885 dp->err_row = 0;
00886 res = OCI_DPR_COMPLETE;
00887
00888 break;
00889 }
00890 case OCI_ERROR:
00891 {
00892 res = OCI_DPR_ERROR;
00893
00894 OCI_ExceptionOCI(dp->con->err, dp->con, NULL, FALSE);
00895
00896 break;
00897 }
00898 case OCI_CONTINUE:
00899 {
00900 dp->status = OCI_DPS_CONVERTED;
00901 res = OCI_DPR_FULL;
00902
00903 break;
00904 }
00905 case OCI_NEED_DATA:
00906 {
00907 res = OCI_DPR_PARTIAL;
00908
00909 break;
00910 }
00911 }
00912
00913 if (ret != OCI_SUCCESS)
00914 {
00915 size = sizeof(dp->err_col);
00916
00917 OCIAttrGet(dp->arr, OCI_HTYPE_DIRPATH_COLUMN_ARRAY, &dp->err_col,
00918 &size, OCI_ATTR_COL_COUNT, dp->con->err);
00919
00920 size = sizeof(dp->err_row);
00921
00922 OCIAttrGet(dp->arr, OCI_HTYPE_DIRPATH_COLUMN_ARRAY, &dp->err_row,
00923 &size, OCI_ATTR_ROW_COUNT, dp->con->err);
00924
00925 dp->nb_prcsd = dp->err_row;
00926 }
00927 else
00928 {
00929 dp->nb_prcsd = dp->nb_cur;
00930 }
00931
00932 }
00933 else
00934 {
00935 ret = OCI_ERROR;
00936 }
00937
00938 OCI_RESULT(ret == OCI_SUCCESS);
00939
00940 return res;
00941 }
00942
00943
00944
00945
00946
00947 unsigned int OCI_API OCI_DirPathLoad
00948 (
00949 OCI_DirPath *dp
00950 )
00951 {
00952 unsigned int res = OCI_DPR_COMPLETE;
00953 sword ret = OCI_SUCCESS;
00954
00955 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, OCI_DPR_ERROR);
00956
00957 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_CONVERTED, OCI_DPR_ERROR);
00958
00959 dp->err_col = 0;
00960 dp->nb_prcsd = 0;
00961
00962 ret = OCIDirPathLoadStream(dp->ctx, dp->strm, dp->con->err);
00963
00964 switch (ret)
00965 {
00966 case OCI_SUCCESS:
00967 {
00968 dp->status = OCI_DPS_PREPARED;
00969 dp->nb_prcsd = dp->nb_cur;
00970 dp->nb_loaded += dp->nb_prcsd;
00971 res = OCI_DPR_COMPLETE;
00972
00973 break;
00974 }
00975 case OCI_ERROR:
00976 {
00977 res = OCI_DPR_ERROR;
00978
00979 OCI_ExceptionOCI(dp->con->err, dp->con, NULL, FALSE);
00980
00981 break;
00982 }
00983 case OCI_NO_DATA:
00984 {
00985 res = OCI_DPR_EMPTY;
00986
00987 break;
00988 }
00989 case OCI_NEED_DATA:
00990 {
00991 res = OCI_DPR_PARTIAL;
00992
00993 break;
00994 }
00995 }
00996
00997 if (ret != OCI_SUCCESS)
00998 {
00999 ub4 size = sizeof(dp->nb_prcsd);
01000
01001 OCIAttrGet(dp->arr, OCI_HTYPE_DIRPATH_COLUMN_ARRAY, &dp->nb_prcsd,
01002 &size, OCI_ATTR_NUM_ROWS, dp->con->err);
01003 }
01004
01005 OCI_RESULT(ret == OCI_SUCCESS);
01006
01007 return res;
01008 }
01009
01010
01011
01012
01013
01014 boolean OCI_API OCI_DirPathFinish
01015 (
01016 OCI_DirPath *dp
01017 )
01018 {
01019 boolean res = TRUE;
01020
01021 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01022
01023 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_PREPARED, FALSE);
01024
01025 OCI_CALL2
01026 (
01027 res, dp->con,
01028
01029 OCIDirPathFinish(dp->ctx, dp->con->err)
01030 )
01031
01032 if (res == TRUE)
01033 dp->status = OCI_DPS_TERMINATED;
01034
01035 OCI_RESULT(res);
01036
01037 return res;
01038 }
01039
01040
01041
01042
01043
01044 boolean OCI_API OCI_DirPathAbort
01045 (
01046 OCI_DirPath *dp
01047 )
01048 {
01049 boolean res = TRUE;
01050
01051 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01052
01053 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_PREPARED, FALSE);
01054
01055 OCI_CALL2
01056 (
01057 res, dp->con,
01058
01059 OCIDirPathAbort(dp->ctx, dp->con->err)
01060 )
01061
01062 if (res == TRUE)
01063 dp->status = OCI_DPS_TERMINATED;
01064
01065 OCI_RESULT(res);
01066
01067 return res;
01068 }
01069
01070
01071
01072
01073
01074 boolean OCI_API OCI_DirPathSave
01075 (
01076 OCI_DirPath *dp
01077 )
01078 {
01079 boolean res = TRUE;
01080
01081 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01082
01083 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_PREPARED, FALSE);
01084
01085 OCI_CALL2
01086 (
01087 res, dp->con,
01088
01089 OCIDirPathDataSave(dp->ctx, dp->con->err, OCI_DIRPATH_DATASAVE_SAVEONLY)
01090 )
01091
01092 OCI_RESULT(res);
01093
01094 return res;
01095 }
01096
01097
01098
01099
01100
01101 boolean OCI_API OCI_DirPathFlushRow
01102 (
01103 OCI_DirPath *dp
01104 )
01105 {
01106 boolean res = TRUE;
01107
01108 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01109
01110 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_PREPARED, FALSE);
01111
01112 OCI_CALL2
01113 (
01114 res, dp->con,
01115
01116 OCIDirPathFlushRow(dp->ctx, dp->con->err)
01117 )
01118
01119 OCI_RESULT(res);
01120
01121 return res;
01122 }
01123
01124
01125
01126
01127
01128 boolean OCI_API OCI_DirPathSetCurrentRows
01129 (
01130 OCI_DirPath *dp,
01131 unsigned int nb_rows
01132 )
01133 {
01134 boolean res = TRUE;
01135
01136 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01137
01138 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_PREPARED, FALSE);
01139
01140 OCI_CHECK_BOUND(dp->con, nb_rows, 1, dp->nb_rows, FALSE);
01141
01142 dp->nb_cur = (ub2) nb_rows;
01143
01144 OCI_RESULT(res);
01145
01146 return res;
01147 }
01148
01149
01150
01151
01152
01153 unsigned int OCI_API OCI_DirPathGetCurrentRows
01154 (
01155 OCI_DirPath *dp
01156 )
01157 {
01158 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, 0);
01159
01160 OCI_RESULT(TRUE);
01161
01162 return dp->nb_cur;
01163 }
01164
01165
01166
01167
01168
01169 unsigned int OCI_API OCI_DirPathGetMaxRows
01170 (
01171 OCI_DirPath *dp
01172 )
01173 {
01174 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, 0);
01175
01176 OCI_RESULT(TRUE);
01177
01178 return dp->nb_rows;
01179 }
01180
01181
01182
01183
01184
01185 boolean OCI_API OCI_DirPathSetDateFormat
01186 (
01187 OCI_DirPath *dp,
01188 const mtext *format
01189 )
01190 {
01191 boolean res = TRUE;
01192 void *ostr = NULL;
01193 int osize = -1;
01194
01195 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01196
01197 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_NOT_PREPARED, FALSE);
01198
01199 osize = -1;
01200 ostr = OCI_GetInputMetaString(format, &osize);
01201
01202 OCI_CALL2
01203 (
01204 res, dp->con,
01205
01206 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
01207 (dvoid *) ostr, (ub4) osize,
01208 (ub4) OCI_ATTR_DATEFORMAT, dp->con->err)
01209 )
01210
01211 OCI_ReleaseMetaString(ostr);
01212
01213 OCI_RESULT(res);
01214
01215 return res;
01216 }
01217
01218
01219
01220
01221
01222 boolean OCI_API OCI_DirPathSetParallel
01223 (
01224 OCI_DirPath *dp,
01225 boolean value
01226 )
01227 {
01228 boolean res = TRUE;
01229 ub1 enabled = (ub1) value;
01230
01231 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01232
01233 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_NOT_PREPARED, FALSE);
01234
01235 OCI_CALL2
01236 (
01237 res, dp->con,
01238
01239 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
01240 (dvoid *) &enabled, (ub4) sizeof(enabled),
01241 (ub4) OCI_ATTR_DIRPATH_PARALLEL, dp->con->err)
01242 )
01243
01244 OCI_RESULT(res);
01245
01246 return res;
01247 }
01248
01249
01250
01251
01252
01253 boolean OCI_API OCI_DirPathSetNoLog
01254 (
01255 OCI_DirPath *dp,
01256 boolean value
01257 )
01258 {
01259 boolean res = TRUE;
01260 ub1 nolog = (ub1) value;
01261
01262 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01263
01264 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_NOT_PREPARED, FALSE);
01265
01266 OCI_CALL2
01267 (
01268 res, dp->con,
01269
01270 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
01271 (dvoid *) &nolog, (ub4) sizeof(nolog),
01272 (ub4) OCI_ATTR_DIRPATH_NOLOG, dp->con->err)
01273 )
01274
01275 OCI_RESULT(res);
01276
01277 return res;
01278 }
01279
01280
01281
01282
01283
01284 boolean OCI_API OCI_DirPathSetCacheSize
01285 (
01286 OCI_DirPath *dp,
01287 unsigned int size
01288 )
01289 {
01290 boolean res = TRUE;
01291 ub4 cache_size = size;
01292 boolean enabled = FALSE;
01293
01294 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01295
01296 OCI_CHECK_DIRPATH_DATE_CACHE_ENABLED(dp, FALSE);
01297
01298 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_NOT_PREPARED, FALSE);
01299
01300 #if OCI_VERSION_COMPILE >= OCI_9_2
01301
01302 OCI_CALL2
01303 (
01304 res, dp->con,
01305
01306 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
01307 (dvoid *) &cache_size, (ub4) sizeof(cache_size),
01308 (ub4) OCI_ATTR_DIRPATH_DCACHE_SIZE, dp->con->err)
01309 )
01310
01311 OCI_CALL2
01312 (
01313 res, dp->con,
01314
01315 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
01316 (dvoid *) &enabled, (ub4) sizeof(enabled),
01317 (ub4) OCI_ATTR_DIRPATH_DCACHE_DISABLE, dp->con->err)
01318 )
01319
01320 #else
01321
01322 OCI_NOT_USED(cache_size);
01323 OCI_NOT_USED(enabled);
01324
01325 #endif
01326
01327 OCI_RESULT(res);
01328
01329 return res;
01330 }
01331
01332
01333
01334
01335
01336 boolean OCI_API OCI_DirPathSetBufferSize
01337 (
01338 OCI_DirPath *dp,
01339 unsigned int size
01340 )
01341 {
01342 boolean res = TRUE;
01343 ub4 bufsize = (ub4) size;
01344
01345 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01346
01347 OCI_CHECK_DIRPATH_STATUS(dp, OCI_DPS_NOT_PREPARED, FALSE);
01348
01349 OCI_CALL2
01350 (
01351 res, dp->con,
01352
01353 OCIAttrSet((dvoid *) dp->ctx, (ub4) OCI_HTYPE_DIRPATH_CTX,
01354 (dvoid *) &bufsize, (ub4) sizeof(bufsize),
01355 (ub4) OCI_ATTR_BUF_SIZE, dp->con->err)
01356 )
01357
01358 OCI_RESULT(res);
01359
01360 return res;
01361 }
01362
01363
01364
01365
01366
01367 unsigned int OCI_API OCI_DirPathGetRowCount
01368 (
01369 OCI_DirPath *dp
01370 )
01371 {
01372 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01373
01374 OCI_RESULT(TRUE);
01375
01376 return dp->nb_loaded;
01377 }
01378
01379
01380
01381
01382
01383 unsigned int OCI_API OCI_DirPathGetAffectedRows
01384 (
01385 OCI_DirPath *dp
01386 )
01387 {
01388 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01389
01390 OCI_RESULT(TRUE);
01391
01392 return dp->nb_prcsd;
01393 }
01394
01395
01396
01397
01398
01399 unsigned int OCI_API OCI_DirPathGetErrorColumn
01400 (
01401 OCI_DirPath *dp
01402 )
01403 {
01404 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01405
01406 OCI_RESULT(TRUE);
01407
01408 return dp->err_col;
01409 }
01410
01411
01412
01413
01414
01415 unsigned int OCI_API OCI_DirPathGetErrorRow
01416 (
01417 OCI_DirPath *dp
01418 )
01419 {
01420 OCI_CHECK_PTR(OCI_IPC_DIRPATH, dp, FALSE);
01421
01422 OCI_RESULT(TRUE);
01423
01424 return dp->err_row;
01425 }