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