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_Elem * OCI_ElemInit
00046 (
00047 OCI_Connection *con,
00048 OCI_Elem **pelem,
00049 void *handle,
00050 OCIInd *pind,
00051 OCI_TypeInfo *typinf
00052 )
00053 {
00054 OCI_Elem *elem = NULL;
00055 boolean res = TRUE;
00056
00057 OCI_CHECK(pelem == NULL, NULL);
00058
00059 if (*pelem == NULL)
00060 *pelem = (OCI_Elem *) OCI_MemAlloc(OCI_IPC_ELEMENT, sizeof(*elem),
00061 (size_t) 1, TRUE);
00062
00063 if (*pelem != NULL)
00064 {
00065 elem = *pelem;
00066
00067 elem->con = con;
00068 elem->ind = OCI_IND_NULL;
00069 elem->typinf = typinf;
00070 elem->handle = handle;
00071 elem->init = FALSE;
00072
00073 if (handle == NULL)
00074 elem->hstate = OCI_OBJECT_ALLOCATED;
00075 else
00076 elem->hstate = OCI_OBJECT_FETCHED_CLEAN;
00077
00078 switch (elem->typinf->cols[0].type)
00079 {
00080 case OCI_CDT_NUMERIC:
00081
00082 if (elem->handle == NULL)
00083 {
00084 elem->handle = (OCINumber *) OCI_MemAlloc(OCI_IPC_VOID,
00085 sizeof(OCINumber),
00086 1, TRUE);
00087 }
00088
00089 break;
00090
00091 case OCI_CDT_TEXT:
00092 case OCI_CDT_TIMESTAMP:
00093 case OCI_CDT_INTERVAL:
00094 case OCI_CDT_RAW:
00095 case OCI_CDT_LOB:
00096 case OCI_CDT_FILE:
00097 case OCI_CDT_REF:
00098
00099 if (elem->handle != NULL)
00100 elem->handle = * (void **) handle;
00101 break;
00102 }
00103
00104 if (pind != NULL)
00105 {
00106 elem->pind = pind;
00107 elem->ind = *elem->pind;
00108 }
00109 else
00110 {
00111 elem->pind = &elem->ind;
00112 }
00113 }
00114 else
00115 res = FALSE;
00116
00117
00118
00119 if (res == FALSE)
00120 {
00121 OCI_ElemFree(elem);
00122 elem = NULL;
00123 }
00124
00125 return elem;
00126 }
00127
00128
00129
00130
00131
00132 boolean OCI_ElemSetNullIndicator
00133 (
00134 OCI_Elem *elem,
00135 OCIInd value
00136 )
00137 {
00138 boolean res = TRUE;
00139
00140 if (elem->typinf->cols[0].type == OCI_CDT_OBJECT)
00141 {
00142 OCI_Object *obj = (OCI_Object *) elem->obj;
00143
00144 if (obj != NULL)
00145 {
00146 elem->pind = obj->tab_ind;
00147 }
00148 }
00149 else
00150 {
00151 if (elem->pind != NULL)
00152 *elem->pind = value;
00153 }
00154
00155 return res;
00156 }
00157
00158
00159
00160
00161
00162 boolean OCI_ElemSetNumber
00163 (
00164 OCI_Elem *elem,
00165 void *value,
00166 uword size,
00167 uword flag
00168 )
00169 {
00170 boolean res = FALSE;
00171
00172 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
00173 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_NUMERIC, FALSE);
00174
00175 res = OCI_NumberSet(elem->con, (OCINumber *) elem->handle, value, size, flag);
00176
00177 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
00178
00179 OCI_RESULT(res);
00180
00181 return res;
00182 }
00183
00184
00185
00186
00187
00188 boolean OCI_ElemGetNumber
00189 (
00190 OCI_Elem *elem,
00191 void *value,
00192 uword size,
00193 uword flag
00194 )
00195 {
00196 boolean res = FALSE;
00197
00198 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
00199
00200 if (elem->typinf->cols[0].type == OCI_CDT_NUMERIC)
00201 {
00202 OCINumber *num = (OCINumber *) elem->handle;
00203
00204 res = OCI_NumberGet(elem->con, num, value, size, flag);
00205 }
00206 else if (elem->typinf->cols[0].type == OCI_CDT_TEXT)
00207 {
00208 const mtext *fmt = OCI_GetDefaultFormatNumeric(elem->con);
00209 ub4 fmt_size = (ub4) mtslen(fmt);
00210 dtext *data = (dtext *) OCI_ElemGetString(elem);
00211
00212 res = OCI_NumberGetFromStr(elem->con, value, size, flag, data,
00213 (int) dtslen(data), fmt, fmt_size);
00214 }
00215 else
00216 {
00217 OCI_ExceptionTypeNotCompatible(elem->con);
00218 }
00219
00220 OCI_RESULT(res);
00221
00222 return res;
00223 }
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233 OCI_Elem * OCI_API OCI_ElemCreate
00234 (
00235 OCI_TypeInfo *typinf
00236 )
00237 {
00238 OCI_Elem *elem = NULL;
00239
00240 OCI_CHECK_INITIALIZED(NULL);
00241 OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00242
00243 elem = OCI_ElemInit(typinf->con, &elem, NULL, (OCIInd *) NULL, typinf);
00244
00245 OCI_RESULT(elem != NULL);
00246
00247 return elem;
00248 }
00249
00250
00251
00252
00253
00254 boolean OCI_API OCI_ElemFree
00255 (
00256 OCI_Elem *elem
00257 )
00258 {
00259 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
00260
00261 OCI_CHECK_OBJECT_FETCHED(elem, FALSE);
00262
00263
00264
00265
00266 if (elem->obj != NULL)
00267 {
00268 OCI_Datatype * data = (OCI_Datatype *) elem->obj;
00269
00270 if (data->hstate == OCI_OBJECT_FETCHED_CLEAN)
00271 data->hstate = OCI_OBJECT_FETCHED_DIRTY;
00272
00273 switch (elem->typinf->cols[0].type)
00274 {
00275 case OCI_CDT_DATETIME:
00276
00277 OCI_DateFree((OCI_Date *) elem->obj);
00278 break;
00279
00280 case OCI_CDT_LOB:
00281
00282 OCI_LobFree((OCI_Lob *) elem->obj);
00283 break;
00284
00285 case OCI_CDT_FILE:
00286
00287 OCI_FileFree((OCI_File *) elem->obj);
00288 break;
00289
00290 case OCI_CDT_OBJECT:
00291
00292 OCI_ObjectFree((OCI_Object *) elem->obj);
00293 break;
00294
00295 case OCI_CDT_COLLECTION:
00296
00297 OCI_CollFree((OCI_Coll *) elem->obj);;
00298 break;
00299
00300 case OCI_CDT_TIMESTAMP:
00301
00302 OCI_TimestampFree((OCI_Timestamp *) elem->obj);
00303 break;
00304
00305 case OCI_CDT_INTERVAL:
00306
00307 OCI_IntervalFree((OCI_Interval *) elem->obj);
00308 break;
00309
00310 case OCI_CDT_REF:
00311
00312 OCI_RefFree((OCI_Ref *) elem->obj);
00313 break;
00314 }
00315 }
00316
00317 if ((elem->hstate == OCI_OBJECT_ALLOCATED) &&
00318 (elem->typinf->cols[0].type == OCI_CDT_NUMERIC))
00319 {
00320 OCI_FREE(elem->handle);
00321 }
00322
00323 OCI_FREE(elem->buf);
00324 OCI_FREE(elem);
00325
00326 OCI_RESULT(TRUE);
00327
00328 return TRUE;
00329 }
00330
00331
00332
00333
00334
00335 short OCI_API OCI_ElemGetShort
00336 (
00337 OCI_Elem *elem
00338 )
00339 {
00340 short value = 0;
00341
00342 OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(short),
00343 (uword) OCI_NUM_SHORT);
00344
00345 return value;
00346 }
00347
00348
00349
00350
00351
00352 unsigned short OCI_API OCI_ElemGetUnsignedShort
00353 (
00354 OCI_Elem *elem
00355 )
00356 {
00357 unsigned short value = 0;
00358
00359 OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(unsigned short),
00360 (uword) OCI_NUM_USHORT);
00361
00362 return value;
00363 }
00364
00365
00366
00367
00368
00369 int OCI_API OCI_ElemGetInt
00370 (
00371 OCI_Elem *elem
00372 )
00373 {
00374 int value = 0;
00375
00376 OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(value),
00377 (uword) OCI_NUM_INT);
00378
00379 return value;
00380 }
00381
00382
00383
00384
00385
00386 unsigned int OCI_API OCI_ElemGetUnsignedInt
00387 (
00388 OCI_Elem *elem
00389 )
00390 {
00391 unsigned int value = 0;
00392
00393 OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(value),
00394 (uword) OCI_NUM_UINT);
00395
00396 return value;
00397 }
00398
00399
00400
00401
00402
00403 big_int OCI_API OCI_ElemGetBigInt
00404 (
00405 OCI_Elem *elem
00406 )
00407 {
00408 big_int value = 0;
00409
00410 OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(big_int),
00411 (uword) OCI_NUM_BIGINT);
00412
00413 return value;
00414 }
00415
00416
00417
00418
00419
00420 big_uint OCI_API OCI_ElemGetUnsignedBigInt
00421 (
00422 OCI_Elem *elem
00423 )
00424 {
00425 big_uint value = 0;
00426
00427 OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(big_uint),
00428 (uword) OCI_NUM_BIGUINT);
00429
00430 return value;
00431 }
00432
00433
00434
00435
00436
00437 double OCI_API OCI_ElemGetDouble
00438 (
00439 OCI_Elem *elem
00440 )
00441 {
00442 double value = 0.0;
00443
00444 OCI_ElemGetNumber(elem, (void *) &value, (uword) sizeof(double),
00445 (uword) OCI_NUM_DOUBLE);
00446
00447 return value;
00448 }
00449
00450
00451
00452
00453
00454 const dtext * OCI_API OCI_ElemGetString
00455 (
00456 OCI_Elem *elem
00457 )
00458 {
00459 const dtext *str = NULL;
00460 boolean res = FALSE;
00461
00462 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00463 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_TEXT, NULL);
00464
00465 if (elem->handle != NULL)
00466 {
00467 res = TRUE;
00468
00469 str = (dtext *) OCI_StringFromStringPtr((OCIString *) elem->handle,
00470 &elem->buf, &elem->buflen);
00471 }
00472
00473 OCI_RESULT(res);
00474
00475 return str;
00476 }
00477
00478
00479
00480
00481
00482 unsigned int OCI_API OCI_ElemGetRaw
00483 (
00484 OCI_Elem *elem,
00485 void *value,
00486 unsigned int len
00487 )
00488 {
00489 boolean res = FALSE;
00490
00491 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, 0);
00492 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_RAW, 0);
00493
00494 if (elem->handle != NULL)
00495 {
00496 OCIRaw *raw = *(OCIRaw **) elem->handle;
00497 ub4 raw_len = 0;
00498
00499 raw_len = OCIRawSize(OCILib.env, raw);
00500
00501 if (len > raw_len)
00502 len = raw_len;
00503
00504 memcpy(value, OCIRawPtr(OCILib.env, raw), (size_t) len);
00505 }
00506
00507 OCI_RESULT(res);
00508
00509 return len;
00510 }
00511
00512
00513
00514
00515
00516 OCI_Date * OCI_API OCI_ElemGetDate
00517 (
00518 OCI_Elem *elem
00519 )
00520 {
00521 boolean res = TRUE;
00522 OCI_Date *date = NULL;
00523
00524 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00525 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_DATETIME, NULL);
00526
00527 if (elem->ind != OCI_IND_NULL)
00528 {
00529 if (elem->init == FALSE)
00530 {
00531 date = OCI_DateInit(elem->con, (OCI_Date **) &elem->obj,
00532 (OCIDate *) elem->handle, FALSE, FALSE);
00533
00534 elem->init = (date != NULL);
00535 }
00536 else
00537 date = (OCI_Date *) elem->obj;
00538
00539 res = elem->init;
00540 }
00541
00542 OCI_RESULT(res);
00543
00544 return date;
00545 }
00546
00547
00548
00549
00550
00551 OCI_Timestamp * OCI_API OCI_ElemGetTimestamp
00552 (
00553 OCI_Elem *elem
00554 )
00555 {
00556 boolean res = TRUE;
00557 OCI_Timestamp *tmsp = NULL;
00558
00559 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00560 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_TIMESTAMP, NULL);
00561
00562 if (elem->ind != OCI_IND_NULL)
00563 {
00564 if (elem->init == FALSE)
00565 {
00566 tmsp = OCI_TimestampInit(elem->con, (OCI_Timestamp **) &elem->obj,
00567 (OCIDateTime *) elem->handle,
00568 elem->typinf->cols[0].subtype);
00569
00570 elem->init = (tmsp != NULL);
00571 }
00572 else
00573 tmsp = (OCI_Timestamp *) elem->obj;
00574
00575 res = elem->init;
00576 }
00577
00578 OCI_RESULT(res);
00579
00580 return tmsp;
00581 }
00582
00583
00584
00585
00586
00587 OCI_Interval * OCI_API OCI_ElemGetInterval
00588 (
00589 OCI_Elem *elem
00590 )
00591 {
00592 boolean res = TRUE;
00593 OCI_Interval *itv = NULL;
00594
00595 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00596 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_INTERVAL, NULL);
00597
00598 if (elem->ind != OCI_IND_NULL)
00599 {
00600 if (elem->init == FALSE)
00601 {
00602 itv = OCI_IntervalInit(elem->con, (OCI_Interval **) &elem->obj,
00603 (OCIInterval *) elem->handle,
00604 elem->typinf->cols[0].subtype);
00605
00606 elem->init = (itv != NULL);
00607 }
00608 else
00609 itv = (OCI_Interval *) elem->obj;
00610
00611 res = elem->init;
00612 }
00613
00614 OCI_RESULT(res);
00615
00616 return itv;
00617 }
00618
00619
00620
00621
00622
00623 OCI_Lob * OCI_API OCI_ElemGetLob
00624 (
00625 OCI_Elem *elem
00626 )
00627 {
00628 boolean res = TRUE;
00629 OCI_Lob *lob = NULL;
00630
00631 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00632 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_LOB, NULL);
00633
00634 if (elem->ind != OCI_IND_NULL)
00635 {
00636 if (elem->init == FALSE)
00637 {
00638 lob = OCI_LobInit(elem->con, (OCI_Lob **) &elem->obj,
00639 (OCILobLocator *) elem->handle,
00640 elem->typinf->cols[0].subtype);
00641
00642 elem->init = (lob != NULL);
00643 }
00644 else
00645 lob = (OCI_Lob *) elem->obj;
00646
00647 res = elem->init;
00648 }
00649
00650 OCI_RESULT(res);
00651
00652 return lob;
00653 }
00654
00655
00656
00657
00658
00659 OCI_File * OCI_API OCI_ElemGetFile
00660 (
00661 OCI_Elem *elem
00662 )
00663 {
00664 boolean res = TRUE;
00665 OCI_File *file = NULL;
00666
00667 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00668 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_FILE, NULL);
00669
00670 if (elem->ind != OCI_IND_NULL)
00671 {
00672 if (elem->init == FALSE)
00673 {
00674 file = OCI_FileInit(elem->con, (OCI_File **) &elem->obj,
00675 (OCILobLocator *) elem->handle,
00676 elem->typinf->cols[0].subtype);
00677
00678 elem->init = (file != NULL);
00679 }
00680 else
00681 file = (OCI_File *) elem->obj;
00682
00683 res = elem->init;
00684 }
00685
00686 OCI_RESULT(res);
00687
00688 return file;
00689 }
00690
00691
00692
00693
00694
00695 OCI_Ref * OCI_API OCI_ElemGetRef
00696 (
00697 OCI_Elem *elem
00698 )
00699 {
00700 boolean res = TRUE;
00701 OCI_Ref *ref = NULL;
00702
00703 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00704 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_REF, NULL);
00705
00706 if (elem->ind != OCI_IND_NULL)
00707 {
00708 if (elem->init == FALSE)
00709 {
00710 ref = OCI_RefInit(elem->con, elem->typinf->cols[0].typinf,
00711 (OCI_Ref **) &elem->obj,
00712 (OCIRef *) elem->handle);
00713
00714 elem->init = (ref != NULL);
00715 }
00716 else
00717 ref = (OCI_Ref *) elem->obj;
00718
00719 res = elem->init;
00720 }
00721
00722 OCI_RESULT(res);
00723
00724 return ref;
00725 }
00726
00727
00728
00729
00730
00731 OCI_Object * OCI_API OCI_ElemGetObject
00732 (
00733 OCI_Elem *elem
00734 )
00735 {
00736 boolean res = TRUE;
00737 OCI_Object *obj = NULL;
00738
00739 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00740 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_OBJECT, NULL);
00741
00742 if (elem->ind != OCI_IND_NULL)
00743 {
00744 if (elem->init == FALSE)
00745 {
00746 obj = OCI_ObjectInit(elem->con, (OCI_Object **) &elem->obj,
00747 elem->handle,
00748 elem->typinf->cols[0].typinf,
00749 NULL, -1, TRUE);
00750
00751 elem->init = (obj != NULL);
00752 }
00753 else
00754 obj = (OCI_Object *) elem->obj;
00755
00756 res = elem->init;
00757 }
00758
00759 OCI_RESULT(res);
00760
00761 return obj;
00762 }
00763
00764
00765
00766
00767
00768 OCI_Coll * OCI_API OCI_ElemGetColl
00769 (
00770 OCI_Elem *elem
00771 )
00772 {
00773 boolean res = TRUE;
00774 OCI_Coll *coll = NULL;
00775
00776 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, NULL);
00777 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_COLLECTION, NULL);
00778
00779 if (elem->ind != OCI_IND_NULL)
00780 {
00781 if (elem->init == FALSE)
00782 {
00783 coll = OCI_CollInit(elem->con, (OCI_Coll **) &elem->obj,
00784 (OCIColl *) elem->handle,
00785 elem->typinf->cols[0].typinf);
00786
00787 elem->init = (coll != NULL);
00788 }
00789 else
00790 coll = (OCI_Coll *) elem->obj;
00791
00792 res = elem->init;
00793 }
00794
00795 OCI_RESULT(res);
00796
00797 return coll;
00798 }
00799
00800
00801
00802
00803
00804 boolean OCI_API OCI_ElemSetShort
00805 (
00806 OCI_Elem *elem,
00807 short value
00808 )
00809 {
00810 return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value),
00811 (uword) OCI_NUM_SHORT);
00812 }
00813
00814
00815
00816
00817
00818 boolean OCI_API OCI_ElemSetUnsignedShort
00819 (
00820 OCI_Elem *elem,
00821 unsigned short value
00822 )
00823 {
00824 return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value),
00825 (uword) OCI_NUM_USHORT);
00826 }
00827
00828
00829
00830
00831
00832 boolean OCI_API OCI_ElemSetInt
00833 (
00834 OCI_Elem *elem,
00835 int value
00836 )
00837 {
00838 return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value),
00839 (uword) OCI_NUM_INT);
00840 }
00841
00842
00843
00844
00845
00846 boolean OCI_API OCI_ElemSetUnsignedInt
00847 (
00848 OCI_Elem *elem,
00849 unsigned int value
00850 )
00851 {
00852 return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value),
00853 (uword) OCI_NUM_UINT);
00854 }
00855
00856
00857
00858
00859
00860 boolean OCI_API OCI_ElemSetBigInt
00861 (
00862 OCI_Elem *elem,
00863 big_int value
00864 )
00865 {
00866 return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value),
00867 (uword) OCI_NUM_BIGINT);
00868 }
00869
00870
00871
00872
00873
00874 boolean OCI_API OCI_ElemSetUnsignedBigInt
00875 (
00876 OCI_Elem *elem,
00877 big_uint value
00878 )
00879 {
00880 return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value),
00881 (uword) OCI_NUM_BIGUINT);
00882 }
00883
00884
00885
00886
00887
00888 boolean OCI_API OCI_ElemSetDouble
00889 (
00890 OCI_Elem *elem,
00891 double value
00892 )
00893 {
00894 return OCI_ElemSetNumber(elem, (void *) &value, (uword) sizeof(value),
00895 (uword) OCI_NUM_DOUBLE);
00896 }
00897
00898
00899
00900
00901
00902 boolean OCI_API OCI_ElemSetString
00903 (
00904 OCI_Elem *elem,
00905 const dtext *value
00906 )
00907 {
00908 boolean res = TRUE;
00909
00910 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
00911 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_TEXT, FALSE);
00912
00913 if (value == NULL)
00914 {
00915 res = OCI_ElemSetNull(elem);
00916 }
00917 else
00918 {
00919 res = OCI_StringToStringPtr((OCIString **) &elem->handle,
00920 elem->con->err, (void *) value,
00921 &elem->buf, &elem->buflen);
00922
00923 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
00924 }
00925
00926 OCI_RESULT(res);
00927
00928 return res;
00929 }
00930
00931
00932
00933
00934
00935 boolean OCI_API OCI_ElemSetRaw
00936 (
00937 OCI_Elem *elem,
00938 void * value,
00939 unsigned int len
00940 )
00941 {
00942 boolean res = TRUE;
00943
00944 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
00945 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_RAW, FALSE);
00946
00947 if (value == NULL)
00948 {
00949 res = OCI_ElemSetNull(elem);
00950 }
00951 else
00952 {
00953 OCI_CHECK_MIN(elem->con, NULL, len, 1, FALSE);
00954
00955 OCI_CALL2
00956 (
00957 res, elem->con,
00958
00959 OCIRawAssignBytes(OCILib.env, elem->con->err, (ub1*) value,
00960 len, (OCIRaw **) &elem->handle)
00961 )
00962
00963 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
00964 }
00965
00966 OCI_RESULT(res);
00967
00968 return res;
00969 }
00970
00971
00972
00973
00974
00975 boolean OCI_API OCI_ElemSetDate
00976 (
00977 OCI_Elem *elem,
00978 OCI_Date *value
00979 )
00980 {
00981 boolean res = TRUE;
00982
00983 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
00984 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_DATETIME, FALSE);
00985
00986 if (value == NULL)
00987 {
00988 res = OCI_ElemSetNull(elem);
00989 }
00990 else
00991 {
00992 if (elem->obj == NULL)
00993 {
00994 OCI_DateInit(elem->con, (OCI_Date **) &elem->obj,
00995 (OCIDate *) elem->handle, TRUE, FALSE);
00996 }
00997
00998 if (elem->obj != NULL)
00999 {
01000 res = OCI_DateAssign((OCI_Date *) elem->obj, value);
01001
01002 if (res == TRUE)
01003 {
01004 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01005
01006 elem->handle = ((OCI_Date *) elem->obj)->handle;
01007 }
01008 }
01009 }
01010
01011 OCI_RESULT(res);
01012
01013 return res;
01014 }
01015
01016
01017
01018
01019
01020 boolean OCI_API OCI_ElemSetTimestamp
01021 (
01022 OCI_Elem *elem,
01023 OCI_Timestamp *value
01024 )
01025 {
01026 boolean res = TRUE;
01027
01028 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01029 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_TIMESTAMP, FALSE);
01030
01031 if (value == NULL)
01032 {
01033 res = OCI_ElemSetNull(elem);
01034 }
01035 else
01036 {
01037 if (elem->obj == NULL)
01038 {
01039 OCI_TimestampInit(elem->con, (OCI_Timestamp **) &elem->obj,
01040 (OCIDateTime *) elem->handle,
01041 elem->typinf->cols[0].subtype);
01042 }
01043
01044 if (elem->obj != NULL)
01045 {
01046 res = OCI_TimestampAssign((OCI_Timestamp *) elem->obj, value);
01047
01048 if (res == TRUE)
01049 {
01050 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01051
01052 elem->handle = ((OCI_Timestamp *) elem->obj)->handle;
01053 }
01054 }
01055 }
01056
01057 OCI_RESULT(res);
01058
01059 return res;
01060 }
01061
01062
01063
01064
01065
01066 boolean OCI_API OCI_ElemSetInterval
01067 (
01068 OCI_Elem *elem,
01069 OCI_Interval *value
01070 )
01071 {
01072 boolean res = TRUE;
01073
01074 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01075 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_INTERVAL, FALSE);
01076
01077 if (value == NULL)
01078 {
01079 res = OCI_ElemSetNull(elem);
01080 }
01081 else
01082 {
01083 if (elem->obj == NULL)
01084 {
01085 OCI_IntervalInit(elem->con, (OCI_Interval **) &elem->obj,
01086 (OCIInterval *) elem->handle,
01087 elem->typinf->cols[0].subtype);
01088 }
01089
01090 if (elem->obj != NULL)
01091 {
01092 res = OCI_IntervalAssign((OCI_Interval *) elem->obj, value);
01093
01094 if (res == TRUE)
01095 {
01096 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01097
01098 elem->handle = ((OCI_Interval *) elem->obj)->handle;
01099 }
01100 }
01101 }
01102
01103 OCI_RESULT(res);
01104
01105 return res;
01106 }
01107
01108
01109
01110
01111
01112 boolean OCI_API OCI_ElemSetColl
01113 (
01114 OCI_Elem *elem,
01115 OCI_Coll *value
01116 )
01117 {
01118 boolean res = TRUE;
01119
01120 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01121 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_COLLECTION, FALSE);
01122
01123 if (value == NULL)
01124 {
01125 res = OCI_ElemSetNull(elem);
01126 }
01127 else
01128 {
01129 if (elem->obj == NULL)
01130 {
01131 OCI_CollInit(elem->con, (OCI_Coll **) &elem->obj,
01132 (OCIColl *) elem->handle,
01133 elem->typinf->cols[0].typinf);
01134 }
01135
01136 if (elem->obj != NULL)
01137 {
01138 res = OCI_CollAssign((OCI_Coll *) elem->obj, value);
01139
01140 if (res == TRUE)
01141 {
01142 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01143
01144 elem->handle = ((OCI_Coll *) elem->obj)->handle;
01145 }
01146 }
01147 }
01148
01149 OCI_RESULT(res);
01150
01151 return res;
01152 }
01153
01154
01155
01156
01157
01158 boolean OCI_API OCI_ElemSetObject
01159 (
01160 OCI_Elem *elem,
01161 OCI_Object *value
01162 )
01163 {
01164 boolean res = TRUE;
01165
01166 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01167 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_OBJECT, FALSE);
01168
01169 if (value == NULL)
01170 {
01171 res = OCI_ElemSetNull(elem);
01172 }
01173 else
01174 {
01175 if (elem->obj == NULL)
01176 {
01177 OCI_ObjectInit(elem->con, (OCI_Object **) &elem->obj,
01178 elem->handle, elem->typinf->cols[0].typinf,
01179 NULL, -1, TRUE);
01180 }
01181
01182 if (elem->obj != NULL)
01183 {
01184 res = OCI_ObjectAssign((OCI_Object *) elem->obj, value);
01185
01186 if (res == TRUE)
01187 {
01188 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01189
01190 elem->handle = ((OCI_Object *) elem->obj)->handle;
01191 }
01192 }
01193 }
01194
01195 OCI_RESULT(res);
01196
01197 return res;
01198 }
01199
01200
01201
01202
01203
01204 boolean OCI_API OCI_ElemSetLob
01205 (
01206 OCI_Elem *elem,
01207 OCI_Lob *value
01208 )
01209 {
01210 boolean res = TRUE;
01211
01212 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01213 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_LOB, FALSE);
01214
01215 if (value == NULL)
01216 {
01217 res = OCI_ElemSetNull(elem);
01218 }
01219 else
01220 {
01221 if (elem->obj == NULL)
01222 {
01223 OCI_LobInit(elem->con, (OCI_Lob **) &elem->obj,
01224 (OCILobLocator *) elem->handle,
01225 elem->typinf->cols[0].subtype);
01226 }
01227
01228 if (elem->obj != NULL)
01229 {
01230 res = OCI_LobAssign((OCI_Lob *) elem->obj, value);
01231
01232 if (res == TRUE)
01233 {
01234 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01235
01236 elem->handle = ((OCI_Lob *) elem->obj)->handle;
01237 }
01238 }
01239 }
01240
01241 OCI_RESULT(res);
01242
01243 return res;
01244 }
01245
01246
01247
01248
01249
01250 boolean OCI_API OCI_ElemSetFile
01251 (
01252 OCI_Elem *elem,
01253 OCI_File *value
01254 )
01255 {
01256 boolean res = TRUE;
01257
01258 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01259 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_FILE, FALSE);
01260
01261 if (value == NULL)
01262 {
01263 res = OCI_ElemSetNull(elem);
01264 }
01265 else
01266 {
01267 if (elem->obj == NULL)
01268 {
01269 OCI_FileInit(elem->con, (OCI_File **) &elem->obj,
01270 (OCILobLocator *) elem->handle,
01271 elem->typinf->cols[0].subtype);
01272 }
01273
01274 if (elem->obj != NULL)
01275 {
01276 res = OCI_FileAssign((OCI_File *) elem->obj, value);
01277
01278 if (res == TRUE)
01279 {
01280 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01281
01282 elem->handle = ((OCI_Object *) elem->obj)->handle;
01283 }
01284 }
01285 }
01286
01287 OCI_RESULT(res);
01288
01289 return res;
01290 }
01291
01292
01293
01294
01295
01296 boolean OCI_API OCI_ElemSetRef
01297 (
01298 OCI_Elem *elem,
01299 OCI_Ref *value
01300 )
01301 {
01302 boolean res = TRUE;
01303
01304 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01305 OCI_CHECK_COMPAT(elem->con, elem->typinf->cols[0].type == OCI_CDT_REF, FALSE);
01306
01307 if (value == NULL)
01308 {
01309 res = OCI_ElemSetNull(elem);
01310 }
01311 else
01312 {
01313 if (elem->obj == NULL)
01314 {
01315 OCI_RefInit(elem->con,elem->typinf->cols[0].typinf,
01316 (OCI_Ref **) &elem->obj, (OCIRef *) elem->handle);
01317 }
01318
01319 if (elem->obj != NULL)
01320 {
01321 res = OCI_RefAssign((OCI_Ref *) elem->obj, value);
01322
01323 if (res == TRUE)
01324 {
01325 OCI_ElemSetNullIndicator(elem, OCI_IND_NOTNULL);
01326
01327 elem->handle = ((OCI_Ref *) elem->obj)->handle;
01328 }
01329 }
01330 }
01331
01332 OCI_RESULT(res);
01333
01334 return res;
01335 }
01336
01337
01338
01339
01340
01341 boolean OCI_API OCI_ElemIsNull
01342 (
01343 OCI_Elem *elem
01344 )
01345 {
01346 boolean ret = FALSE;
01347
01348 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01349
01350 if (elem->pind != NULL)
01351 {
01352 ret = (*elem->pind == OCI_IND_NULL);
01353 }
01354
01355 OCI_RESULT(TRUE);
01356
01357 return ret;
01358 }
01359
01360
01361
01362
01363
01364 boolean OCI_API OCI_ElemSetNull
01365 (
01366 OCI_Elem *elem
01367 )
01368 {
01369 boolean res = FALSE;
01370
01371 OCI_CHECK_PTR(OCI_IPC_ELEMENT, elem, FALSE);
01372
01373 res = OCI_ElemSetNullIndicator(elem, OCI_IND_NULL);
01374
01375 OCI_RESULT(res);
01376
01377 return res;
01378 }