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