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

D:/Perso/dev/ocilib/ocilib/src/object.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: object.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_ObjectGetIndicatorOffset
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 ub2 OCI_ObjectGetIndOffset
00046 (
00047     OCI_TypeInfo *typinf,
00048     int           index
00049 )
00050 {
00051     ub2 i = 0, j = 1;
00052 
00053     for (i = 0; i < index; i++)
00054     {
00055         if (typinf->cols[i].type == OCI_CDT_OBJECT)
00056         {
00057             j += OCI_ObjectGetIndOffset(typinf->cols[i].typinf,
00058                                         typinf->cols[i].typinf->nb_cols);
00059         }
00060         else
00061         {
00062             j++;
00063         }
00064 
00065     }
00066 
00067     return j;
00068 }
00069 
00070 /* --------------------------------------------------------------------------------------------- *
00071  * OCI_ObjectGetStructSize
00072  * --------------------------------------------------------------------------------------------- */
00073 
00074 size_t OCI_ObjectGetStructSize
00075 (
00076     OCI_TypeInfo *typinf
00077 )
00078 {
00079     size_t size1 = 0;
00080     size_t size2 = 0;
00081 
00082     int type1 = 0;
00083     int type2 = 0;
00084 
00085     ub2 i;
00086 
00087     boolean align = FALSE;
00088 
00089     size_t size = 0;
00090 
00091     if (typinf->struct_size != 0)
00092     {
00093         size = typinf->struct_size;
00094     }
00095     else
00096     {
00097         for (i = 0; i < typinf->nb_cols; i++)
00098         {
00099             align = FALSE;
00100 
00101             if (i > 0)
00102             {
00103                 size1 = size2;
00104                 type1 = type2;
00105 
00106                 typinf->offsets[i] = (int) size;
00107             }
00108             else
00109             {
00110                 OCI_ObjectGetAttrInfo(typinf, i, &size1, &type1);
00111 
00112                 typinf->offsets[i] = 0;
00113             }
00114 
00115             OCI_ObjectGetAttrInfo(typinf, i+1, &size2, &type2);
00116 
00117             switch (OCI_OFFSET_PAIR(type1, type2))
00118             {
00119             case OCI_OFFSET_PAIR(OCI_OFT_NUMBER, OCI_OFT_POINTER):
00120             case OCI_OFFSET_PAIR(OCI_OFT_DATE, OCI_OFT_POINTER):
00121             case OCI_OFFSET_PAIR(OCI_OFT_OBJECT, OCI_OFT_POINTER):
00122 
00123                 align = TRUE;
00124                 break;
00125             }
00126 
00127             size += size1;
00128 
00129             if (align)
00130             {
00131                 size = ROUNDUP(size);
00132             }
00133         }
00134 
00135         typinf->struct_size = size + size2;
00136     }
00137 
00138     return size;
00139 }
00140 
00141 /* --------------------------------------------------------------------------------------------- *
00142  * OCI_ObjectGetAttrSize
00143  * --------------------------------------------------------------------------------------------- */
00144 
00145 boolean OCI_ObjectGetAttrInfo
00146 (
00147     OCI_TypeInfo *typinf,
00148     int           index,
00149     size_t       *p_size,
00150     int          *p_type
00151 )
00152 {
00153     if (index >= typinf->nb_cols)
00154     {
00155         *p_size = 0;
00156         *p_type = 0;
00157 
00158         return FALSE;
00159     }
00160 
00161     switch (typinf->cols[index].type)
00162     {
00163     case OCI_CDT_NUMERIC:
00164 
00165         *p_size = sizeof(OCINumber);
00166         *p_type = OCI_OFT_NUMBER;
00167         break;
00168 
00169     case OCI_CDT_DATETIME:
00170 
00171         *p_size = sizeof(OCIDate);
00172         *p_type = OCI_OFT_DATE;
00173         break;
00174 
00175     case OCI_CDT_OBJECT:
00176 
00177         *p_size = OCI_ObjectGetStructSize(typinf->cols[index].typinf);
00178         *p_type = OCI_OFT_OBJECT;
00179         break;
00180 
00181     default:
00182 
00183         *p_size = sizeof(void *);
00184         *p_type = OCI_OFT_POINTER;
00185     }
00186 
00187     return TRUE;
00188 }
00189 
00190 /* --------------------------------------------------------------------------------------------- *
00191  * OCI_ObjectInit
00192  * --------------------------------------------------------------------------------------------- */
00193 
00194 OCI_Object * OCI_ObjectInit
00195 (
00196     OCI_Connection *con,
00197     OCI_Object    **pobj,
00198     void           *handle,
00199     OCI_TypeInfo   *typinf,
00200     OCI_Object     *parent,
00201     int             index,
00202     boolean         reset
00203 )
00204 {
00205     OCI_Object * obj = NULL;
00206     boolean res      = TRUE;
00207 
00208     OCI_CHECK(pobj == NULL, NULL);
00209 
00210     if (*pobj == NULL)
00211         *pobj = (OCI_Object *) OCI_MemAlloc(OCI_IPC_OBJECT, sizeof(*obj),
00212                                             (size_t) 1, TRUE);
00213 
00214     if (*pobj != NULL)
00215     {
00216         obj = *pobj;
00217 
00218         obj->con    = con;
00219         obj->handle = handle;
00220         obj->typinf = typinf;
00221 
00222         if (obj->objs == NULL)
00223         {
00224             obj->objs = (void **) OCI_MemAlloc(OCI_IPC_BUFF_ARRAY,
00225                                                sizeof(void *),
00226                                                (size_t) typinf->nb_cols,
00227                                                TRUE);
00228         }
00229         else
00230         {
00231             OCI_ObjectReset(obj);
00232         }
00233 
00234         res = (obj->objs != NULL);
00235 
00236         if (((res == TRUE)) &&
00237             ((obj->handle == NULL) || (obj->hstate == OCI_OBJECT_ALLOCATED_ARRAY)))
00238         {
00239             /* allocates handle for non fetched object */
00240 
00241             if (obj->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00242             {
00243                 obj->hstate = OCI_OBJECT_ALLOCATED;
00244             }
00245 
00246             OCI_CALL2
00247             (
00248                 res, obj->con,
00249 
00250                 OCI_ObjectNew(OCILib.env,  con->err, con->cxt,
00251                               (OCITypeCode) SQLT_NTY, obj->typinf->tdo,
00252                               (dvoid *) NULL,
00253                               (OCIDuration) OCI_DURATION_SESSION,
00254                               (boolean) TRUE,
00255                               (dvoid **) &obj->handle)
00256             )
00257         }
00258         else
00259         {
00260             obj->hstate = OCI_OBJECT_FETCHED_CLEAN;
00261         }
00262 
00263         if ((res == TRUE) && (obj->type == 0))
00264         {
00265             ub4 size = sizeof(obj->type);
00266 
00267             /* calling OCIObjectGetProperty() on objects that are attributes of
00268                parent objects leads to a segfault on MS Windows !
00269                We need to report that to Oracle! Because sub objects always are
00270                values, if the parent indicator array is not null, let's assign
00271                the object type properties ourselves */
00272 
00273             if (parent == NULL)
00274             {
00275                 OCIObjectGetProperty(OCILib.env, con->err, obj->handle,
00276                                      (OCIObjectPropId) OCI_OBJECTPROP_LIFETIME,
00277                                      (void *) &obj->type, &size);
00278             }
00279             else
00280             {
00281                 obj->type = OCI_OBJECT_VALUE;
00282             }
00283         }
00284 
00285         if ((res == TRUE) && ((reset == TRUE) || (obj->tab_ind == NULL)))
00286         {
00287             if (parent == NULL)
00288             {
00289                 OCI_CALL2
00290                 (
00291                     res, obj->con,
00292 
00293                     OCIObjectGetInd(OCILib.env, obj->con->err,
00294                                     (dvoid *) obj->handle,
00295                                     (dvoid **) &obj->tab_ind)
00296                 )
00297             }
00298             else
00299             {
00300                 obj->tab_ind = parent->tab_ind;
00301                 obj->idx_ind = parent->idx_ind + OCI_ObjectGetIndOffset(parent->typinf, index);
00302             }
00303         }
00304     }
00305     else
00306         res = FALSE;
00307 
00308     /* check for failure */
00309 
00310     if (res == FALSE)
00311     {
00312         OCI_ObjectFree(obj);
00313         obj = NULL;
00314     }
00315 
00316     return obj;
00317 }
00318 
00319 /* --------------------------------------------------------------------------------------------- *
00320  * OCI_ObjectReset
00321  * --------------------------------------------------------------------------------------------- */
00322 
00323 void OCI_ObjectReset
00324 (
00325     OCI_Object *obj
00326 )
00327 {
00328     ub2 i;
00329 
00330     for (i = 0; i < obj->typinf->nb_cols; i++)
00331     {
00332         if (obj->objs[i] != NULL)
00333         {
00334             OCI_Datatype * data = (OCI_Datatype *) obj->objs[i];
00335 
00336             if (data->hstate == OCI_OBJECT_FETCHED_CLEAN)
00337                 data->hstate =  OCI_OBJECT_FETCHED_DIRTY;
00338 
00339             switch (obj->typinf->cols[i].type)
00340             {
00341             case OCI_CDT_DATETIME:
00342 
00343                 OCI_DateFree((OCI_Date *) obj->objs[i]);
00344                 break;
00345 
00346             case OCI_CDT_LOB:
00347 
00348                 OCI_LobFree((OCI_Lob *) obj->objs[i]);
00349                 break;
00350 
00351             case OCI_CDT_FILE:
00352 
00353                 OCI_FileFree((OCI_File *) obj->objs[i]);
00354                 break;
00355 
00356             case OCI_CDT_OBJECT:
00357 
00358                 OCI_ObjectFree((OCI_Object *) obj->objs[i]);
00359                 break;
00360 
00361             case OCI_CDT_COLLECTION:
00362 
00363                 OCI_CollFree((OCI_Coll *) obj->objs[i]);;
00364                 break;
00365 
00366             case OCI_CDT_TIMESTAMP:
00367 
00368                 OCI_TimestampFree((OCI_Timestamp *) obj->objs[i]);
00369                 break;
00370 
00371             case OCI_CDT_INTERVAL:
00372 
00373                 OCI_IntervalFree((OCI_Interval *) obj->objs[i]);
00374                 break;
00375             case OCI_CDT_REF:
00376 
00377                 OCI_RefFree((OCI_Ref *) obj->objs[i]);
00378                 break;
00379             }
00380 
00381             obj->objs[i] = NULL;
00382         }
00383     }
00384 }
00385 
00386 /* --------------------------------------------------------------------------------------------- *
00387  * OCI_ObjectGetAttrIndex
00388  * --------------------------------------------------------------------------------------------- */
00389 
00390 int OCI_ObjectGetAttrIndex
00391 (
00392     OCI_Object  *obj,
00393     const mtext *attr,
00394     int          type
00395 )
00396 {
00397     int res = -1;
00398     ub2 i;
00399 
00400     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, -1);
00401     OCI_CHECK_PTR(OCI_IPC_STRING, attr, -1);
00402 
00403     for (i = 0; i < obj->typinf->nb_cols; i++)
00404     {
00405         OCI_Column *col = &obj->typinf->cols[i];
00406 
00407         if (((type == -1) || (col->type == type))  &&
00408             (mtscasecmp(col->name, attr) == 0))
00409         {
00410             res = (int) i;
00411             break;
00412         }
00413     }
00414 
00415     if (res == -1)
00416         OCI_ExceptionAttributeNotFound(obj->con, attr);
00417 
00418     return res;
00419 }
00420 
00421 /* --------------------------------------------------------------------------------------------- *
00422  * OCI_ObjectGetAttr
00423  * --------------------------------------------------------------------------------------------- */
00424 
00425 void * OCI_ObjectGetAttr
00426 (
00427     OCI_Object  *obj,
00428     unsigned int index,
00429     OCIInd     **pind
00430 )
00431 {
00432     size_t offset = 0;
00433 
00434     if (obj->typinf->struct_size == 0)
00435     {
00436         OCI_ObjectGetStructSize(obj->typinf);
00437     }
00438 
00439     offset = (size_t) obj->typinf->offsets[index];
00440 
00441     if (pind != NULL)
00442     {
00443         *pind = &obj->tab_ind[OCI_ObjectGetIndOffset(obj->typinf, index)];
00444     }
00445 
00446     return ((char *) obj->handle + offset);
00447 }
00448 
00449 /* --------------------------------------------------------------------------------------------- *
00450  * OCI_ObjectSetNumber
00451  * --------------------------------------------------------------------------------------------- */
00452 
00453 boolean OCI_ObjectSetNumber
00454 (
00455     OCI_Object  *obj,
00456     const mtext *attr,
00457     void        *value,
00458     uword        size,
00459     uword        flag
00460 )
00461 {
00462     boolean res = FALSE;
00463     int index   = 0;
00464 
00465     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00466 
00467     index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_NUMERIC);
00468 
00469     if (index >= 0)
00470     {
00471         OCIInd *ind    = NULL;
00472         OCINumber *num = OCI_ObjectGetAttr(obj, index, &ind);
00473 
00474         res = OCI_NumberSet(obj->con, num, value, size, flag);
00475 
00476         if (res == TRUE)
00477             *ind = OCI_IND_NOTNULL;
00478     }
00479 
00480     OCI_RESULT(res);
00481 
00482     return res;
00483 }
00484 
00485 /* --------------------------------------------------------------------------------------------- *
00486  * OCI_ObjectGetNumber
00487  * --------------------------------------------------------------------------------------------- */
00488 
00489 boolean OCI_ObjectGetNumber
00490 (
00491     OCI_Object  *obj,
00492     const mtext *attr,
00493     void        *value,
00494     uword        size,
00495     uword        flag
00496 )
00497 {
00498     boolean res = FALSE;
00499     int index   = 0;
00500 
00501     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00502 
00503     index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_NUMERIC);
00504 
00505     if (index >= 0)
00506     {
00507         OCIInd *ind    = NULL;
00508         OCINumber *num = NULL;
00509 
00510         num = OCI_ObjectGetAttr(obj, index, &ind);
00511 
00512         if ((num != NULL) && (*ind != OCI_IND_NULL))
00513         {
00514             res = OCI_NumberGet(obj->con, num, value, size, flag);
00515         }
00516     }
00517     else
00518     {
00519         index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
00520 
00521         if (index >= 0)
00522         {
00523             const mtext *fmt = OCI_GetDefaultFormatNumeric(obj->con);
00524             ub4 fmt_size     = (ub4) mtslen(fmt);
00525             dtext *data      = (dtext *) OCI_ObjectGetString(obj, attr);
00526 
00527             res = OCI_NumberGetFromStr(obj->con, value, size, flag, data,
00528                                        (int) dtslen(data),  fmt, fmt_size);
00529         }
00530     }
00531 
00532     OCI_RESULT(res);
00533 
00534     return res;
00535 }
00536 
00537 /* ********************************************************************************************* *
00538  *                            PUBLIC FUNCTIONS
00539  * ********************************************************************************************* */
00540 
00541 /* --------------------------------------------------------------------------------------------- *
00542  * OCI_ObjectCreate
00543  * --------------------------------------------------------------------------------------------- */
00544 
00545 OCI_Object * OCI_API OCI_ObjectCreate
00546 (
00547     OCI_Connection *con,
00548     OCI_TypeInfo   *typinf
00549 )
00550 {
00551     OCI_Object *obj = NULL;
00552 
00553     OCI_CHECK_INITIALIZED(NULL);
00554 
00555     OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
00556     OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00557 
00558     obj = OCI_ObjectInit(con, &obj, NULL, typinf, NULL, -1, TRUE);
00559 
00560     OCI_RESULT(obj != NULL);
00561 
00562     return obj;
00563 }
00564 
00565 /* --------------------------------------------------------------------------------------------- *
00566  * OCI_ObjectFree
00567  * --------------------------------------------------------------------------------------------- */
00568 
00569 boolean OCI_API OCI_ObjectFree
00570 (
00571     OCI_Object *obj
00572 )
00573 {
00574     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
00575 
00576     OCI_CHECK_OBJECT_FETCHED(obj, FALSE);
00577 
00578     /* if the object has sub-objects that have been fetched, we need to free
00579        these objects */
00580 
00581     OCI_ObjectReset(obj);
00582 
00583     if (obj->objs != NULL)
00584     {
00585         OCI_FREE(obj->objs);
00586     }
00587 
00588     if ((obj->hstate == OCI_OBJECT_ALLOCATED      ) ||
00589         (obj->hstate == OCI_OBJECT_ALLOCATED_ARRAY))
00590     {
00591         OCI_OCIObjectFree(OCILib.env, obj->con->err,  obj->handle,
00592                           OCI_OBJECTFREE_NONULL);
00593     }
00594 
00595     OCI_FREE(obj->buf);
00596 
00597     if (obj->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00598     {
00599         OCI_FREE(obj);
00600     }
00601 
00602     OCI_RESULT(TRUE);
00603 
00604     return TRUE;
00605 }
00606 
00607 /* --------------------------------------------------------------------------------------------- *
00608  * OCI_ObjectArrayCreate
00609  * --------------------------------------------------------------------------------------------- */
00610 
00611 OCI_Object ** OCI_API OCI_ObjectArrayCreate
00612 (
00613     OCI_Connection *con,
00614     OCI_TypeInfo   *typinf,
00615     unsigned int    nbelem
00616 )
00617 {
00618     OCI_Array *arr    = NULL;
00619     OCI_Object **objs = NULL;
00620 
00621     arr = OCI_ArrayCreate(con, nbelem, OCI_CDT_OBJECT, 0,
00622                           sizeof(void *), sizeof(OCI_Object),
00623                           0, typinf);
00624 
00625     if (arr != NULL)
00626     {
00627         objs = (OCI_Object **) arr->tab_obj;
00628     }
00629 
00630     return objs;
00631 }
00632 
00633 /* --------------------------------------------------------------------------------------------- *
00634  * OCI_ObjectArrayFree
00635  * --------------------------------------------------------------------------------------------- */
00636 
00637 boolean OCI_API OCI_ObjectArrayFree
00638 (
00639     OCI_Object **objs
00640 )
00641 {
00642     return OCI_ArrayFreeFromHandles((void **) objs);
00643 }
00644 
00645 /* --------------------------------------------------------------------------------------------- *
00646  * OCI_ObjectAssign
00647  * --------------------------------------------------------------------------------------------- */
00648 
00649 boolean OCI_API OCI_ObjectAssign
00650 (
00651     OCI_Object *obj,
00652     OCI_Object *obj_src
00653 )
00654 {
00655     boolean res = TRUE;
00656 
00657     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj,     FALSE);
00658     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj_src, FALSE);
00659 
00660     OCI_CHECK_COMPAT(obj->con, obj->typinf->tdo == obj_src->typinf->tdo, FALSE);
00661 
00662     OCI_CALL2
00663     (
00664         res, obj->con,
00665 
00666         OCIObjectCopy(OCILib.env, obj->con->err, obj->con->cxt,
00667                       obj_src->handle, (obj_src->tab_ind + obj_src->idx_ind),
00668                       obj->handle, (obj->tab_ind + obj->idx_ind),
00669                       obj->typinf->tdo, OCI_DURATION_SESSION, OCI_DEFAULT)
00670     )
00671 
00672     if (res == TRUE)
00673     {
00674         obj->typinf = obj_src->typinf;
00675 
00676         OCI_ObjectReset(obj);
00677     }
00678 
00679     OCI_RESULT(res);
00680 
00681     return res;
00682 }
00683 
00684 /* --------------------------------------------------------------------------------------------- *
00685  * OCI_ObjectGetInt
00686  * --------------------------------------------------------------------------------------------- */
00687 
00688 short OCI_API OCI_ObjectGetShort
00689 (
00690     OCI_Object  *obj,
00691     const mtext *attr
00692 )
00693 {
00694     short value = 0;
00695 
00696     OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_SHORT);
00697 
00698     return value;
00699 }
00700 
00701 /* --------------------------------------------------------------------------------------------- *
00702  * OCI_ObjectGetUnsignedInt
00703  * --------------------------------------------------------------------------------------------- */
00704 
00705 unsigned short OCI_API OCI_ObjectGetUnsignedShort
00706 (
00707     OCI_Object  *obj,
00708     const mtext *attr
00709 )
00710 {
00711     unsigned short value = 0;
00712 
00713     OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_USHORT);
00714 
00715     return value;
00716 }
00717 
00718 /* --------------------------------------------------------------------------------------------- *
00719  * OCI_ObjectGetInt
00720  * --------------------------------------------------------------------------------------------- */
00721 
00722 int OCI_API OCI_ObjectGetInt
00723 (
00724     OCI_Object  *obj,
00725     const mtext *attr
00726 )
00727 {
00728     int value = 0;
00729 
00730     OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_INT);
00731 
00732     return value;
00733 }
00734 
00735 /* --------------------------------------------------------------------------------------------- *
00736  * OCI_ObjectGetUnsignedInt
00737  * --------------------------------------------------------------------------------------------- */
00738 
00739 unsigned int OCI_API OCI_ObjectGetUnsignedInt
00740 (
00741     OCI_Object  *obj,
00742     const mtext *attr
00743 )
00744 {
00745     unsigned int value = 0;
00746 
00747     OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_UINT);
00748 
00749     return value;
00750 }
00751 
00752 /* --------------------------------------------------------------------------------------------- *
00753  * OCI_ObjectGetBigInt
00754  * --------------------------------------------------------------------------------------------- */
00755 
00756 big_int OCI_API OCI_ObjectGetBigInt
00757 (
00758     OCI_Object  *obj,
00759     const mtext *attr
00760 )
00761 {
00762     big_int value = 0;
00763 
00764     OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGINT);
00765 
00766     return value;
00767 }
00768 
00769 /* --------------------------------------------------------------------------------------------- *
00770  * OCI_ObjectGetUnsignedBigInt
00771  * --------------------------------------------------------------------------------------------- */
00772 
00773 big_uint OCI_API OCI_ObjectGetUnsignedBigInt
00774 (
00775     OCI_Object  *obj,
00776     const mtext *attr
00777 )
00778 {
00779     big_uint value = 0;
00780 
00781     OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_BIGUINT);
00782 
00783     return value;
00784 }
00785 
00786 /* --------------------------------------------------------------------------------------------- *
00787  * OCI_ObjectGetDouble
00788  * --------------------------------------------------------------------------------------------- */
00789 
00790 double OCI_API OCI_ObjectGetDouble
00791 (
00792     OCI_Object  *obj,
00793     const mtext *attr
00794 )
00795 {
00796     double value = 0.0;
00797 
00798     OCI_ObjectGetNumber(obj, attr, &value, sizeof(value), OCI_NUM_DOUBLE);
00799 
00800     return value;
00801 }
00802 
00803 /* --------------------------------------------------------------------------------------------- *
00804  * OCI_ObjectGetString
00805  * --------------------------------------------------------------------------------------------- */
00806 
00807 const dtext * OCI_API OCI_ObjectGetString
00808 (
00809     OCI_Object  *obj,
00810     const mtext *attr
00811 )
00812 {
00813     const dtext *str = NULL;
00814     boolean res      = TRUE;
00815     int index        = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
00816 
00817     if (index >= 0)
00818     {
00819         OCIInd *ind       = NULL;
00820         OCIString **value = NULL;
00821 
00822         value = OCI_ObjectGetAttr(obj, index, &ind);
00823 
00824         if ((value != NULL) && (*ind != OCI_IND_NULL))
00825         {
00826             str = (dtext *) OCI_StringFromStringPtr(*value, &obj->buf, &obj->buflen);
00827         }
00828     }
00829 
00830     OCI_RESULT(res);
00831 
00832     return str;
00833 }
00834 
00835 /* --------------------------------------------------------------------------------------------- *
00836  * OCI_ObjectGetRaw
00837  * --------------------------------------------------------------------------------------------- */
00838 
00839 int OCI_API OCI_ObjectGetRaw
00840 (
00841     OCI_Object  *obj,
00842     const mtext *attr,
00843     void        *buffer,
00844     unsigned int len
00845 )
00846 {
00847     boolean res = TRUE;
00848     int index   = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_RAW);
00849     ub4 raw_len = 0;
00850 
00851     if (index >= 0)
00852     {
00853         OCIInd *ind    = NULL;
00854         OCIRaw **value = NULL;
00855 
00856         value = OCI_ObjectGetAttr(obj, index, &ind);
00857 
00858         if ((value != NULL) && (*ind != OCI_IND_NULL))
00859         {
00860             raw_len = OCIRawSize(OCILib.env, *value);
00861 
00862             if (len > raw_len)
00863                 len = raw_len;
00864 
00865             memcpy(buffer, OCIRawPtr(OCILib.env, *value), (size_t) len);
00866         }
00867     }
00868 
00869     OCI_RESULT(res);
00870 
00871     return len;
00872 }
00873 
00874 /* --------------------------------------------------------------------------------------------- *
00875  * OCI_ObjectGetDate
00876  * --------------------------------------------------------------------------------------------- */
00877 
00878 OCI_Date * OCI_API OCI_ObjectGetDate
00879 (
00880     OCI_Object  *obj,
00881     const mtext *attr
00882 )
00883 {
00884     OCI_Date * date = NULL;
00885     boolean res     = TRUE;
00886     int index       = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_DATETIME);
00887 
00888     if (index >= 0)
00889     {
00890         OCIInd *ind    = NULL;
00891         OCIDate *value = NULL;
00892 
00893         value = OCI_ObjectGetAttr(obj, index, &ind);
00894 
00895         if ((value != NULL) && (*ind != OCI_IND_NULL))
00896         {
00897             date = OCI_DateInit(obj->con, (OCI_Date **) &obj->objs[index],
00898                                 value, FALSE, FALSE);
00899 
00900             res = (date != NULL);
00901         }
00902     }
00903 
00904     OCI_RESULT(res);
00905 
00906     return date;
00907 }
00908 
00909 /* --------------------------------------------------------------------------------------------- *
00910  * OCI_ObjectGetTimestamp
00911  * --------------------------------------------------------------------------------------------- */
00912 
00913 OCI_Timestamp * OCI_API OCI_ObjectGetTimestamp
00914 (
00915     OCI_Object  *obj,
00916     const mtext *attr
00917 )
00918 {
00919     OCI_Timestamp *tmsp = NULL;
00920     boolean res         = TRUE;
00921 
00922     int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TIMESTAMP);
00923 
00924     if (index >= 0)
00925     {
00926         OCIInd *ind         = NULL;
00927         OCIDateTime **value = NULL;
00928 
00929         value = OCI_ObjectGetAttr(obj, index, &ind);
00930 
00931         if ((value != NULL) && (*ind != OCI_IND_NULL))
00932         {
00933             tmsp = OCI_TimestampInit(obj->con,
00934                                      (OCI_Timestamp **) &obj->objs[index],
00935                                      (OCIDateTime *) *value,
00936                                      obj->typinf->cols[index].subtype);
00937 
00938             res = (tmsp != NULL);
00939         }
00940     }
00941 
00942     OCI_RESULT(res);
00943 
00944     return tmsp;
00945 }
00946 
00947 /* --------------------------------------------------------------------------------------------- *
00948  * OCI_ObjectGetInterval
00949  * --------------------------------------------------------------------------------------------- */
00950 
00951 OCI_Interval * OCI_API OCI_ObjectGetInterval
00952 (
00953     OCI_Object  *obj,
00954     const mtext *attr
00955 )
00956 {
00957     OCI_Interval *itv = NULL;
00958     boolean res       = TRUE;
00959     int index         = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_INTERVAL);
00960 
00961     if (index >= 0)
00962     {
00963         OCIInd *ind         = NULL;
00964         OCIInterval **value = NULL;
00965 
00966         value = OCI_ObjectGetAttr(obj, index, &ind);
00967 
00968         if ((value != NULL) && (*ind != OCI_IND_NULL))
00969         {
00970             itv = OCI_IntervalInit(obj->con,
00971                                    (OCI_Interval **) &obj->objs[index],
00972                                    (OCIInterval *) *value,
00973                                    obj->typinf->cols[index].subtype);
00974 
00975             res = (itv != NULL);
00976         }
00977     }
00978 
00979     OCI_RESULT(res);
00980 
00981     return itv;
00982 }
00983 
00984 /* --------------------------------------------------------------------------------------------- *
00985  * OCI_ObjectGetColl
00986  * --------------------------------------------------------------------------------------------- */
00987 
00988 OCI_Coll * OCI_API OCI_ObjectGetColl
00989 (
00990     OCI_Object  *obj,
00991     const mtext *attr
00992 )
00993 {
00994     OCI_Coll *coll = NULL;
00995     boolean res    = TRUE;
00996     int index      = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_COLLECTION);
00997 
00998     if (index >= 0)
00999     {
01000         OCIInd *ind     = NULL;
01001         OCIColl **value = NULL;
01002 
01003         value = OCI_ObjectGetAttr(obj, index, &ind);
01004 
01005         if ((value != NULL) && (*ind != OCI_IND_NULL))
01006         {
01007             coll = OCI_CollInit(obj->con,
01008                                 (OCI_Coll **) &obj->objs[index],
01009                                 (OCIColl *) *value,
01010                                 obj->typinf->cols[index].typinf);
01011 
01012             res = (coll != NULL);
01013         }
01014     }
01015 
01016     OCI_RESULT(res);
01017 
01018     return coll;
01019 }
01020 
01021 /* --------------------------------------------------------------------------------------------- *
01022  * OCI_ObjectGetObject
01023  * --------------------------------------------------------------------------------------------- */
01024 
01025 OCI_Object * OCI_API OCI_ObjectGetObject
01026 (
01027     OCI_Object  *obj,
01028     const mtext *attr
01029 )
01030 {
01031     OCI_Object *obj2 = NULL;
01032     boolean res      = TRUE;
01033     int index        = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_OBJECT);
01034 
01035     if (index >= 0)
01036     {
01037         OCIInd *ind = NULL;
01038         void *value = NULL;
01039 
01040         value = OCI_ObjectGetAttr(obj, index, &ind);
01041 
01042         if ((value != NULL) && (*ind != OCI_IND_NULL))
01043         {
01044             obj2 = OCI_ObjectInit(obj->con, (OCI_Object **) &obj->objs[index],
01045                                   value, obj->typinf->cols[index].typinf,
01046                                   obj, index, FALSE);
01047 
01048             res = (obj2 != NULL);
01049         }
01050     }
01051 
01052     OCI_RESULT(res);
01053 
01054     return obj2;
01055 }
01056 
01057 /* --------------------------------------------------------------------------------------------- *
01058  * OCI_ObjectGetLob
01059  * --------------------------------------------------------------------------------------------- */
01060 
01061 OCI_Lob * OCI_API OCI_ObjectGetLob
01062 (
01063     OCI_Object  *obj,
01064     const mtext *attr
01065 )
01066 {
01067     OCI_Lob *lob = NULL;
01068     boolean res  = TRUE;
01069     int index    = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_LOB);
01070 
01071     if (index >= 0)
01072     {
01073         OCIInd *ind           = NULL;
01074         OCILobLocator **value = NULL;
01075 
01076         value = OCI_ObjectGetAttr(obj, index, &ind);
01077 
01078         if ((value != NULL) && (*ind != OCI_IND_NULL))
01079         {
01080             lob = OCI_LobInit(obj->con, (OCI_Lob **) &obj->objs[index],
01081                               *value, obj->typinf->cols[index].subtype);
01082 
01083             res = (lob != NULL);
01084         }
01085     }
01086 
01087     OCI_RESULT(res);
01088 
01089     return lob;
01090 }
01091 
01092 /* --------------------------------------------------------------------------------------------- *
01093  * OCI_ObjectGetFile
01094  * --------------------------------------------------------------------------------------------- */
01095 
01096 OCI_File * OCI_API OCI_ObjectGetFile
01097 (
01098     OCI_Object  *obj,
01099     const mtext *attr
01100 )
01101 {
01102     OCI_File *file = NULL;
01103     boolean res    = TRUE;
01104     int index      = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_FILE);
01105 
01106     if (index >= 0)
01107     {
01108         OCIInd *ind           = NULL;
01109         OCILobLocator **value = NULL;
01110 
01111         value = OCI_ObjectGetAttr(obj, index, &ind);
01112 
01113         if ((value != NULL) && (*ind != OCI_IND_NULL))
01114         {
01115             file = OCI_FileInit(obj->con, (OCI_File **) &obj->objs[index],
01116                                 *value, obj->typinf->cols[index].subtype);
01117 
01118             res = (file != NULL);
01119         }
01120     }
01121 
01122     OCI_RESULT(res);
01123 
01124     return file;
01125 }
01126 
01127 /* --------------------------------------------------------------------------------------------- *
01128  * OCI_ObjectGetRef
01129  * --------------------------------------------------------------------------------------------- */
01130 
01131 OCI_Ref * OCI_API OCI_ObjectGetRef
01132 (
01133     OCI_Object  *obj,
01134     const mtext *attr
01135 )
01136 {
01137     OCI_Ref *ref = NULL;
01138     boolean res  = TRUE;
01139     int index    = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_REF);
01140 
01141     if (index >= 0)
01142     {
01143         OCIInd *ind    = NULL;
01144         OCIRef **value = NULL;
01145 
01146         value = OCI_ObjectGetAttr(obj, index, &ind);
01147 
01148         if ((value != NULL) && (*ind != OCI_IND_NULL))
01149         {
01150             ref = OCI_RefInit(obj->con, NULL, (OCI_Ref **) &obj->objs[index],
01151                               *value);
01152 
01153             res = (ref != NULL);
01154         }
01155     }
01156 
01157     OCI_RESULT(res);
01158 
01159     return ref;
01160 }
01161 
01162 /* --------------------------------------------------------------------------------------------- *
01163  * OCI_ObjectSetShort
01164  * --------------------------------------------------------------------------------------------- */
01165 
01166 boolean OCI_API OCI_ObjectSetShort
01167 (
01168     OCI_Object  *obj,
01169     const mtext *attr,
01170     short        value
01171 )
01172 {
01173     return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01174                                (uword) OCI_NUM_SHORT);
01175 }
01176 
01177 /* --------------------------------------------------------------------------------------------- *
01178  * OCI_ObjectSetUnsignedShort
01179  * --------------------------------------------------------------------------------------------- */
01180 
01181 boolean OCI_API OCI_ObjectSetUnsignedShort
01182 (
01183     OCI_Object    *obj,
01184     const mtext   *attr,
01185     unsigned short value
01186 )
01187 {
01188     return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01189                                (uword) OCI_NUM_USHORT);
01190 }
01191 
01192 /* --------------------------------------------------------------------------------------------- *
01193  * OCI_ObjectSetInt
01194  * --------------------------------------------------------------------------------------------- */
01195 
01196 boolean OCI_API OCI_ObjectSetInt
01197 (
01198     OCI_Object  *obj,
01199     const mtext *attr,
01200     int          value
01201 )
01202 {
01203     return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01204                                (uword) OCI_NUM_INT);
01205 }
01206 
01207 /* --------------------------------------------------------------------------------------------- *
01208  * OCI_ObjectSetUnsignedInt
01209  * --------------------------------------------------------------------------------------------- */
01210 
01211 boolean OCI_API OCI_ObjectSetUnsignedInt
01212 (
01213     OCI_Object  *obj,
01214     const mtext *attr,
01215     unsigned int value
01216 )
01217 {
01218     return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01219                                (uword) OCI_NUM_UINT);
01220 }
01221 
01222 /* --------------------------------------------------------------------------------------------- *
01223  * OCI_ObjectSetBigInt
01224  * --------------------------------------------------------------------------------------------- */
01225 
01226 boolean OCI_API OCI_ObjectSetBigInt
01227 (
01228     OCI_Object  *obj,
01229     const mtext *attr,
01230     big_int      value
01231 )
01232 {
01233     return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01234                                (uword) OCI_NUM_BIGINT);
01235 }
01236 
01237 /* --------------------------------------------------------------------------------------------- *
01238  * OCI_ObjectSetUnsignedBigInt
01239  * --------------------------------------------------------------------------------------------- */
01240 
01241 boolean OCI_API OCI_ObjectSetUnsignedBigInt
01242 (
01243     OCI_Object  *obj,
01244     const mtext *attr,
01245     big_uint     value
01246 )
01247 {
01248     return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01249                                (uword) OCI_NUM_BIGUINT);
01250 }
01251 
01252 /* --------------------------------------------------------------------------------------------- *
01253  * OCI_ObjectSetDouble
01254  * --------------------------------------------------------------------------------------------- */
01255 
01256 boolean OCI_API OCI_ObjectSetDouble
01257 (
01258     OCI_Object  *obj,
01259     const mtext *attr,
01260     double       value
01261 )
01262 {
01263     return OCI_ObjectSetNumber(obj, attr, &value, sizeof(value),
01264                                (uword) OCI_NUM_DOUBLE);
01265 }
01266 
01267 /* --------------------------------------------------------------------------------------------- *
01268  * OCI_ObjectSetString
01269  * --------------------------------------------------------------------------------------------- */
01270 
01271 boolean OCI_API OCI_ObjectSetString
01272 (
01273     OCI_Object  *obj,
01274     const mtext *attr,
01275     const dtext *value
01276 )
01277 {
01278     boolean res = TRUE;
01279 
01280     if (value == NULL)
01281     {
01282         res = OCI_ObjectSetNull(obj, attr);
01283     }
01284     else
01285     {
01286         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TEXT);
01287 
01288         if (index >= 0)
01289         {
01290             OCIInd *ind      = NULL;
01291             OCIString **data = OCI_ObjectGetAttr(obj, index, &ind);
01292 
01293             res = OCI_StringToStringPtr(data, obj->con->err, (void *) value,
01294                                         &obj->buf, &obj->buflen);
01295 
01296             if (res == TRUE)
01297                 *ind = OCI_IND_NOTNULL;
01298         }
01299         else
01300             res = FALSE;
01301     }
01302 
01303     OCI_RESULT(res);
01304 
01305     return res;
01306 }
01307 
01308 /* --------------------------------------------------------------------------------------------- *
01309  * OCI_ObjectSetRaw
01310  * --------------------------------------------------------------------------------------------- */
01311 
01312 boolean OCI_API OCI_ObjectSetRaw
01313 (
01314     OCI_Object  *obj,
01315     const mtext *attr,
01316     void       * value,
01317     unsigned int len
01318 )
01319 {
01320     boolean res = TRUE;
01321 
01322     if (value == NULL)
01323     {
01324         res = OCI_ObjectSetNull(obj, attr);
01325     }
01326     else
01327     {
01328         int index;
01329 
01330         OCI_CHECK_MIN(obj->con, NULL, len, 1, FALSE);
01331 
01332         index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_RAW);
01333 
01334         if (index >= 0)
01335         {
01336             OCIInd *ind   = NULL;
01337             OCIRaw **data = OCI_ObjectGetAttr(obj, index, &ind);
01338 
01339             OCI_CALL2
01340             (
01341                 res, obj->con,
01342 
01343                 OCIRawAssignBytes(OCILib.env, obj->con->err, (ub1*) value,
01344                                   len, data)
01345             )
01346 
01347             if (res == TRUE)
01348                 *ind = OCI_IND_NOTNULL;
01349         }
01350         else
01351             res = FALSE;
01352     }
01353 
01354     OCI_RESULT(res);
01355 
01356     return res;
01357 }
01358 
01359 /* --------------------------------------------------------------------------------------------- *
01360  * OCI_ObjectSetDate
01361  * --------------------------------------------------------------------------------------------- */
01362 
01363 boolean OCI_API OCI_ObjectSetDate
01364 (
01365     OCI_Object  *obj,
01366     const mtext *attr,
01367     OCI_Date    *value
01368 )
01369 {
01370     boolean res = TRUE;
01371 
01372     if (value == NULL)
01373     {
01374         res = OCI_ObjectSetNull(obj, attr);
01375     }
01376     else
01377     {
01378         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_DATETIME);
01379 
01380         if (index >= 0)
01381         {
01382             OCIInd * ind  = NULL;
01383             OCIDate *data = OCI_ObjectGetAttr(obj, index, &ind);
01384 
01385             OCI_CALL2
01386             (
01387                 res, obj->con,
01388 
01389                 OCIDateAssign(obj->con->err, value->handle, data)
01390             )
01391 
01392             if (res == TRUE)
01393                 *ind = OCI_IND_NOTNULL;
01394         }
01395     }
01396 
01397     OCI_RESULT(res);
01398 
01399     return res;
01400 }
01401 
01402 /* --------------------------------------------------------------------------------------------- *
01403  * OCI_ObjectSetTimestamp
01404  * --------------------------------------------------------------------------------------------- */
01405 
01406 boolean OCI_API OCI_ObjectSetTimestamp
01407 (
01408     OCI_Object    *obj,
01409     const mtext   *attr,
01410     OCI_Timestamp *value
01411 )
01412 {
01413     boolean res = TRUE;
01414 
01415     if (value == NULL)
01416     {
01417         res = OCI_ObjectSetNull(obj, attr);
01418     }
01419     else
01420     {
01421         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_TIMESTAMP);
01422 
01423         if (index >= 0)
01424         {
01425             #if OCI_VERSION_COMPILE >= OCI_9_0
01426 
01427             OCIInd * ind       = NULL;
01428             OCIDateTime **data = OCI_ObjectGetAttr(obj, index, &ind);
01429 
01430             OCI_CALL2
01431             (
01432                 res, obj->con,
01433 
01434                 OCIDateTimeAssign((dvoid *) OCILib.env, obj->con->err,
01435                                   value->handle, *data)
01436             )
01437 
01438             if (res == TRUE)
01439                 *ind = OCI_IND_NOTNULL;
01440 
01441             #endif
01442         }
01443     }
01444 
01445     OCI_RESULT(res);
01446 
01447     return res;
01448 }
01449 
01450 /* --------------------------------------------------------------------------------------------- *
01451  * OCI_ObjectSetInterval
01452  * --------------------------------------------------------------------------------------------- */
01453 
01454 boolean OCI_API OCI_ObjectSetInterval
01455 (
01456     OCI_Object   *obj,
01457     const mtext  *attr,
01458     OCI_Interval *value
01459 )
01460 {
01461     boolean res = TRUE;
01462 
01463     if (value == NULL)
01464     {
01465         res = OCI_ObjectSetNull(obj, attr);
01466     }
01467     else
01468     {
01469         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_INTERVAL);
01470 
01471         if (index >= 0)
01472         {
01473             #if OCI_VERSION_COMPILE >= OCI_9_0
01474 
01475             OCIInd * ind       = NULL;
01476             OCIInterval **data = OCI_ObjectGetAttr(obj, index, &ind);
01477 
01478             OCI_CALL2
01479             (
01480                 res, obj->con,
01481 
01482                 OCIIntervalAssign((dvoid *) OCILib.env, obj->con->err,
01483                                   value->handle, *data)
01484             )
01485 
01486             if (res == TRUE)
01487                 *ind = OCI_IND_NOTNULL;
01488 
01489             #endif
01490         }
01491     }
01492 
01493     OCI_RESULT(res);
01494 
01495     return res;
01496 }
01497 
01498 /* --------------------------------------------------------------------------------------------- *
01499  * OCI_ObjectSetColl
01500  * --------------------------------------------------------------------------------------------- */
01501 
01502 boolean OCI_API OCI_ObjectSetColl
01503 (
01504     OCI_Object  *obj,
01505     const mtext *attr,
01506     OCI_Coll    *value
01507 )
01508 {
01509     boolean res = TRUE;
01510 
01511     if (value == NULL)
01512     {
01513         res = OCI_ObjectSetNull(obj, attr);
01514     }
01515     else
01516     {
01517         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_COLLECTION);
01518 
01519         if (index >= 0)
01520         {
01521             OCIInd *ind    = NULL;
01522             OCIColl **data = OCI_ObjectGetAttr(obj, index, &ind);
01523 
01524             OCI_CALL2
01525             (
01526                 res, obj->con,
01527 
01528                 OCICollAssign(OCILib.env, obj->con->err, value->handle, *data)
01529             )
01530 
01531             if (res == TRUE)
01532                 *ind = OCI_IND_NOTNULL;
01533         }
01534     }
01535 
01536     OCI_RESULT(res);
01537 
01538     return res;
01539 }
01540 
01541 /* --------------------------------------------------------------------------------------------- *
01542  * OCI_ObjectSetObject
01543  * --------------------------------------------------------------------------------------------- */
01544 
01545 boolean OCI_API OCI_ObjectSetObject
01546 (
01547     OCI_Object  *obj,
01548     const mtext *attr,
01549     OCI_Object  *value
01550 )
01551 {
01552     boolean res = TRUE;
01553 
01554     if (value == NULL)
01555     {
01556         res = OCI_ObjectSetNull(obj, attr);
01557     }
01558     else
01559     {
01560         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_OBJECT);
01561 
01562         if (index >= 0)
01563         {
01564             OCIInd *ind = NULL;
01565             void *data  = OCI_ObjectGetAttr(obj, index, &ind);
01566 
01567             OCI_CALL2
01568             (
01569                 res, obj->con,
01570 
01571                 OCIObjectCopy(OCILib.env, obj->con->err, obj->con->cxt,
01572                               value->handle, (value->tab_ind + value->idx_ind),
01573                               data, ind, obj->typinf->cols[index].typinf->tdo,
01574                               OCI_DURATION_SESSION, OCI_DEFAULT)
01575             )
01576 
01577             if (res == TRUE)
01578                 *ind = OCI_IND_NOTNULL;
01579         }
01580     }
01581 
01582     OCI_RESULT(res);
01583 
01584     return res;
01585 }
01586 
01587 /* --------------------------------------------------------------------------------------------- *
01588  * OCI_ObjectSetLob
01589  * --------------------------------------------------------------------------------------------- */
01590 
01591 boolean OCI_API OCI_ObjectSetLob
01592 (
01593     OCI_Object  *obj,
01594     const mtext *attr,
01595     OCI_Lob     *value
01596 )
01597 {
01598     boolean res = TRUE;
01599 
01600     if (value == NULL)
01601     {
01602         res = OCI_ObjectSetNull(obj, attr);
01603     }
01604     else
01605     {
01606         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_LOB);
01607 
01608         if (index >= 0)
01609         {
01610             OCIInd * ind = NULL;
01611             void **data  = OCI_ObjectGetAttr(obj, index, &ind);
01612 
01613             OCI_CALL2
01614             (
01615                 res, obj->con,
01616 
01617                 OCILobLocatorAssign(obj->con->cxt, obj->con->err,
01618                                     value->handle, (OCILobLocator **) data)
01619             )
01620 
01621             if (res == TRUE)
01622                 *ind = OCI_IND_NOTNULL;
01623         }
01624     }
01625 
01626     OCI_RESULT(res);
01627 
01628     return res;
01629 }
01630 
01631 /* --------------------------------------------------------------------------------------------- *
01632  * OCI_ObjectSetFile
01633  * --------------------------------------------------------------------------------------------- */
01634 
01635 boolean OCI_API OCI_ObjectSetFile
01636 (
01637     OCI_Object  *obj,
01638     const mtext *attr,
01639     OCI_File    *value
01640 )
01641 {
01642     boolean res = TRUE;
01643 
01644     if (value == NULL)
01645     {
01646         res = OCI_ObjectSetNull(obj, attr);
01647     }
01648     else
01649     {
01650         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_FILE);
01651 
01652         if (index >= 0)
01653         {
01654             OCIInd *ind = NULL;
01655             void **data = OCI_ObjectGetAttr(obj, index, &ind);
01656 
01657             OCI_CALL2
01658             (
01659                 res, obj->con,
01660 
01661                 OCILobLocatorAssign(obj->con->cxt, obj->con->err,
01662                                     value->handle, (OCILobLocator **) data)
01663             )
01664 
01665             if (res == TRUE)
01666                 *ind = OCI_IND_NOTNULL;
01667         }
01668     }
01669 
01670     OCI_RESULT(res);
01671 
01672     return res;
01673 }
01674 
01675 /* --------------------------------------------------------------------------------------------- *
01676  * OCI_ObjectSetRef
01677  * --------------------------------------------------------------------------------------------- */
01678 
01679 boolean OCI_API OCI_ObjectSetRef
01680 (
01681     OCI_Object  *obj,
01682     const mtext *attr,
01683     OCI_Ref     *value
01684 )
01685 {
01686     boolean res = FALSE;
01687 
01688     if (value == NULL)
01689     {
01690         res = OCI_ObjectSetNull(obj, attr);
01691     }
01692     else
01693     {
01694         int index = OCI_ObjectGetAttrIndex(obj, attr, OCI_CDT_REF);
01695 
01696         if (index >= 0)
01697         {
01698             OCIInd *ind   = NULL;
01699             OCIRef **data = OCI_ObjectGetAttr(obj, index, &ind);
01700 
01701             OCI_CALL2
01702             (
01703                 res, obj->con,
01704 
01705                 OCIRefAssign(OCILib.env, obj->con->err, value->handle, data)
01706             )
01707 
01708             if (res == TRUE)
01709                 *ind = OCI_IND_NOTNULL;
01710         }
01711     }
01712 
01713     OCI_RESULT(res);
01714 
01715     return res;
01716 }
01717 
01718 /* --------------------------------------------------------------------------------------------- *
01719  * OCI_ObjectSetNull
01720  * --------------------------------------------------------------------------------------------- */
01721 
01722 boolean OCI_API OCI_ObjectSetNull
01723 (
01724     OCI_Object  *obj,
01725     const mtext *attr
01726 )
01727 {
01728     boolean res = TRUE;
01729     int index;
01730 
01731     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01732     OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);
01733 
01734     index = OCI_ObjectGetAttrIndex(obj, attr, -1);
01735 
01736     if (index >= 0)
01737     {
01738         int ind_index = OCI_ObjectGetIndOffset(obj->typinf, index);
01739 
01740         obj->tab_ind[ind_index] = OCI_IND_NULL;
01741 
01742         res = TRUE;
01743     }
01744     else
01745         res = FALSE;
01746 
01747     OCI_RESULT(res);
01748 
01749     return res;
01750 }
01751 
01752 /* --------------------------------------------------------------------------------------------- *
01753  * OCI_ObjectIsNull
01754  * --------------------------------------------------------------------------------------------- */
01755 
01756 boolean OCI_API OCI_ObjectIsNull
01757 (
01758     OCI_Object  *obj,
01759     const mtext *attr
01760 )
01761 {
01762     boolean res = TRUE;
01763     boolean ret = TRUE;
01764     int index   = 0;
01765 
01766     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01767     OCI_CHECK_PTR(OCI_IPC_STRING, attr, FALSE);
01768 
01769     index = OCI_ObjectGetAttrIndex(obj, attr, -1);
01770 
01771     if (index >= 0)
01772     {
01773         int ind_index = OCI_ObjectGetIndOffset(obj->typinf, index);
01774 
01775         ret = (obj->tab_ind[ind_index] != OCI_IND_NOTNULL);
01776 
01777         res = TRUE;
01778     }
01779     else
01780         res = FALSE;
01781 
01782     OCI_RESULT(res);
01783 
01784     return ret;
01785 }
01786 
01787 /* --------------------------------------------------------------------------------------------- *
01788  * OCI_ObjectGetTypeInfo
01789  * --------------------------------------------------------------------------------------------- */
01790 
01791 OCI_TypeInfo * OCI_API OCI_ObjectGetTypeInfo
01792 (
01793     OCI_Object *obj
01794 )
01795 {
01796     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, NULL);
01797 
01798     OCI_RESULT(TRUE);
01799 
01800     return obj->typinf;
01801 }
01802 
01803 /* --------------------------------------------------------------------------------------------- *
01804  * OCI_ObjectGetType
01805  * --------------------------------------------------------------------------------------------- */
01806 
01807 unsigned int OCI_API OCI_ObjectGetType
01808 (
01809     OCI_Object *obj
01810 )
01811 {
01812     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, OCI_UNKNOWN);
01813 
01814     OCI_RESULT(TRUE);
01815 
01816     return (unsigned int) obj->type;
01817 }
01818 
01819 /* --------------------------------------------------------------------------------------------- *
01820  * OCI_ObjectGetSelfRef
01821  * --------------------------------------------------------------------------------------------- */
01822 
01823 boolean OCI_API OCI_ObjectGetSelfRef
01824 (
01825     OCI_Object *obj,
01826     OCI_Ref    *ref
01827 )
01828 {
01829     boolean res = TRUE;
01830 
01831     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01832     OCI_CHECK_PTR(OCI_IPC_REF, ref, FALSE);
01833 
01834     OCI_CHECK_COMPAT(obj->con, obj->typinf->tdo == ref->typinf->tdo, FALSE);
01835 
01836     OCI_CALL2
01837     (
01838         res, obj->con,
01839 
01840         OCIObjectGetObjectRef(OCILib.env, obj->con->err, obj->handle, ref->handle)
01841     )
01842 
01843     if (res == TRUE)
01844     {
01845         OCI_ObjectFree(ref->obj);
01846         ref->obj = NULL;
01847     }
01848 
01849     OCI_RESULT(res);
01850 
01851     return res;
01852 }
01853 
01854 /* --------------------------------------------------------------------------------------------- *
01855  * OCI_ObjectGetStruct
01856  * --------------------------------------------------------------------------------------------- */
01857 
01858 boolean OCI_API OCI_ObjectGetStruct
01859 (
01860     OCI_Object *obj,
01861     void      **pp_struct,
01862     void     ** pp_ind
01863 )
01864 {
01865     OCI_CHECK_PTR(OCI_IPC_OBJECT, obj, FALSE);
01866 
01867     OCI_RESULT(TRUE);
01868 
01869     *pp_struct = (void *) obj->handle;
01870 
01871     if (pp_ind)
01872         *pp_ind = (void *) obj->tab_ind;
01873 
01874     OCI_RESULT(TRUE);
01875 
01876     return TRUE;
01877 }
01878 

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