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