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