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