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

Generated on Mon Dec 13 2010 22:32:01 for OCILIB (C Driver for Oracle) by  doxygen 1.7.2