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