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

Generated on Thu Jul 30 17:41:52 2009 for OCILIB (C Driver for Oracle) by  doxygen 1.5.4