OCILIB (C Driver for Oracle) 3.9.2
D:/Perso/dev/ocilib/ocilib/src/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-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.2 2011-07-13 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 }