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 ub2 OCI_ObjectGetIndOffset
00046 (
00047 OCI_TypeInfo *typinf,
00048 int index
00049 )
00050 {
00051 ub2 i = 0, j = 1;
00052
00053 for (i = 0; i < index; i++)
00054 {
00055 if (typinf->cols[i].type == OCI_CDT_OBJECT)
00056 {
00057 j += OCI_ObjectGetIndOffset(typinf->cols[i].typinf,
00058 typinf->cols[i].typinf->nb_cols);
00059 }
00060 else
00061 {
00062 j++;
00063 }
00064
00065 }
00066
00067 return j;
00068 }
00069
00070
00071
00072
00073
00074 size_t OCI_ObjectGetStructSize
00075 (
00076 OCI_TypeInfo *typinf
00077 )
00078 {
00079 size_t size1 = 0;
00080 size_t size2 = 0;
00081
00082 int type1 = 0;
00083 int type2 = 0;
00084
00085 ub2 i;
00086
00087 boolean align = FALSE;
00088
00089 size_t size = 0;
00090
00091 if (typinf->struct_size != 0)
00092 {
00093 size = typinf->struct_size;
00094 }
00095 else
00096 {
00097 for (i = 0; i < typinf->nb_cols; i++)
00098 {
00099 align = FALSE;
00100
00101 if (i > 0)
00102 {
00103 size1 = size2;
00104 type1 = type2;
00105
00106 typinf->offsets[i] = (int) size;
00107 }
00108 else
00109 {
00110 OCI_ObjectGetAttrInfo(typinf, i, &size1, &type1);
00111
00112 typinf->offsets[i] = 0;
00113 }
00114
00115 OCI_ObjectGetAttrInfo(typinf, i+1, &size2, &type2);
00116
00117 switch (OCI_OFFSET_PAIR(type1, type2))
00118 {
00119 case OCI_OFFSET_PAIR(OCI_OFT_NUMBER, OCI_OFT_POINTER):
00120 case OCI_OFFSET_PAIR(OCI_OFT_DATE, OCI_OFT_POINTER):
00121 case OCI_OFFSET_PAIR(OCI_OFT_OBJECT, OCI_OFT_POINTER):
00122
00123 align = TRUE;
00124 break;
00125 }
00126
00127 size += size1;
00128
00129 if (align)
00130 {
00131 size = ROUNDUP(size);
00132 }
00133 }
00134
00135 typinf->struct_size = size + size2;
00136 }
00137
00138 return size;
00139 }
00140
00141
00142
00143
00144
00145 boolean OCI_ObjectGetAttrInfo
00146 (
00147 OCI_TypeInfo *typinf,
00148 int index,
00149 size_t *p_size,
00150 int *p_type
00151 )
00152 {
00153 if (index >= typinf->nb_cols)
00154 {
00155 *p_size = 0;
00156 *p_type = 0;
00157
00158 return FALSE;
00159 }
00160
00161 switch (typinf->cols[index].type)
00162 {
00163 case OCI_CDT_NUMERIC:
00164
00165 *p_size = sizeof(OCINumber);
00166 *p_type = OCI_OFT_NUMBER;
00167 break;
00168
00169 case OCI_CDT_DATETIME:
00170
00171 *p_size = sizeof(OCIDate);
00172 *p_type = OCI_OFT_DATE;
00173 break;
00174
00175 case OCI_CDT_OBJECT:
00176
00177 *p_size = OCI_ObjectGetStructSize(typinf->cols[index].typinf);
00178 *p_type = OCI_OFT_OBJECT;
00179 break;
00180
00181 default:
00182
00183 *p_size = sizeof(void *);
00184 *p_type = OCI_OFT_POINTER;
00185 }
00186
00187 return TRUE;
00188 }
00189
00190
00191
00192
00193
00194 OCI_Object * OCI_ObjectInit
00195 (
00196 OCI_Connection *con,
00197 OCI_Object **pobj,
00198 void *handle,
00199 OCI_TypeInfo *typinf,
00200 OCI_Object *parent,
00201 int index,
00202 boolean reset
00203 )
00204 {
00205 OCI_Object * obj = NULL;
00206 boolean res = TRUE;
00207
00208 OCI_CHECK(pobj == NULL, NULL);
00209
00210 if (*pobj == NULL)
00211 *pobj = (OCI_Object *) OCI_MemAlloc(OCI_IPC_OBJECT, sizeof(*obj),
00212 (size_t) 1, TRUE);
00213
00214 if (*pobj != NULL)
00215 {
00216 obj = *pobj;
00217
00218 obj->con = con;
00219 obj->handle = handle;
00220 obj->typinf = typinf;
00221
00222 if (obj->objs == NULL)
00223 {
00224 obj->objs = (void **) OCI_MemAlloc(OCI_IPC_BUFF_ARRAY,
00225 sizeof(void *),
00226 (size_t) typinf->nb_cols,
00227 TRUE);
00228 }
00229 else
00230 {
00231 OCI_ObjectReset(obj);
00232 }
00233
00234 res = (obj->objs != NULL);
00235
00236 if (((res == TRUE)) &&
00237 ((obj->handle == NULL) || (obj->hstate == OCI_OBJECT_ALLOCATED_ARRAY)))
00238 {
00239
00240
00241 if (obj->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00242 {
00243 obj->hstate = OCI_OBJECT_ALLOCATED;
00244 }
00245
00246 OCI_CALL2
00247 (
00248 res, obj->con,
00249
00250 OCI_ObjectNew(OCILib.env, con->err, con->cxt,
00251 (OCITypeCode) SQLT_NTY, obj->typinf->tdo,
00252 (dvoid *) NULL,
00253 (OCIDuration) OCI_DURATION_SESSION,
00254 (boolean) TRUE,
00255 (dvoid **) &obj->handle)
00256 )
00257 }
00258 else
00259 {
00260 obj->hstate = OCI_OBJECT_FETCHED_CLEAN;
00261 }
00262
00263 if ((res == TRUE) && (obj->type == 0))
00264 {
00265 ub4 size = sizeof(obj->type);
00266
00267
00268
00269
00270
00271
00272
00273 if (parent == NULL)
00274 {
00275 OCIObjectGetProperty(OCILib.env, con->err, obj->handle,
00276 (OCIObjectPropId) OCI_OBJECTPROP_LIFETIME,
00277 (void *) &obj->type, &size);
00278 }
00279 else
00280 {
00281 obj->type = OCI_OBJECT_VALUE;
00282 }
00283 }
00284
00285 if ((res == TRUE) && ((reset == TRUE) || (obj->tab_ind == NULL)))
00286 {
00287 if (parent == NULL)
00288 {
00289 OCI_CALL2
00290 (
00291 res, obj->con,
00292
00293 OCIObjectGetInd(OCILib.env, obj->con->err,
00294 (dvoid *) obj->handle,
00295 (dvoid **) &obj->tab_ind)
00296 )
00297 }
00298 else
00299 {
00300 obj->tab_ind = parent->tab_ind;
00301 obj->idx_ind = parent->idx_ind + OCI_ObjectGetIndOffset(parent->typinf, index);
00302 }
00303 }
00304 }
00305 else
00306 res = FALSE;
00307
00308
00309
00310 if (res == FALSE)
00311 {
00312 OCI_ObjectFree(obj);
00313 obj = NULL;
00314 }
00315
00316 return obj;
00317 }
00318
00319
00320
00321
00322
00323 void OCI_ObjectReset
00324 (
00325 OCI_Object *obj
00326 )
00327 {
00328 ub2 i;
00329
00330 for (i = 0; i < obj->typinf->nb_cols; i++)
00331 {
00332 if (obj->objs[i] != NULL)
00333 {
00334 OCI_Datatype * data = (OCI_Datatype *) obj->objs[i];
00335
00336 if (data->hstate == OCI_OBJECT_FETCHED_CLEAN)
00337 data->hstate = OCI_OBJECT_FETCHED_DIRTY;
00338
00339 switch (obj->typinf->cols[i].type)
00340 {
00341 case OCI_CDT_DATETIME:
00342
00343 OCI_DateFree((OCI_Date *) obj->objs[i]);
00344 break;
00345
00346 case OCI_CDT_LOB:
00347
00348 OCI_LobFree((OCI_Lob *) obj->objs[i]);
00349 break;
00350
00351 case OCI_CDT_FILE:
00352
00353 OCI_FileFree((OCI_File *) obj->objs[i]);
00354 break;
00355
00356 case OCI_CDT_OBJECT:
00357
00358 OCI_ObjectFree((OCI_Object *) obj->objs[i]);
00359 break;
00360
00361 case OCI_CDT_COLLECTION:
00362
00363 OCI_CollFree((OCI_Coll *) obj->objs[i]);;
00364 break;
00365
00366 case OCI_CDT_TIMESTAMP:
00367
00368 OCI_TimestampFree((OCI_Timestamp *) obj->objs[i]);
00369 break;
00370
00371 case OCI_CDT_INTERVAL:
00372
00373 OCI_IntervalFree((OCI_Interval *) obj->objs[i]);
00374 break;
00375 case OCI_CDT_REF:
00376
00377 OCI_RefFree((OCI_Ref *) obj->objs[i]);
00378 break;
00379 }
00380
00381 obj->objs[i] = NULL;
00382 }
00383 }
00384 }
00385
00386
00387
00388
00389
00390 int OCI_ObjectGetAttrIndex
00391 (
00392 OCI_Object *obj,
00393 const mtext *attr,
00394 int type
00395 )
00396 {
00397 int res = -1;
00398 ub2 i;
00399
00400 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, -1);
00401 OCI_CHECK_PTR(OCI_IPC_STRING, attr, -1);
00402
00403 for (i = 0; i < obj->typinf->nb_cols; i++)
00404 {
00405 OCI_Column *col = &obj->typinf->cols[i];
00406
00407 if (((type == -1) || (col->type == type)) &&
00408 (mtscasecmp(col->name, attr) == 0))
00409 {
00410 res = (int) i;
00411 break;
00412 }
00413 }
00414
00415 if (res == -1)
00416 OCI_ExceptionAttributeNotFound(obj->con, attr);
00417
00418 return res;
00419 }
00420
00421
00422
00423
00424
00425 void * OCI_ObjectGetAttr
00426 (
00427 OCI_Object *obj,
00428 unsigned int index,
00429 OCIInd **pind
00430 )
00431 {
00432 size_t offset = 0;
00433
00434 if (obj->typinf->struct_size == 0)
00435 {
00436 OCI_ObjectGetStructSize(obj->typinf);
00437 }
00438
00439 offset = (size_t) obj->typinf->offsets[index];
00440
00441 if (pind != NULL)
00442 {
00443 *pind = &obj->tab_ind[OCI_ObjectGetIndOffset(obj->typinf, index)];
00444 }
00445
00446 return ((char *) obj->handle + offset);
00447 }
00448
00449
00450
00451
00452
00453 boolean OCI_ObjectSetNumber
00454 (
00455 OCI_Object *obj,
00456 const mtext *attr,
00457 void *value,
00458 uword size,
00459 uword flag
00460 )
00461 {
00462 boolean res = FALSE;
00463 int index = 0;
00464
00465 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00466
00467 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_NUMERIC);
00468
00469 if (index >= 0)
00470 {
00471 OCIInd *ind = NULL;
00472 OCINumber *num = OCI_ObjectGetAttr(obj, index, &ind);
00473
00474 res = OCI_NumberSet(obj->con, num, value, size, flag);
00475
00476 if (res == TRUE)
00477 *ind = OCI_IND_NOTNULL;
00478 }
00479
00480 OCI_RESULT(res);
00481
00482 return res;
00483 }
00484
00485
00486
00487
00488
00489 boolean OCI_ObjectGetNumber
00490 (
00491 OCI_Object *obj,
00492 const mtext *attr,
00493 void *value,
00494 uword size,
00495 uword flag
00496 )
00497 {
00498 boolean res = FALSE;
00499 int index = 0;
00500
00501 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00502
00503 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_NUMERIC);
00504
00505 if (index >= 0)
00506 {
00507 OCIInd *ind = NULL;
00508 OCINumber *num = NULL;
00509
00510 num = OCI_ObjectGetAttr(obj, index, &ind);
00511
00512 if ((num != NULL) && (*ind != OCI_IND_NULL))
00513 {
00514 res = OCI_NumberGet(obj->con, num, value, size, flag);
00515 }
00516 }
00517 else
00518 {
00519 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
00520
00521 if (index >= 0)
00522 {
00523 const mtext *fmt = OCI_GetDefaultFormatNumeric(obj->con);
00524 ub4 fmt_size = (ub4) mtslen(fmt);
00525 dtext *data = (dtext *) OCI_ObjectGetString(obj, attr);
00526
00527 res = OCI_NumberGetFromStr(obj->con, value, size, flag, data,
00528 (int) dtslen(data), fmt, fmt_size);
00529 }
00530 }
00531
00532 OCI_RESULT(res);
00533
00534 return res;
00535 }
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545 OCI_Object * OCI_API OCI_ObjectCreate
00546 (
00547 OCI_Connection *con,
00548 OCI_TypeInfo *typinf
00549 )
00550 {
00551 OCI_Object *obj = NULL;
00552
00553 OCI_CHECK_INITIALIZED(NULL);
00554
00555 OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
00556 OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00557
00558 obj = OCI_ObjectInit(con, &obj, NULL, typinf, NULL, -1, TRUE);
00559
00560 OCI_RESULT(obj != NULL);
00561
00562 return obj;
00563 }
00564
00565
00566
00567
00568
00569 boolean OCI_API OCI_ObjectFree
00570 (
00571 OCI_Object *obj
00572 )
00573 {
00574 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00575
00576 OCI_CHECK_OBJECT_FETCHED(obj, FALSE);
00577
00578
00579
00580
00581 OCI_ObjectReset(obj);
00582
00583 if (obj->objs != NULL)
00584 {
00585 OCI_FREE(obj->objs);
00586 }
00587
00588 if ((obj->hstate == OCI_OBJECT_ALLOCATED ) ||
00589 (obj->hstate == OCI_OBJECT_ALLOCATED_ARRAY))
00590 {
00591 OCI_OCIObjectFree(OCILib.env, obj->con->err, obj->handle,
00592 OCI_OBJECTFREE_NONULL);
00593 }
00594
00595 OCI_FREE(obj->buf);
00596
00597 if (obj->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00598 {
00599 OCI_FREE(obj);
00600 }
00601
00602 OCI_RESULT(TRUE);
00603
00604 return TRUE;
00605 }
00606
00607
00608
00609
00610
00611 OCI_Object ** OCI_API OCI_ObjectArrayCreate
00612 (
00613 OCI_Connection *con,
00614 OCI_TypeInfo *typinf,
00615 unsigned int nbelem
00616 )
00617 {
00618 OCI_Array *arr = NULL;
00619 OCI_Object **objs = NULL;
00620
00621 arr = OCI_ArrayCreate(con, nbelem, OCI_CDT_OBJECT, 0,
00622 sizeof(void *), sizeof(OCI_Object),
00623 0, typinf);
00624
00625 if (arr != NULL)
00626 {
00627 objs = (OCI_Object **) arr->tab_obj;
00628 }
00629
00630 return objs;
00631 }
00632
00633
00634
00635
00636
00637 boolean OCI_API OCI_ObjectArrayFree
00638 (
00639 OCI_Object **objs
00640 )
00641 {
00642 return OCI_ArrayFreeFromHandles((void **) objs);
00643 }
00644
00645
00646
00647
00648
00649 boolean OCI_API OCI_ObjectAssign
00650 (
00651 OCI_Object *obj,
00652 OCI_Object *obj_src
00653 )
00654 {
00655 boolean res = TRUE;
00656
00657 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00658 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj_src, FALSE);
00659
00660 OCI_CHECK_COMPAT(obj->con, obj->typinf->tdo == obj_src->typinf->tdo, FALSE);
00661
00662 OCI_CALL2
00663 (
00664 res, obj->con,
00665
00666 OCIObjectCopy(OCILib.env, obj->con->err, obj->con->cxt,
00667 obj_src->handle, (obj_src->tab_ind + obj_src->idx_ind),
00668 obj->handle, (obj->tab_ind + obj->idx_ind),
00669 obj->typinf->tdo, OCI_DURATION_SESSION, OCI_DEFAULT)
00670 )
00671
00672 if (res == TRUE)
00673 {
00674 obj->typinf = obj_src->typinf;
00675
00676 OCI_ObjectReset(obj);
00677 }
00678
00679 OCI_RESULT(res);
00680
00681 return res;
00682 }
00683
00684
00685
00686
00687
00688 short OCI_API OCI_ObjectGetShort
00689 (
00690 OCI_Object *obj,
00691 const mtext *attr
00692 )
00693 {
00694 short value = 0;
00695
00696 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_SHORT);
00697
00698 return value;
00699 }
00700
00701
00702
00703
00704
00705 unsigned short OCI_API OCI_ObjectGetUnsignedShort
00706 (
00707 OCI_Object *obj,
00708 const mtext *attr
00709 )
00710 {
00711 unsigned short value = 0;
00712
00713 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_USHORT);
00714
00715 return value;
00716 }
00717
00718
00719
00720
00721
00722 int OCI_API OCI_ObjectGetInt
00723 (
00724 OCI_Object *obj,
00725 const mtext *attr
00726 )
00727 {
00728 int value = 0;
00729
00730 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_INT);
00731
00732 return value;
00733 }
00734
00735
00736
00737
00738
00739 unsigned int OCI_API OCI_ObjectGetUnsignedInt
00740 (
00741 OCI_Object *obj,
00742 const mtext *attr
00743 )
00744 {
00745 unsigned int value = 0;
00746
00747 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_UINT);
00748
00749 return value;
00750 }
00751
00752
00753
00754
00755
00756 big_int OCI_API OCI_ObjectGetBigInt
00757 (
00758 OCI_Object *obj,
00759 const mtext *attr
00760 )
00761 {
00762 big_int value = 0;
00763
00764 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGINT);
00765
00766 return value;
00767 }
00768
00769
00770
00771
00772
00773 big_uint OCI_API OCI_ObjectGetUnsignedBigInt
00774 (
00775 OCI_Object *obj,
00776 const mtext *attr
00777 )
00778 {
00779 big_uint value = 0;
00780
00781 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGUINT);
00782
00783 return value;
00784 }
00785
00786
00787
00788
00789
00790 double OCI_API OCI_ObjectGetDouble
00791 (
00792 OCI_Object *obj,
00793 const mtext *attr
00794 )
00795 {
00796 double value = 0.0;
00797
00798 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_DOUBLE);
00799
00800 return value;
00801 }
00802
00803
00804
00805
00806
00807 const dtext * OCI_API OCI_ObjectGetString
00808 (
00809 OCI_Object *obj,
00810 const mtext *attr
00811 )
00812 {
00813 const dtext *str = NULL;
00814 boolean res = TRUE;
00815 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
00816
00817 if (index >= 0)
00818 {
00819 OCIInd *ind = NULL;
00820 OCIString **value = NULL;
00821
00822 value = OCI_ObjectGetAttr(obj, index, &ind);
00823
00824 if ((value != NULL) && (*ind != OCI_IND_NULL))
00825 {
00826 str = (dtext *) OCI_StringFromStringPtr(*value, &obj->buf, &obj->buflen);
00827 }
00828 }
00829
00830 OCI_RESULT(res);
00831
00832 return str;
00833 }
00834
00835
00836
00837
00838
00839 int OCI_API OCI_ObjectGetRaw
00840 (
00841 OCI_Object *obj,
00842 const mtext *attr,
00843 void *buffer,
00844 unsigned int len
00845 )
00846 {
00847 boolean res = TRUE;
00848 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_RAW);
00849 ub4 raw_len = 0;
00850
00851 if (index >= 0)
00852 {
00853 OCIInd *ind = NULL;
00854 OCIRaw **value = NULL;
00855
00856 value = OCI_ObjectGetAttr(obj, index, &ind);
00857
00858 if ((value != NULL) && (*ind != OCI_IND_NULL))
00859 {
00860 raw_len = OCIRawSize(OCILib.env, *value);
00861
00862 if (len > raw_len)
00863 len = raw_len;
00864
00865 memcpy(buffer, OCIRawPtr(OCILib.env, *value), (size_t) len);
00866 }
00867 }
00868
00869 OCI_RESULT(res);
00870
00871 return len;
00872 }
00873
00874
00875
00876
00877
00878 OCI_Date * OCI_API OCI_ObjectGetDate
00879 (
00880 OCI_Object *obj,
00881 const mtext *attr
00882 )
00883 {
00884 OCI_Date * date = NULL;
00885 boolean res = TRUE;
00886 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_DATETIME);
00887
00888 if (index >= 0)
00889 {
00890 OCIInd *ind = NULL;
00891 OCIDate *value = NULL;
00892
00893 value = OCI_ObjectGetAttr(obj, index, &ind);
00894
00895 if ((value != NULL) && (*ind != OCI_IND_NULL))
00896 {
00897 date = OCI_DateInit(obj->con, (OCI_Date **) &obj->objs[index],
00898 value, FALSE, FALSE);
00899
00900 res = (date != NULL);
00901 }
00902 }
00903
00904 OCI_RESULT(res);
00905
00906 return date;
00907 }
00908
00909
00910
00911
00912
00913 OCI_Timestamp * OCI_API OCI_ObjectGetTimestamp
00914 (
00915 OCI_Object *obj,
00916 const mtext *attr
00917 )
00918 {
00919 OCI_Timestamp *tmsp = NULL;
00920 boolean res = TRUE;
00921
00922 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TIMESTAMP);
00923
00924 if (index >= 0)
00925 {
00926 OCIInd *ind = NULL;
00927 OCIDateTime **value = NULL;
00928
00929 value = OCI_ObjectGetAttr(obj, index, &ind);
00930
00931 if ((value != NULL) && (*ind != OCI_IND_NULL))
00932 {
00933 tmsp = OCI_TimestampInit(obj->con,
00934 (OCI_Timestamp **) &obj->objs[index],
00935 (OCIDateTime *) *value,
00936 obj->typinf->cols[index].subtype);
00937
00938 res = (tmsp != NULL);
00939 }
00940 }
00941
00942 OCI_RESULT(res);
00943
00944 return tmsp;
00945 }
00946
00947
00948
00949
00950
00951 OCI_Interval * OCI_API OCI_ObjectGetInterval
00952 (
00953 OCI_Object *obj,
00954 const mtext *attr
00955 )
00956 {
00957 OCI_Interval *itv = NULL;
00958 boolean res = TRUE;
00959 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_INTERVAL);
00960
00961 if (index >= 0)
00962 {
00963 OCIInd *ind = NULL;
00964 OCIInterval **value = NULL;
00965
00966 value = OCI_ObjectGetAttr(obj, index, &ind);
00967
00968 if ((value != NULL) && (*ind != OCI_IND_NULL))
00969 {
00970 itv = OCI_IntervalInit(obj->con,
00971 (OCI_Interval **) &obj->objs[index],
00972 (OCIInterval *) *value,
00973 obj->typinf->cols[index].subtype);
00974
00975 res = (itv != NULL);
00976 }
00977 }
00978
00979 OCI_RESULT(res);
00980
00981 return itv;
00982 }
00983
00984
00985
00986
00987
00988 OCI_Coll * OCI_API OCI_ObjectGetColl
00989 (
00990 OCI_Object *obj,
00991 const mtext *attr
00992 )
00993 {
00994 OCI_Coll *coll = NULL;
00995 boolean res = TRUE;
00996 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_COLLECTION);
00997
00998 if (index >= 0)
00999 {
01000 OCIInd *ind = NULL;
01001 OCIColl **value = NULL;
01002
01003 value = OCI_ObjectGetAttr(obj, index, &ind);
01004
01005 if ((value != NULL) && (*ind != OCI_IND_NULL))
01006 {
01007 coll = OCI_CollInit(obj->con,
01008 (OCI_Coll **) &obj->objs[index],
01009 (OCIColl *) *value,
01010 obj->typinf->cols[index].typinf);
01011
01012 res = (coll != NULL);
01013 }
01014 }
01015
01016 OCI_RESULT(res);
01017
01018 return coll;
01019 }
01020
01021
01022
01023
01024
01025 OCI_Object * OCI_API OCI_ObjectGetObject
01026 (
01027 OCI_Object *obj,
01028 const mtext *attr
01029 )
01030 {
01031 OCI_Object *obj2 = NULL;
01032 boolean res = TRUE;
01033 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_OBJECT);
01034
01035 if (index >= 0)
01036 {
01037 OCIInd *ind = NULL;
01038 void *value = NULL;
01039
01040 value = OCI_ObjectGetAttr(obj, index, &ind);
01041
01042 if ((value != NULL) && (*ind != OCI_IND_NULL))
01043 {
01044 obj2 = OCI_ObjectInit(obj->con, (OCI_Object **) &obj->objs[index],
01045 value, obj->typinf->cols[index].typinf,
01046 obj, index, FALSE);
01047
01048 res = (obj2 != NULL);
01049 }
01050 }
01051
01052 OCI_RESULT(res);
01053
01054 return obj2;
01055 }
01056
01057
01058
01059
01060
01061 OCI_Lob * OCI_API OCI_ObjectGetLob
01062 (
01063 OCI_Object *obj,
01064 const mtext *attr
01065 )
01066 {
01067 OCI_Lob *lob = NULL;
01068 boolean res = TRUE;
01069 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_LOB);
01070
01071 if (index >= 0)
01072 {
01073 OCIInd *ind = NULL;
01074 OCILobLocator **value = NULL;
01075
01076 value = OCI_ObjectGetAttr(obj, index, &ind);
01077
01078 if ((value != NULL) && (*ind != OCI_IND_NULL))
01079 {
01080 lob = OCI_LobInit(obj->con, (OCI_Lob **) &obj->objs[index],
01081 *value, obj->typinf->cols[index].subtype);
01082
01083 res = (lob != NULL);
01084 }
01085 }
01086
01087 OCI_RESULT(res);
01088
01089 return lob;
01090 }
01091
01092
01093
01094
01095
01096 OCI_File * OCI_API OCI_ObjectGetFile
01097 (
01098 OCI_Object *obj,
01099 const mtext *attr
01100 )
01101 {
01102 OCI_File *file = NULL;
01103 boolean res = TRUE;
01104 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_FILE);
01105
01106 if (index >= 0)
01107 {
01108 OCIInd *ind = NULL;
01109 OCILobLocator **value = NULL;
01110
01111 value = OCI_ObjectGetAttr(obj, index, &ind);
01112
01113 if ((value != NULL) && (*ind != OCI_IND_NULL))
01114 {
01115 file = OCI_FileInit(obj->con, (OCI_File **) &obj->objs[index],
01116 *value, obj->typinf->cols[index].subtype);
01117
01118 res = (file != NULL);
01119 }
01120 }
01121
01122 OCI_RESULT(res);
01123
01124 return file;
01125 }
01126
01127
01128
01129
01130
01131 OCI_Ref * OCI_API OCI_ObjectGetRef
01132 (
01133 OCI_Object *obj,
01134 const mtext *attr
01135 )
01136 {
01137 OCI_Ref *ref = NULL;
01138 boolean res = TRUE;
01139 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_REF);
01140
01141 if (index >= 0)
01142 {
01143 OCIInd *ind = NULL;
01144 OCIRef **value = NULL;
01145
01146 value = OCI_ObjectGetAttr(obj, index, &ind);
01147
01148 if ((value != NULL) && (*ind != OCI_IND_NULL))
01149 {
01150 ref = OCI_RefInit(obj->con, NULL, (OCI_Ref **) &obj->objs[index],
01151 *value);
01152
01153 res = (ref != NULL);
01154 }
01155 }
01156
01157 OCI_RESULT(res);
01158
01159 return ref;
01160 }
01161
01162
01163
01164
01165
01166 boolean OCI_API OCI_ObjectSetShort
01167 (
01168 OCI_Object *obj,
01169 const mtext *attr,
01170 short value
01171 )
01172 {
01173 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01174 (uword) OCI_NUM_SHORT);
01175 }
01176
01177
01178
01179
01180
01181 boolean OCI_API OCI_ObjectSetUnsignedShort
01182 (
01183 OCI_Object *obj,
01184 const mtext *attr,
01185 unsigned short value
01186 )
01187 {
01188 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01189 (uword) OCI_NUM_USHORT);
01190 }
01191
01192
01193
01194
01195
01196 boolean OCI_API OCI_ObjectSetInt
01197 (
01198 OCI_Object *obj,
01199 const mtext *attr,
01200 int value
01201 )
01202 {
01203 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01204 (uword) OCI_NUM_INT);
01205 }
01206
01207
01208
01209
01210
01211 boolean OCI_API OCI_ObjectSetUnsignedInt
01212 (
01213 OCI_Object *obj,
01214 const mtext *attr,
01215 unsigned int value
01216 )
01217 {
01218 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01219 (uword) OCI_NUM_UINT);
01220 }
01221
01222
01223
01224
01225
01226 boolean OCI_API OCI_ObjectSetBigInt
01227 (
01228 OCI_Object *obj,
01229 const mtext *attr,
01230 big_int value
01231 )
01232 {
01233 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01234 (uword) OCI_NUM_BIGINT);
01235 }
01236
01237
01238
01239
01240
01241 boolean OCI_API OCI_ObjectSetUnsignedBigInt
01242 (
01243 OCI_Object *obj,
01244 const mtext *attr,
01245 big_uint value
01246 )
01247 {
01248 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01249 (uword) OCI_NUM_BIGUINT);
01250 }
01251
01252
01253
01254
01255
01256 boolean OCI_API OCI_ObjectSetDouble
01257 (
01258 OCI_Object *obj,
01259 const mtext *attr,
01260 double value
01261 )
01262 {
01263 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01264 (uword) OCI_NUM_DOUBLE);
01265 }
01266
01267
01268
01269
01270
01271 boolean OCI_API OCI_ObjectSetString
01272 (
01273 OCI_Object *obj,
01274 const mtext *attr,
01275 const dtext *value
01276 )
01277 {
01278 boolean res = TRUE;
01279
01280 if (value == NULL)
01281 {
01282 res = OCI_ObjectSetNull(obj, attr);
01283 }
01284 else
01285 {
01286 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
01287
01288 if (index >= 0)
01289 {
01290 OCIInd *ind = NULL;
01291 OCIString **data = OCI_ObjectGetAttr(obj, index, &ind);
01292
01293 res = OCI_StringToStringPtr(data, obj->con->err, (void *) value,
01294 &obj->buf, &obj->buflen);
01295
01296 if (res == TRUE)
01297 *ind = OCI_IND_NOTNULL;
01298 }
01299 else
01300 res = FALSE;
01301 }
01302
01303 OCI_RESULT(res);
01304
01305 return res;
01306 }
01307
01308
01309
01310
01311
01312 boolean OCI_API OCI_ObjectSetRaw
01313 (
01314 OCI_Object *obj,
01315 const mtext *attr,
01316 void * value,
01317 unsigned int len
01318 )
01319 {
01320 boolean res = TRUE;
01321
01322 if (value == NULL)
01323 {
01324 res = OCI_ObjectSetNull(obj, attr);
01325 }
01326 else
01327 {
01328 int index;
01329
01330 OCI_CHECK_MIN(obj->con, NULL, len, 1, FALSE);
01331
01332 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_RAW);
01333
01334 if (index >= 0)
01335 {
01336 OCIInd *ind = NULL;
01337 OCIRaw **data = OCI_ObjectGetAttr(obj, index, &ind);
01338
01339 OCI_CALL2
01340 (
01341 res, obj->con,
01342
01343 OCIRawAssignBytes(OCILib.env, obj->con->err, (ub1*) value,
01344 len, data)
01345 )
01346
01347 if (res == TRUE)
01348 *ind = OCI_IND_NOTNULL;
01349 }
01350 else
01351 res = FALSE;
01352 }
01353
01354 OCI_RESULT(res);
01355
01356 return res;
01357 }
01358
01359
01360
01361
01362
01363 boolean OCI_API OCI_ObjectSetDate
01364 (
01365 OCI_Object *obj,
01366 const mtext *attr,
01367 OCI_Date *value
01368 )
01369 {
01370 boolean res = TRUE;
01371
01372 if (value == NULL)
01373 {
01374 res = OCI_ObjectSetNull(obj, attr);
01375 }
01376 else
01377 {
01378 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_DATETIME);
01379
01380 if (index >= 0)
01381 {
01382 OCIInd * ind = NULL;
01383 OCIDate *data = OCI_ObjectGetAttr(obj, index, &ind);
01384
01385 OCI_CALL2
01386 (
01387 res, obj->con,
01388
01389 OCIDateAssign(obj->con->err, value->handle, data)
01390 )
01391
01392 if (res == TRUE)
01393 *ind = OCI_IND_NOTNULL;
01394 }
01395 }
01396
01397 OCI_RESULT(res);
01398
01399 return res;
01400 }
01401
01402
01403
01404
01405
01406 boolean OCI_API OCI_ObjectSetTimestamp
01407 (
01408 OCI_Object *obj,
01409 const mtext *attr,
01410 OCI_Timestamp *value
01411 )
01412 {
01413 boolean res = TRUE;
01414
01415 if (value == NULL)
01416 {
01417 res = OCI_ObjectSetNull(obj, attr);
01418 }
01419 else
01420 {
01421 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TIMESTAMP);
01422
01423 if (index >= 0)
01424 {
01425 #if OCI_VERSION_COMPILE >= OCI_9_0
01426
01427 OCIInd * ind = NULL;
01428 OCIDateTime **data = OCI_ObjectGetAttr(obj, index, &ind);
01429
01430 OCI_CALL2
01431 (
01432 res, obj->con,
01433
01434 OCIDateTimeAssign((dvoid *) OCILib.env, obj->con->err,
01435 value->handle, *data)
01436 )
01437
01438 if (res == TRUE)
01439 *ind = OCI_IND_NOTNULL;
01440
01441 #endif
01442 }
01443 }
01444
01445 OCI_RESULT(res);
01446
01447 return res;
01448 }
01449
01450
01451
01452
01453
01454 boolean OCI_API OCI_ObjectSetInterval
01455 (
01456 OCI_Object *obj,
01457 const mtext *attr,
01458 OCI_Interval *value
01459 )
01460 {
01461 boolean res = TRUE;
01462
01463 if (value == NULL)
01464 {
01465 res = OCI_ObjectSetNull(obj, attr);
01466 }
01467 else
01468 {
01469 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_INTERVAL);
01470
01471 if (index >= 0)
01472 {
01473 #if OCI_VERSION_COMPILE >= OCI_9_0
01474
01475 OCIInd * ind = NULL;
01476 OCIInterval **data = OCI_ObjectGetAttr(obj, index, &ind);
01477
01478 OCI_CALL2
01479 (
01480 res, obj->con,
01481
01482 OCIIntervalAssign((dvoid *) OCILib.env, obj->con->err,
01483 value->handle, *data)
01484 )
01485
01486 if (res == TRUE)
01487 *ind = OCI_IND_NOTNULL;
01488
01489 #endif
01490 }
01491 }
01492
01493 OCI_RESULT(res);
01494
01495 return res;
01496 }
01497
01498
01499
01500
01501
01502 boolean OCI_API OCI_ObjectSetColl
01503 (
01504 OCI_Object *obj,
01505 const mtext *attr,
01506 OCI_Coll *value
01507 )
01508 {
01509 boolean res = TRUE;
01510
01511 if (value == NULL)
01512 {
01513 res = OCI_ObjectSetNull(obj, attr);
01514 }
01515 else
01516 {
01517 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_COLLECTION);
01518
01519 if (index >= 0)
01520 {
01521 OCIInd *ind = NULL;
01522 OCIColl **data = OCI_ObjectGetAttr(obj, index, &ind);
01523
01524 OCI_CALL2
01525 (
01526 res, obj->con,
01527
01528 OCICollAssign(OCILib.env, obj->con->err, value->handle, *data)
01529 )
01530
01531 if (res == TRUE)
01532 *ind = OCI_IND_NOTNULL;
01533 }
01534 }
01535
01536 OCI_RESULT(res);
01537
01538 return res;
01539 }
01540
01541
01542
01543
01544
01545 boolean OCI_API OCI_ObjectSetObject
01546 (
01547 OCI_Object *obj,
01548 const mtext *attr,
01549 OCI_Object *value
01550 )
01551 {
01552 boolean res = TRUE;
01553
01554 if (value == NULL)
01555 {
01556 res = OCI_ObjectSetNull(obj, attr);
01557 }
01558 else
01559 {
01560 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_OBJECT);
01561
01562 if (index >= 0)
01563 {
01564 OCIInd *ind = NULL;
01565 void *data = OCI_ObjectGetAttr(obj, index, &ind);
01566
01567 OCI_CALL2
01568 (
01569 res, obj->con,
01570
01571 OCIObjectCopy(OCILib.env, obj->con->err, obj->con->cxt,
01572 value->handle, (value->tab_ind + value->idx_ind),
01573 data, ind, obj->typinf->cols[index].typinf->tdo,
01574 OCI_DURATION_SESSION, OCI_DEFAULT)
01575 )
01576
01577 if (res == TRUE)
01578 *ind = OCI_IND_NOTNULL;
01579 }
01580 }
01581
01582 OCI_RESULT(res);
01583
01584 return res;
01585 }
01586
01587
01588
01589
01590
01591 boolean OCI_API OCI_ObjectSetLob
01592 (
01593 OCI_Object *obj,
01594 const mtext *attr,
01595 OCI_Lob *value
01596 )
01597 {
01598 boolean res = TRUE;
01599
01600 if (value == NULL)
01601 {
01602 res = OCI_ObjectSetNull(obj, attr);
01603 }
01604 else
01605 {
01606 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_LOB);
01607
01608 if (index >= 0)
01609 {
01610 OCIInd * ind = NULL;
01611 void **data = OCI_ObjectGetAttr(obj, index, &ind);
01612
01613 OCI_CALL2
01614 (
01615 res, obj->con,
01616
01617 OCILobLocatorAssign(obj->con->cxt, obj->con->err,
01618 value->handle, (OCILobLocator **) data)
01619 )
01620
01621 if (res == TRUE)
01622 *ind = OCI_IND_NOTNULL;
01623 }
01624 }
01625
01626 OCI_RESULT(res);
01627
01628 return res;
01629 }
01630
01631
01632
01633
01634
01635 boolean OCI_API OCI_ObjectSetFile
01636 (
01637 OCI_Object *obj,
01638 const mtext *attr,
01639 OCI_File *value
01640 )
01641 {
01642 boolean res = TRUE;
01643
01644 if (value == NULL)
01645 {
01646 res = OCI_ObjectSetNull(obj, attr);
01647 }
01648 else
01649 {
01650 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_FILE);
01651
01652 if (index >= 0)
01653 {
01654 OCIInd *ind = NULL;
01655 void **data = OCI_ObjectGetAttr(obj, index, &ind);
01656
01657 OCI_CALL2
01658 (
01659 res, obj->con,
01660
01661 OCILobLocatorAssign(obj->con->cxt, obj->con->err,
01662 value->handle, (OCILobLocator **) data)
01663 )
01664
01665 if (res == TRUE)
01666 *ind = OCI_IND_NOTNULL;
01667 }
01668 }
01669
01670 OCI_RESULT(res);
01671
01672 return res;
01673 }
01674
01675
01676
01677
01678
01679 boolean OCI_API OCI_ObjectSetRef
01680 (
01681 OCI_Object *obj,
01682 const mtext *attr,
01683 OCI_Ref *value
01684 )
01685 {
01686 boolean res = FALSE;
01687
01688 if (value == NULL)
01689 {
01690 res = OCI_ObjectSetNull(obj, attr);
01691 }
01692 else
01693 {
01694 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_REF);
01695
01696 if (index >= 0)
01697 {
01698 OCIInd *ind = NULL;
01699 OCIRef **data = OCI_ObjectGetAttr(obj, index, &ind);
01700
01701 OCI_CALL2
01702 (
01703 res, obj->con,
01704
01705 OCIRefAssign(OCILib.env, obj->con->err, value->handle, data)
01706 )
01707
01708 if (res == TRUE)
01709 *ind = OCI_IND_NOTNULL;
01710 }
01711 }
01712
01713 OCI_RESULT(res);
01714
01715 return res;
01716 }
01717
01718
01719
01720
01721
01722 boolean OCI_API OCI_ObjectSetNull
01723 (
01724 OCI_Object *obj,
01725 const mtext *attr
01726 )
01727 {
01728 boolean res = TRUE;
01729 int index;
01730
01731 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01732 OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);
01733
01734 index = OCI_ObjectGetAttrIndex(obj, attr, -1);
01735
01736 if (index >= 0)
01737 {
01738 int ind_index = OCI_ObjectGetIndOffset(obj->typinf, index);
01739
01740 obj->tab_ind[ind_index] = OCI_IND_NULL;
01741
01742 res = TRUE;
01743 }
01744 else
01745 res = FALSE;
01746
01747 OCI_RESULT(res);
01748
01749 return res;
01750 }
01751
01752
01753
01754
01755
01756 boolean OCI_API OCI_ObjectIsNull
01757 (
01758 OCI_Object *obj,
01759 const mtext *attr
01760 )
01761 {
01762 boolean res = TRUE;
01763 boolean ret = TRUE;
01764 int index = 0;
01765
01766 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01767 OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);
01768
01769 index = OCI_ObjectGetAttrIndex(obj, attr, -1);
01770
01771 if (index >= 0)
01772 {
01773 int ind_index = OCI_ObjectGetIndOffset(obj->typinf, index);
01774
01775 ret = (obj->tab_ind[ind_index] != OCI_IND_NOTNULL);
01776
01777 res = TRUE;
01778 }
01779 else
01780 res = FALSE;
01781
01782 OCI_RESULT(res);
01783
01784 return ret;
01785 }
01786
01787
01788
01789
01790
01791 OCI_TypeInfo * OCI_API OCI_ObjectGetTypeInfo
01792 (
01793 OCI_Object *obj
01794 )
01795 {
01796 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, NULL);
01797
01798 OCI_RESULT(TRUE);
01799
01800 return obj->typinf;
01801 }
01802
01803
01804
01805
01806
01807 unsigned int OCI_API OCI_ObjectGetType
01808 (
01809 OCI_Object *obj
01810 )
01811 {
01812 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, OCI_UNKNOWN);
01813
01814 OCI_RESULT(TRUE);
01815
01816 return (unsigned int) obj->type;
01817 }
01818
01819
01820
01821
01822
01823 boolean OCI_API OCI_ObjectGetSelfRef
01824 (
01825 OCI_Object *obj,
01826 OCI_Ref *ref
01827 )
01828 {
01829 boolean res = TRUE;
01830
01831 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01832 OCI_CHECK_PTR(OCI_IPC_REF, ref, FALSE);
01833
01834 OCI_CHECK_COMPAT(obj->con, obj->typinf->tdo == ref->typinf->tdo, FALSE);
01835
01836 OCI_CALL2
01837 (
01838 res, obj->con,
01839
01840 OCIObjectGetObjectRef(OCILib.env, obj->con->err, obj->handle, ref->handle)
01841 )
01842
01843 if (res == TRUE)
01844 {
01845 OCI_ObjectFree(ref->obj);
01846 ref->obj = NULL;
01847 }
01848
01849 OCI_RESULT(res);
01850
01851 return res;
01852 }
01853
01854
01855
01856
01857
01858 boolean OCI_API OCI_ObjectGetStruct
01859 (
01860 OCI_Object *obj,
01861 void **pp_struct,
01862 void ** pp_ind
01863 )
01864 {
01865 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01866
01867 OCI_RESULT(TRUE);
01868
01869 *pp_struct = (void *) obj->handle;
01870
01871 if (pp_ind)
01872 *pp_ind = (void *) obj->tab_ind;
01873
01874 OCI_RESULT(TRUE);
01875
01876 return TRUE;
01877 }
01878