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, OCI_DEF_ALIGN);
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 int ind_index = obj->idx_ind + OCI_ObjectGetIndOffset(obj->typinf, index);
00444
00445 *pind = &obj->tab_ind[ind_index];
00446 }
00447
00448 return ((char *) obj->handle + offset);
00449 }
00450
00451
00452
00453
00454
00455 boolean OCI_ObjectSetNumber
00456 (
00457 OCI_Object *obj,
00458 const mtext *attr,
00459 void *value,
00460 uword size,
00461 uword flag
00462 )
00463 {
00464 boolean res = FALSE;
00465 int index = 0;
00466
00467 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00468
00469 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_NUMERIC);
00470
00471 if (index >= 0)
00472 {
00473 OCIInd *ind = NULL;
00474 OCINumber *num = OCI_ObjectGetAttr(obj, index, &ind);
00475
00476 res = OCI_NumberSet(obj->con, num, value, size, flag);
00477
00478 if (res == TRUE)
00479 *ind = OCI_IND_NOTNULL;
00480 }
00481
00482 OCI_RESULT(res);
00483
00484 return res;
00485 }
00486
00487
00488
00489
00490
00491 boolean OCI_ObjectGetNumber
00492 (
00493 OCI_Object *obj,
00494 const mtext *attr,
00495 void *value,
00496 uword size,
00497 uword flag
00498 )
00499 {
00500 boolean res = FALSE;
00501 int index = 0;
00502
00503 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00504
00505 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_NUMERIC);
00506
00507 if (index >= 0)
00508 {
00509 OCIInd *ind = NULL;
00510 OCINumber *num = NULL;
00511
00512 num = OCI_ObjectGetAttr(obj, index, &ind);
00513
00514 if ((num != NULL) && (*ind != OCI_IND_NULL))
00515 {
00516 res = OCI_NumberGet(obj->con, num, value, size, flag);
00517 }
00518 }
00519 else
00520 {
00521 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
00522
00523 if (index >= 0)
00524 {
00525 const mtext *fmt = OCI_GetDefaultFormatNumeric(obj->con);
00526 ub4 fmt_size = (ub4) mtslen(fmt);
00527 dtext *data = (dtext *) OCI_ObjectGetString(obj, attr);
00528
00529 res = OCI_NumberGetFromStr(obj->con, value, size, flag, data,
00530 (int) dtslen(data), fmt, fmt_size);
00531 }
00532 }
00533
00534 OCI_RESULT(res);
00535
00536 return res;
00537 }
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547 OCI_Object * OCI_API OCI_ObjectCreate
00548 (
00549 OCI_Connection *con,
00550 OCI_TypeInfo *typinf
00551 )
00552 {
00553 OCI_Object *obj = NULL;
00554
00555 OCI_CHECK_INITIALIZED(NULL);
00556
00557 OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
00558 OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00559
00560 obj = OCI_ObjectInit(con, &obj, NULL, typinf, NULL, -1, TRUE);
00561
00562 OCI_RESULT(obj != NULL);
00563
00564 return obj;
00565 }
00566
00567
00568
00569
00570
00571 boolean OCI_API OCI_ObjectFree
00572 (
00573 OCI_Object *obj
00574 )
00575 {
00576 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00577
00578 OCI_CHECK_OBJECT_FETCHED(obj, FALSE);
00579
00580
00581
00582
00583 OCI_ObjectReset(obj);
00584
00585 if (obj->objs != NULL)
00586 {
00587 OCI_FREE(obj->objs);
00588 }
00589
00590 if ((obj->hstate == OCI_OBJECT_ALLOCATED ) ||
00591 (obj->hstate == OCI_OBJECT_ALLOCATED_ARRAY))
00592 {
00593 OCI_OCIObjectFree(OCILib.env, obj->con->err, obj->handle,
00594 OCI_OBJECTFREE_NONULL);
00595 }
00596
00597 OCI_FREE(obj->buf);
00598
00599 if (obj->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00600 {
00601 OCI_FREE(obj);
00602 }
00603
00604 OCI_RESULT(TRUE);
00605
00606 return TRUE;
00607 }
00608
00609
00610
00611
00612
00613 OCI_Object ** OCI_API OCI_ObjectArrayCreate
00614 (
00615 OCI_Connection *con,
00616 OCI_TypeInfo *typinf,
00617 unsigned int nbelem
00618 )
00619 {
00620 OCI_Array *arr = NULL;
00621 OCI_Object **objs = NULL;
00622
00623 arr = OCI_ArrayCreate(con, nbelem, OCI_CDT_OBJECT, 0,
00624 sizeof(void *), sizeof(OCI_Object),
00625 0, typinf);
00626
00627 if (arr != NULL)
00628 {
00629 objs = (OCI_Object **) arr->tab_obj;
00630 }
00631
00632 return objs;
00633 }
00634
00635
00636
00637
00638
00639 boolean OCI_API OCI_ObjectArrayFree
00640 (
00641 OCI_Object **objs
00642 )
00643 {
00644 return OCI_ArrayFreeFromHandles((void **) objs);
00645 }
00646
00647
00648
00649
00650
00651 boolean OCI_API OCI_ObjectAssign
00652 (
00653 OCI_Object *obj,
00654 OCI_Object *obj_src
00655 )
00656 {
00657 boolean res = TRUE;
00658
00659 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00660 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj_src, FALSE);
00661
00662 OCI_CHECK_COMPAT(obj->con, obj->typinf->tdo == obj_src->typinf->tdo, FALSE);
00663
00664 OCI_CALL2
00665 (
00666 res, obj->con,
00667
00668 OCIObjectCopy(OCILib.env, obj->con->err, obj->con->cxt,
00669 obj_src->handle, (obj_src->tab_ind + obj_src->idx_ind),
00670 obj->handle, (obj->tab_ind + obj->idx_ind),
00671 obj->typinf->tdo, OCI_DURATION_SESSION, OCI_DEFAULT)
00672 )
00673
00674 if (res == TRUE)
00675 {
00676 obj->typinf = obj_src->typinf;
00677
00678 OCI_ObjectReset(obj);
00679 }
00680
00681 OCI_RESULT(res);
00682
00683 return res;
00684 }
00685
00686
00687
00688
00689
00690 short OCI_API OCI_ObjectGetShort
00691 (
00692 OCI_Object *obj,
00693 const mtext *attr
00694 )
00695 {
00696 short value = 0;
00697
00698 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_SHORT);
00699
00700 return value;
00701 }
00702
00703
00704
00705
00706
00707 unsigned short OCI_API OCI_ObjectGetUnsignedShort
00708 (
00709 OCI_Object *obj,
00710 const mtext *attr
00711 )
00712 {
00713 unsigned short value = 0;
00714
00715 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_USHORT);
00716
00717 return value;
00718 }
00719
00720
00721
00722
00723
00724 int OCI_API OCI_ObjectGetInt
00725 (
00726 OCI_Object *obj,
00727 const mtext *attr
00728 )
00729 {
00730 int value = 0;
00731
00732 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_INT);
00733
00734 return value;
00735 }
00736
00737
00738
00739
00740
00741 unsigned int OCI_API OCI_ObjectGetUnsignedInt
00742 (
00743 OCI_Object *obj,
00744 const mtext *attr
00745 )
00746 {
00747 unsigned int value = 0;
00748
00749 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_UINT);
00750
00751 return value;
00752 }
00753
00754
00755
00756
00757
00758 big_int OCI_API OCI_ObjectGetBigInt
00759 (
00760 OCI_Object *obj,
00761 const mtext *attr
00762 )
00763 {
00764 big_int value = 0;
00765
00766 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGINT);
00767
00768 return value;
00769 }
00770
00771
00772
00773
00774
00775 big_uint OCI_API OCI_ObjectGetUnsignedBigInt
00776 (
00777 OCI_Object *obj,
00778 const mtext *attr
00779 )
00780 {
00781 big_uint value = 0;
00782
00783 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGUINT);
00784
00785 return value;
00786 }
00787
00788
00789
00790
00791
00792 double OCI_API OCI_ObjectGetDouble
00793 (
00794 OCI_Object *obj,
00795 const mtext *attr
00796 )
00797 {
00798 double value = 0.0;
00799
00800 OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_DOUBLE);
00801
00802 return value;
00803 }
00804
00805
00806
00807
00808
00809 const dtext * OCI_API OCI_ObjectGetString
00810 (
00811 OCI_Object *obj,
00812 const mtext *attr
00813 )
00814 {
00815 const dtext *str = NULL;
00816 boolean res = TRUE;
00817 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
00818
00819 if (index >= 0)
00820 {
00821 OCIInd *ind = NULL;
00822 OCIString **value = NULL;
00823
00824 value = OCI_ObjectGetAttr(obj, index, &ind);
00825
00826 if ((value != NULL) && (*ind != OCI_IND_NULL))
00827 {
00828 str = (dtext *) OCI_StringFromStringPtr(*value, &obj->buf, &obj->buflen);
00829 }
00830 }
00831
00832 OCI_RESULT(res);
00833
00834 return str;
00835 }
00836
00837
00838
00839
00840
00841 int OCI_API OCI_ObjectGetRaw
00842 (
00843 OCI_Object *obj,
00844 const mtext *attr,
00845 void *buffer,
00846 unsigned int len
00847 )
00848 {
00849 boolean res = TRUE;
00850 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_RAW);
00851 ub4 raw_len = 0;
00852
00853 if (index >= 0)
00854 {
00855 OCIInd *ind = NULL;
00856 OCIRaw **value = NULL;
00857
00858 value = OCI_ObjectGetAttr(obj, index, &ind);
00859
00860 if ((value != NULL) && (*ind != OCI_IND_NULL))
00861 {
00862 raw_len = OCIRawSize(OCILib.env, *value);
00863
00864 if (len > raw_len)
00865 len = raw_len;
00866
00867 memcpy(buffer, OCIRawPtr(OCILib.env, *value), (size_t) len);
00868 }
00869 }
00870
00871 OCI_RESULT(res);
00872
00873 return len;
00874 }
00875
00876
00877
00878
00879
00880 OCI_Date * OCI_API OCI_ObjectGetDate
00881 (
00882 OCI_Object *obj,
00883 const mtext *attr
00884 )
00885 {
00886 OCI_Date * date = NULL;
00887 boolean res = TRUE;
00888 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_DATETIME);
00889
00890 if (index >= 0)
00891 {
00892 OCIInd *ind = NULL;
00893 OCIDate *value = NULL;
00894
00895 value = OCI_ObjectGetAttr(obj, index, &ind);
00896
00897 if ((value != NULL) && (*ind != OCI_IND_NULL))
00898 {
00899 date = OCI_DateInit(obj->con, (OCI_Date **) &obj->objs[index],
00900 value, FALSE, FALSE);
00901
00902 res = (date != NULL);
00903 }
00904 }
00905
00906 OCI_RESULT(res);
00907
00908 return date;
00909 }
00910
00911
00912
00913
00914
00915 OCI_Timestamp * OCI_API OCI_ObjectGetTimestamp
00916 (
00917 OCI_Object *obj,
00918 const mtext *attr
00919 )
00920 {
00921 OCI_Timestamp *tmsp = NULL;
00922 boolean res = TRUE;
00923
00924 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TIMESTAMP);
00925
00926 if (index >= 0)
00927 {
00928 OCIInd *ind = NULL;
00929 OCIDateTime **value = NULL;
00930
00931 value = OCI_ObjectGetAttr(obj, index, &ind);
00932
00933 if ((value != NULL) && (*ind != OCI_IND_NULL))
00934 {
00935 tmsp = OCI_TimestampInit(obj->con,
00936 (OCI_Timestamp **) &obj->objs[index],
00937 (OCIDateTime *) *value,
00938 obj->typinf->cols[index].subtype);
00939
00940 res = (tmsp != NULL);
00941 }
00942 }
00943
00944 OCI_RESULT(res);
00945
00946 return tmsp;
00947 }
00948
00949
00950
00951
00952
00953 OCI_Interval * OCI_API OCI_ObjectGetInterval
00954 (
00955 OCI_Object *obj,
00956 const mtext *attr
00957 )
00958 {
00959 OCI_Interval *itv = NULL;
00960 boolean res = TRUE;
00961 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_INTERVAL);
00962
00963 if (index >= 0)
00964 {
00965 OCIInd *ind = NULL;
00966 OCIInterval **value = NULL;
00967
00968 value = OCI_ObjectGetAttr(obj, index, &ind);
00969
00970 if ((value != NULL) && (*ind != OCI_IND_NULL))
00971 {
00972 itv = OCI_IntervalInit(obj->con,
00973 (OCI_Interval **) &obj->objs[index],
00974 (OCIInterval *) *value,
00975 obj->typinf->cols[index].subtype);
00976
00977 res = (itv != NULL);
00978 }
00979 }
00980
00981 OCI_RESULT(res);
00982
00983 return itv;
00984 }
00985
00986
00987
00988
00989
00990 OCI_Coll * OCI_API OCI_ObjectGetColl
00991 (
00992 OCI_Object *obj,
00993 const mtext *attr
00994 )
00995 {
00996 OCI_Coll *coll = NULL;
00997 boolean res = TRUE;
00998 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_COLLECTION);
00999
01000 if (index >= 0)
01001 {
01002 OCIInd *ind = NULL;
01003 OCIColl **value = NULL;
01004
01005 value = OCI_ObjectGetAttr(obj, index, &ind);
01006
01007 if ((value != NULL) && (*ind != OCI_IND_NULL))
01008 {
01009 coll = OCI_CollInit(obj->con,
01010 (OCI_Coll **) &obj->objs[index],
01011 (OCIColl *) *value,
01012 obj->typinf->cols[index].typinf);
01013
01014 res = (coll != NULL);
01015 }
01016 }
01017
01018 OCI_RESULT(res);
01019
01020 return coll;
01021 }
01022
01023
01024
01025
01026
01027 OCI_Object * OCI_API OCI_ObjectGetObject
01028 (
01029 OCI_Object *obj,
01030 const mtext *attr
01031 )
01032 {
01033 OCI_Object *obj2 = NULL;
01034 boolean res = TRUE;
01035 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_OBJECT);
01036
01037 if (index >= 0)
01038 {
01039 OCIInd *ind = NULL;
01040 void *value = NULL;
01041
01042 value = OCI_ObjectGetAttr(obj, index, &ind);
01043
01044 if ((value != NULL) && (*ind != OCI_IND_NULL))
01045 {
01046 obj2 = OCI_ObjectInit(obj->con, (OCI_Object **) &obj->objs[index],
01047 value, obj->typinf->cols[index].typinf,
01048 obj, index, FALSE);
01049
01050 res = (obj2 != NULL);
01051 }
01052 }
01053
01054 OCI_RESULT(res);
01055
01056 return obj2;
01057 }
01058
01059
01060
01061
01062
01063 OCI_Lob * OCI_API OCI_ObjectGetLob
01064 (
01065 OCI_Object *obj,
01066 const mtext *attr
01067 )
01068 {
01069 OCI_Lob *lob = NULL;
01070 boolean res = TRUE;
01071 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_LOB);
01072
01073 if (index >= 0)
01074 {
01075 OCIInd *ind = NULL;
01076 OCILobLocator **value = NULL;
01077
01078 value = OCI_ObjectGetAttr(obj, index, &ind);
01079
01080 if ((value != NULL) && (*ind != OCI_IND_NULL))
01081 {
01082 lob = OCI_LobInit(obj->con, (OCI_Lob **) &obj->objs[index],
01083 *value, obj->typinf->cols[index].subtype);
01084
01085 res = (lob != NULL);
01086 }
01087 }
01088
01089 OCI_RESULT(res);
01090
01091 return lob;
01092 }
01093
01094
01095
01096
01097
01098 OCI_File * OCI_API OCI_ObjectGetFile
01099 (
01100 OCI_Object *obj,
01101 const mtext *attr
01102 )
01103 {
01104 OCI_File *file = NULL;
01105 boolean res = TRUE;
01106 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_FILE);
01107
01108 if (index >= 0)
01109 {
01110 OCIInd *ind = NULL;
01111 OCILobLocator **value = NULL;
01112
01113 value = OCI_ObjectGetAttr(obj, index, &ind);
01114
01115 if ((value != NULL) && (*ind != OCI_IND_NULL))
01116 {
01117 file = OCI_FileInit(obj->con, (OCI_File **) &obj->objs[index],
01118 *value, obj->typinf->cols[index].subtype);
01119
01120 res = (file != NULL);
01121 }
01122 }
01123
01124 OCI_RESULT(res);
01125
01126 return file;
01127 }
01128
01129
01130
01131
01132
01133 OCI_Ref * OCI_API OCI_ObjectGetRef
01134 (
01135 OCI_Object *obj,
01136 const mtext *attr
01137 )
01138 {
01139 OCI_Ref *ref = NULL;
01140 boolean res = TRUE;
01141 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_REF);
01142
01143 if (index >= 0)
01144 {
01145 OCIInd *ind = NULL;
01146 OCIRef **value = NULL;
01147
01148 value = OCI_ObjectGetAttr(obj, index, &ind);
01149
01150 if ((value != NULL) && (*ind != OCI_IND_NULL))
01151 {
01152 ref = OCI_RefInit(obj->con, NULL, (OCI_Ref **) &obj->objs[index],
01153 *value);
01154
01155 res = (ref != NULL);
01156 }
01157 }
01158
01159 OCI_RESULT(res);
01160
01161 return ref;
01162 }
01163
01164
01165
01166
01167
01168 boolean OCI_API OCI_ObjectSetShort
01169 (
01170 OCI_Object *obj,
01171 const mtext *attr,
01172 short value
01173 )
01174 {
01175 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01176 (uword) OCI_NUM_SHORT);
01177 }
01178
01179
01180
01181
01182
01183 boolean OCI_API OCI_ObjectSetUnsignedShort
01184 (
01185 OCI_Object *obj,
01186 const mtext *attr,
01187 unsigned short value
01188 )
01189 {
01190 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01191 (uword) OCI_NUM_USHORT);
01192 }
01193
01194
01195
01196
01197
01198 boolean OCI_API OCI_ObjectSetInt
01199 (
01200 OCI_Object *obj,
01201 const mtext *attr,
01202 int value
01203 )
01204 {
01205 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01206 (uword) OCI_NUM_INT);
01207 }
01208
01209
01210
01211
01212
01213 boolean OCI_API OCI_ObjectSetUnsignedInt
01214 (
01215 OCI_Object *obj,
01216 const mtext *attr,
01217 unsigned int value
01218 )
01219 {
01220 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01221 (uword) OCI_NUM_UINT);
01222 }
01223
01224
01225
01226
01227
01228 boolean OCI_API OCI_ObjectSetBigInt
01229 (
01230 OCI_Object *obj,
01231 const mtext *attr,
01232 big_int value
01233 )
01234 {
01235 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01236 (uword) OCI_NUM_BIGINT);
01237 }
01238
01239
01240
01241
01242
01243 boolean OCI_API OCI_ObjectSetUnsignedBigInt
01244 (
01245 OCI_Object *obj,
01246 const mtext *attr,
01247 big_uint value
01248 )
01249 {
01250 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01251 (uword) OCI_NUM_BIGUINT);
01252 }
01253
01254
01255
01256
01257
01258 boolean OCI_API OCI_ObjectSetDouble
01259 (
01260 OCI_Object *obj,
01261 const mtext *attr,
01262 double value
01263 )
01264 {
01265 return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01266 (uword) OCI_NUM_DOUBLE);
01267 }
01268
01269
01270
01271
01272
01273 boolean OCI_API OCI_ObjectSetString
01274 (
01275 OCI_Object *obj,
01276 const mtext *attr,
01277 const dtext *value
01278 )
01279 {
01280 boolean res = TRUE;
01281
01282 if (value == NULL)
01283 {
01284 res = OCI_ObjectSetNull(obj, attr);
01285 }
01286 else
01287 {
01288 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
01289
01290 if (index >= 0)
01291 {
01292 OCIInd *ind = NULL;
01293 OCIString **data = OCI_ObjectGetAttr(obj, index, &ind);
01294
01295 res = OCI_StringToStringPtr(data, obj->con->err, (void *) value,
01296 &obj->buf, &obj->buflen);
01297
01298 if (res == TRUE)
01299 *ind = OCI_IND_NOTNULL;
01300 }
01301 else
01302 res = FALSE;
01303 }
01304
01305 OCI_RESULT(res);
01306
01307 return res;
01308 }
01309
01310
01311
01312
01313
01314 boolean OCI_API OCI_ObjectSetRaw
01315 (
01316 OCI_Object *obj,
01317 const mtext *attr,
01318 void * value,
01319 unsigned int len
01320 )
01321 {
01322 boolean res = TRUE;
01323
01324 if (value == NULL)
01325 {
01326 res = OCI_ObjectSetNull(obj, attr);
01327 }
01328 else
01329 {
01330 int index;
01331
01332 OCI_CHECK_MIN(obj->con, NULL, len, 1, FALSE);
01333
01334 index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_RAW);
01335
01336 if (index >= 0)
01337 {
01338 OCIInd *ind = NULL;
01339 OCIRaw **data = OCI_ObjectGetAttr(obj, index, &ind);
01340
01341 OCI_CALL2
01342 (
01343 res, obj->con,
01344
01345 OCIRawAssignBytes(OCILib.env, obj->con->err, (ub1*) value,
01346 len, data)
01347 )
01348
01349 if (res == TRUE)
01350 *ind = OCI_IND_NOTNULL;
01351 }
01352 else
01353 res = FALSE;
01354 }
01355
01356 OCI_RESULT(res);
01357
01358 return res;
01359 }
01360
01361
01362
01363
01364
01365 boolean OCI_API OCI_ObjectSetDate
01366 (
01367 OCI_Object *obj,
01368 const mtext *attr,
01369 OCI_Date *value
01370 )
01371 {
01372 boolean res = TRUE;
01373
01374 if (value == NULL)
01375 {
01376 res = OCI_ObjectSetNull(obj, attr);
01377 }
01378 else
01379 {
01380 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_DATETIME);
01381
01382 if (index >= 0)
01383 {
01384 OCIInd * ind = NULL;
01385 OCIDate *data = OCI_ObjectGetAttr(obj, index, &ind);
01386
01387 OCI_CALL2
01388 (
01389 res, obj->con,
01390
01391 OCIDateAssign(obj->con->err, value->handle, data)
01392 )
01393
01394 if (res == TRUE)
01395 *ind = OCI_IND_NOTNULL;
01396 }
01397 }
01398
01399 OCI_RESULT(res);
01400
01401 return res;
01402 }
01403
01404
01405
01406
01407
01408 boolean OCI_API OCI_ObjectSetTimestamp
01409 (
01410 OCI_Object *obj,
01411 const mtext *attr,
01412 OCI_Timestamp *value
01413 )
01414 {
01415 boolean res = TRUE;
01416
01417 if (value == NULL)
01418 {
01419 res = OCI_ObjectSetNull(obj, attr);
01420 }
01421 else
01422 {
01423 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TIMESTAMP);
01424
01425 if (index >= 0)
01426 {
01427 #if OCI_VERSION_COMPILE >= OCI_9_0
01428
01429 OCIInd * ind = NULL;
01430 OCIDateTime **data = OCI_ObjectGetAttr(obj, index, &ind);
01431
01432 OCI_CALL2
01433 (
01434 res, obj->con,
01435
01436 OCIDateTimeAssign((dvoid *) OCILib.env, obj->con->err,
01437 value->handle, *data)
01438 )
01439
01440 if (res == TRUE)
01441 *ind = OCI_IND_NOTNULL;
01442
01443 #endif
01444 }
01445 }
01446
01447 OCI_RESULT(res);
01448
01449 return res;
01450 }
01451
01452
01453
01454
01455
01456 boolean OCI_API OCI_ObjectSetInterval
01457 (
01458 OCI_Object *obj,
01459 const mtext *attr,
01460 OCI_Interval *value
01461 )
01462 {
01463 boolean res = TRUE;
01464
01465 if (value == NULL)
01466 {
01467 res = OCI_ObjectSetNull(obj, attr);
01468 }
01469 else
01470 {
01471 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_INTERVAL);
01472
01473 if (index >= 0)
01474 {
01475 #if OCI_VERSION_COMPILE >= OCI_9_0
01476
01477 OCIInd * ind = NULL;
01478 OCIInterval **data = OCI_ObjectGetAttr(obj, index, &ind);
01479
01480 OCI_CALL2
01481 (
01482 res, obj->con,
01483
01484 OCIIntervalAssign((dvoid *) OCILib.env, obj->con->err,
01485 value->handle, *data)
01486 )
01487
01488 if (res == TRUE)
01489 *ind = OCI_IND_NOTNULL;
01490
01491 #endif
01492 }
01493 }
01494
01495 OCI_RESULT(res);
01496
01497 return res;
01498 }
01499
01500
01501
01502
01503
01504 boolean OCI_API OCI_ObjectSetColl
01505 (
01506 OCI_Object *obj,
01507 const mtext *attr,
01508 OCI_Coll *value
01509 )
01510 {
01511 boolean res = TRUE;
01512
01513 if (value == NULL)
01514 {
01515 res = OCI_ObjectSetNull(obj, attr);
01516 }
01517 else
01518 {
01519 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_COLLECTION);
01520
01521 if (index >= 0)
01522 {
01523 OCIInd *ind = NULL;
01524 OCIColl **data = OCI_ObjectGetAttr(obj, index, &ind);
01525
01526 OCI_CALL2
01527 (
01528 res, obj->con,
01529
01530 OCICollAssign(OCILib.env, obj->con->err, value->handle, *data)
01531 )
01532
01533 if (res == TRUE)
01534 *ind = OCI_IND_NOTNULL;
01535 }
01536 }
01537
01538 OCI_RESULT(res);
01539
01540 return res;
01541 }
01542
01543
01544
01545
01546
01547 boolean OCI_API OCI_ObjectSetObject
01548 (
01549 OCI_Object *obj,
01550 const mtext *attr,
01551 OCI_Object *value
01552 )
01553 {
01554 boolean res = TRUE;
01555
01556 if (value == NULL)
01557 {
01558 res = OCI_ObjectSetNull(obj, attr);
01559 }
01560 else
01561 {
01562 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_OBJECT);
01563
01564 if (index >= 0)
01565 {
01566 OCIInd *ind = NULL;
01567 void *data = OCI_ObjectGetAttr(obj, index, &ind);
01568
01569 OCI_CALL2
01570 (
01571 res, obj->con,
01572
01573 OCIObjectCopy(OCILib.env, obj->con->err, obj->con->cxt,
01574 value->handle, (value->tab_ind + value->idx_ind),
01575 data, ind, obj->typinf->cols[index].typinf->tdo,
01576 OCI_DURATION_SESSION, OCI_DEFAULT)
01577 )
01578
01579 if (res == TRUE)
01580 *ind = OCI_IND_NOTNULL;
01581 }
01582 }
01583
01584 OCI_RESULT(res);
01585
01586 return res;
01587 }
01588
01589
01590
01591
01592
01593 boolean OCI_API OCI_ObjectSetLob
01594 (
01595 OCI_Object *obj,
01596 const mtext *attr,
01597 OCI_Lob *value
01598 )
01599 {
01600 boolean res = TRUE;
01601
01602 if (value == NULL)
01603 {
01604 res = OCI_ObjectSetNull(obj, attr);
01605 }
01606 else
01607 {
01608 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_LOB);
01609
01610 if (index >= 0)
01611 {
01612 OCIInd * ind = NULL;
01613 void **data = OCI_ObjectGetAttr(obj, index, &ind);
01614
01615 OCI_CALL2
01616 (
01617 res, obj->con,
01618
01619 OCILobLocatorAssign(obj->con->cxt, obj->con->err,
01620 value->handle, (OCILobLocator **) data)
01621 )
01622
01623 if (res == TRUE)
01624 *ind = OCI_IND_NOTNULL;
01625 }
01626 }
01627
01628 OCI_RESULT(res);
01629
01630 return res;
01631 }
01632
01633
01634
01635
01636
01637 boolean OCI_API OCI_ObjectSetFile
01638 (
01639 OCI_Object *obj,
01640 const mtext *attr,
01641 OCI_File *value
01642 )
01643 {
01644 boolean res = TRUE;
01645
01646 if (value == NULL)
01647 {
01648 res = OCI_ObjectSetNull(obj, attr);
01649 }
01650 else
01651 {
01652 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_FILE);
01653
01654 if (index >= 0)
01655 {
01656 OCIInd *ind = NULL;
01657 void **data = OCI_ObjectGetAttr(obj, index, &ind);
01658
01659 OCI_CALL2
01660 (
01661 res, obj->con,
01662
01663 OCILobLocatorAssign(obj->con->cxt, obj->con->err,
01664 value->handle, (OCILobLocator **) data)
01665 )
01666
01667 if (res == TRUE)
01668 *ind = OCI_IND_NOTNULL;
01669 }
01670 }
01671
01672 OCI_RESULT(res);
01673
01674 return res;
01675 }
01676
01677
01678
01679
01680
01681 boolean OCI_API OCI_ObjectSetRef
01682 (
01683 OCI_Object *obj,
01684 const mtext *attr,
01685 OCI_Ref *value
01686 )
01687 {
01688 boolean res = FALSE;
01689
01690 if (value == NULL)
01691 {
01692 res = OCI_ObjectSetNull(obj, attr);
01693 }
01694 else
01695 {
01696 int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_REF);
01697
01698 if (index >= 0)
01699 {
01700 OCIInd *ind = NULL;
01701 OCIRef **data = OCI_ObjectGetAttr(obj, index, &ind);
01702
01703 OCI_CALL2
01704 (
01705 res, obj->con,
01706
01707 OCIRefAssign(OCILib.env, obj->con->err, value->handle, data)
01708 )
01709
01710 if (res == TRUE)
01711 *ind = OCI_IND_NOTNULL;
01712 }
01713 }
01714
01715 OCI_RESULT(res);
01716
01717 return res;
01718 }
01719
01720
01721
01722
01723
01724 boolean OCI_API OCI_ObjectSetNull
01725 (
01726 OCI_Object *obj,
01727 const mtext *attr
01728 )
01729 {
01730 boolean res = TRUE;
01731 int index;
01732
01733 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01734 OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);
01735
01736 index = OCI_ObjectGetAttrIndex(obj, attr, -1);
01737
01738 if (index >= 0)
01739 {
01740 int ind_index = obj->idx_ind + OCI_ObjectGetIndOffset(obj->typinf, index);
01741
01742 obj->tab_ind[ind_index] = OCI_IND_NULL;
01743
01744 res = TRUE;
01745 }
01746 else
01747 res = FALSE;
01748
01749 OCI_RESULT(res);
01750
01751 return res;
01752 }
01753
01754
01755
01756
01757
01758 boolean OCI_API OCI_ObjectIsNull
01759 (
01760 OCI_Object *obj,
01761 const mtext *attr
01762 )
01763 {
01764 boolean res = TRUE;
01765 boolean ret = TRUE;
01766 int index = 0;
01767
01768 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01769 OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);
01770
01771 index = OCI_ObjectGetAttrIndex(obj, attr, -1);
01772
01773 if (index >= 0)
01774 {
01775 int ind_index = obj->idx_ind + OCI_ObjectGetIndOffset(obj->typinf, index);
01776
01777 ret = (obj->tab_ind[ind_index] != OCI_IND_NOTNULL);
01778
01779 res = TRUE;
01780 }
01781 else
01782 res = FALSE;
01783
01784 OCI_RESULT(res);
01785
01786 return ret;
01787 }
01788
01789
01790
01791
01792
01793 OCI_TypeInfo * OCI_API OCI_ObjectGetTypeInfo
01794 (
01795 OCI_Object *obj
01796 )
01797 {
01798 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, NULL);
01799
01800 OCI_RESULT(TRUE);
01801
01802 return obj->typinf;
01803 }
01804
01805
01806
01807
01808
01809 unsigned int OCI_API OCI_ObjectGetType
01810 (
01811 OCI_Object *obj
01812 )
01813 {
01814 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, OCI_UNKNOWN);
01815
01816 OCI_RESULT(TRUE);
01817
01818 return (unsigned int) obj->type;
01819 }
01820
01821
01822
01823
01824
01825 boolean OCI_API OCI_ObjectGetSelfRef
01826 (
01827 OCI_Object *obj,
01828 OCI_Ref *ref
01829 )
01830 {
01831 boolean res = TRUE;
01832
01833 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01834 OCI_CHECK_PTR(OCI_IPC_REF, ref, FALSE);
01835
01836 OCI_CHECK_COMPAT(obj->con, obj->typinf->tdo == ref->typinf->tdo, FALSE);
01837
01838 OCI_CALL2
01839 (
01840 res, obj->con,
01841
01842 OCIObjectGetObjectRef(OCILib.env, obj->con->err, obj->handle, ref->handle)
01843 )
01844
01845 if (res == TRUE)
01846 {
01847 OCI_ObjectFree(ref->obj);
01848 ref->obj = NULL;
01849 }
01850
01851 OCI_RESULT(res);
01852
01853 return res;
01854 }
01855
01856
01857
01858
01859
01860 boolean OCI_API OCI_ObjectGetStruct
01861 (
01862 OCI_Object *obj,
01863 void **pp_struct,
01864 void ** pp_ind
01865 )
01866 {
01867 OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01868
01869 OCI_RESULT(TRUE);
01870
01871 *pp_struct = (void *) obj->handle;
01872
01873 if (pp_ind)
01874 *pp_ind = (void *) obj->tab_ind;
01875
01876 OCI_RESULT(TRUE);
01877
01878 return TRUE;
01879 }
01880