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

D:/Perso/dev/ocilib/ocilib/src/object.c

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

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