OCILIB (C Driver for Oracle) 3.12.1
element.c
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 }