• Main Page
  • Modules
  • Data Structures
  • Files
  • File List

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

Generated on Sun Oct 24 2010 22:02:54 for OCILIB (C Driver for Oracle) by  doxygen 1.7.1