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

Generated on Thu Jul 30 17:41:53 2009 for OCILIB (C Driver for Oracle) by  doxygen 1.5.4