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