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