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

D:/Perso/dev/ocilib/ocilib/src/ref.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: ref.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_RefInit
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 OCI_Ref * OCI_RefInit
00046 (
00047     OCI_Connection *con,
00048     OCI_TypeInfo   *typinf,
00049     OCI_Ref       **pref,
00050     void           *handle
00051 )
00052 {
00053     boolean res   = TRUE;
00054     OCI_Ref * ref = NULL;
00055 
00056     OCI_CHECK(pref == NULL, NULL);
00057 
00058     if (*pref == NULL)
00059         *pref = (OCI_Ref *) OCI_MemAlloc(OCI_IPC_REF, sizeof(*ref), (size_t) 1, TRUE);
00060 
00061     if (*pref != NULL)
00062     {
00063         ref = *pref;
00064 
00065         ref->handle = handle;
00066         ref->con    = con;
00067         ref->typinf = typinf;
00068 
00069         if ((ref->handle == NULL) || (ref->hstate == OCI_OBJECT_ALLOCATED_ARRAY))
00070         {
00071             /* allocates handle for non fetched object */
00072 
00073             if (ref->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00074             {
00075                 ref->hstate = OCI_OBJECT_ALLOCATED;
00076             }
00077 
00078             OCI_CALL2
00079             (
00080                 res, ref->con,
00081 
00082                 OCI_ObjectNew(OCILib.env,  con->err, con->cxt,
00083                               (OCITypeCode) SQLT_REF,
00084                               (OCIType*) NULL,
00085                               (dvoid *) NULL,
00086                               (OCIDuration) OCI_DURATION_SESSION,
00087                               (boolean) FALSE,
00088                               (dvoid **) &ref->handle)
00089             )
00090         }
00091         else
00092         {
00093             ref->hstate = OCI_OBJECT_FETCHED_CLEAN;
00094 
00095             OCI_RefUnpin(ref);
00096         }
00097     }
00098     else
00099         res = FALSE;
00100 
00101     /* check for failure */
00102 
00103     if (res == FALSE)
00104     {
00105         OCI_RefFree(ref);
00106         ref = NULL;
00107     }
00108 
00109     return ref;
00110 }
00111 
00112 /* --------------------------------------------------------------------------------------------- *
00113  * OCI_RefPin
00114  * --------------------------------------------------------------------------------------------- */
00115 
00116 boolean OCI_RefPin
00117 (
00118     OCI_Ref *ref
00119 )
00120 {
00121     boolean res      = TRUE;
00122     void *obj_handle = NULL;
00123 
00124     OCI_CHECK(ref == NULL, FALSE);
00125 
00126     OCI_RefUnpin(ref);
00127 
00128     OCI_CALL2
00129     (
00130         res, ref->con,
00131 
00132         OCIObjectPin(OCILib.env, ref->con->err, ref->handle,
00133                      (OCIComplexObject *) 0, OCI_PIN_ANY, OCI_DURATION_SESSION,
00134                      OCI_LOCK_NONE, &obj_handle)
00135     )
00136 
00137     if (res == TRUE)
00138     {
00139         OCI_Object *obj = NULL;
00140 
00141         if (res == TRUE)
00142         {
00143             obj =  OCI_ObjectInit(ref->con, (OCI_Object **) &ref->obj,
00144                                   obj_handle, ref->typinf, NULL, -1, TRUE);
00145         }
00146 
00147         if (obj != NULL)
00148             ref->pinned = TRUE;
00149         else
00150             res = FALSE;
00151     }
00152 
00153     return res;
00154 }
00155 
00156 /* --------------------------------------------------------------------------------------------- *
00157  * OCI_RefUnpin
00158  * --------------------------------------------------------------------------------------------- */
00159 
00160 boolean OCI_RefUnpin
00161 (
00162     OCI_Ref *ref
00163 )
00164 {
00165     boolean res = TRUE;
00166 
00167     OCI_CHECK(ref == NULL, FALSE);
00168 
00169     if (ref->pinned == TRUE)
00170     {
00171         OCI_CALL2
00172         (
00173             res, ref->con,
00174 
00175             OCIObjectUnpin(OCILib.env, ref->con->err, ref->obj->handle)
00176         )
00177 
00178         ref->pinned = FALSE;
00179     }
00180 
00181     if (ref->obj != NULL)
00182     {
00183         ref->obj->hstate = OCI_OBJECT_FETCHED_DIRTY;
00184         OCI_ObjectFree(ref->obj);
00185         ref->obj = NULL;
00186     }
00187 
00188     return res;
00189 }
00190 
00191 /* ********************************************************************************************* *
00192  *                            PUBLIC FUNCTIONS
00193  * ********************************************************************************************* */
00194 
00195 /* --------------------------------------------------------------------------------------------- *
00196  * OCI_RefCreate
00197  * --------------------------------------------------------------------------------------------- */
00198 
00199 OCI_Ref * OCI_API OCI_RefCreate
00200 (
00201     OCI_Connection *con,
00202     OCI_TypeInfo   *typinf
00203 )
00204 {
00205     OCI_Ref *ref = NULL;
00206 
00207     OCI_CHECK_INITIALIZED(NULL);
00208 
00209     OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
00210     OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00211 
00212     ref = OCI_RefInit(con, typinf, &ref, NULL);
00213 
00214     OCI_RESULT(ref != NULL);
00215 
00216     return ref;
00217 }
00218 
00219 /* --------------------------------------------------------------------------------------------- *
00220  * OCI_RefFree
00221  * --------------------------------------------------------------------------------------------- */
00222 
00223 boolean OCI_API OCI_RefFree
00224 (
00225     OCI_Ref *ref
00226 )
00227 {
00228     OCI_CHECK_PTR(OCI_IPC_REF, ref, FALSE);
00229 
00230     OCI_CHECK_OBJECT_FETCHED(ref, FALSE);
00231 
00232     OCI_RefUnpin(ref);
00233 
00234     if ((ref->hstate == OCI_OBJECT_ALLOCATED      ) ||
00235         (ref->hstate == OCI_OBJECT_ALLOCATED_ARRAY))
00236     {
00237         OCI_OCIObjectFree(OCILib.env, ref->con->err,  ref->handle,
00238                           OCI_OBJECTFREE_NONULL);
00239     }
00240 
00241     if (ref->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00242     {
00243         OCI_FREE(ref);
00244     }
00245 
00246     OCI_RESULT(TRUE);
00247 
00248     return TRUE;
00249 }
00250 
00251 /* --------------------------------------------------------------------------------------------- *
00252  * OCI_RefArrayCreate
00253  * --------------------------------------------------------------------------------------------- */
00254 
00255 OCI_Ref ** OCI_API OCI_RefArrayCreate
00256 (
00257     OCI_Connection *con,
00258     OCI_TypeInfo   *typinf,
00259     unsigned int    nbelem
00260 )
00261 {
00262     OCI_Array *arr = NULL;
00263     OCI_Ref **refs = NULL;
00264 
00265     arr = OCI_ArrayCreate(con, nbelem, OCI_CDT_REF, 0,
00266                           sizeof(OCIRef *), sizeof(OCI_Ref),
00267                           0, typinf);
00268 
00269     if (arr != NULL)
00270     {
00271         refs = (OCI_Ref **) arr->tab_obj;
00272     }
00273 
00274     return refs;
00275 }
00276 
00277 /* --------------------------------------------------------------------------------------------- *
00278  * OCI_RefArrayFree
00279  * --------------------------------------------------------------------------------------------- */
00280 
00281 boolean OCI_API OCI_RefArrayFree
00282 (
00283     OCI_Ref **refs
00284 )
00285 {
00286     return OCI_ArrayFreeFromHandles((void **) refs);
00287 }
00288 
00289 /* --------------------------------------------------------------------------------------------- *
00290  * OCI_RefGetObject
00291  * --------------------------------------------------------------------------------------------- */
00292 
00293 OCI_Object * OCI_API OCI_RefGetObject
00294 (
00295     OCI_Ref *ref
00296 )
00297 {
00298     OCI_Object *obj = NULL;
00299 
00300     if (OCI_RefIsNull(ref) == FALSE)
00301     {
00302         boolean res = TRUE;
00303 
00304         res = OCI_RefPin(ref);
00305 
00306         OCI_RESULT(res);
00307 
00308         obj = ref->obj;
00309     }
00310 
00311     return obj;
00312 }
00313 
00314 /* --------------------------------------------------------------------------------------------- *
00315  * OCI_RefAssign
00316  * --------------------------------------------------------------------------------------------- */
00317 
00318 boolean OCI_API OCI_RefAssign
00319 (
00320     OCI_Ref *ref,
00321     OCI_Ref *ref_src
00322 )
00323 {
00324     boolean res = TRUE;
00325 
00326     OCI_CHECK_PTR(OCI_IPC_REF, ref,     FALSE);
00327     OCI_CHECK_PTR(OCI_IPC_REF, ref_src, FALSE);
00328 
00329     OCI_CHECK_COMPAT(ref->con, ref->typinf->tdo == ref_src->typinf->tdo, FALSE);
00330 
00331     OCI_CALL2
00332     (
00333         res, ref->con,
00334 
00335         OCIRefAssign(OCILib.env, ref->con->err, ref_src->handle, &ref->handle)
00336     )
00337 
00338     if (res == TRUE)
00339     {
00340         if (ref->obj != NULL)
00341         {
00342             OCI_ObjectFree(ref->obj);
00343             ref->obj = NULL;
00344         }
00345 
00346         ref->typinf = ref_src->typinf;
00347         ref->pinned = ref_src->pinned;
00348     }
00349 
00350     OCI_RESULT(res);
00351 
00352     return res;
00353 }
00354 
00355 /* --------------------------------------------------------------------------------------------- *
00356  * OCI_RefIsNull
00357  * --------------------------------------------------------------------------------------------- */
00358 
00359 boolean OCI_API OCI_RefIsNull
00360 (
00361     OCI_Ref *ref
00362 )
00363 {
00364     OCI_CHECK_PTR(OCI_IPC_REF, ref, TRUE);
00365 
00366     OCI_RESULT(TRUE);
00367 
00368     return (OCIRefIsNull(OCILib.env, ref->handle) == TRUE);
00369 }
00370 
00371 /* --------------------------------------------------------------------------------------------- *
00372  * OCI_RefSetNull
00373  * --------------------------------------------------------------------------------------------- */
00374 
00375 boolean OCI_API OCI_RefSetNull
00376 (
00377     OCI_Ref *ref
00378 )
00379 {
00380     boolean res = TRUE;
00381 
00382     OCI_CHECK_PTR(OCI_IPC_REF, ref, FALSE);
00383 
00384     res = OCI_RefUnpin(ref);
00385 
00386     if (res == TRUE)
00387     {
00388         OCIRefClear(OCILib.env, ref->handle);
00389 
00390         if (ref->obj != NULL)
00391         {
00392             OCI_ObjectFree(ref->obj);
00393             ref->obj = NULL;
00394         }
00395     }
00396 
00397     OCI_RESULT(res);
00398 
00399     return res;
00400 }
00401 
00402 /* --------------------------------------------------------------------------------------------- *
00403  * OCI_RefToText
00404  * --------------------------------------------------------------------------------------------- */
00405 
00406 boolean OCI_API OCI_RefToText
00407 (
00408     OCI_Ref     *ref,
00409     unsigned int size,
00410     mtext       *str
00411 )
00412 {
00413     boolean res = TRUE;
00414     void *ostr  = NULL;
00415     int osize   = (int) size * (int) sizeof(mtext);
00416 
00417     OCI_CHECK_PTR(OCI_IPC_REF, ref, FALSE);
00418     OCI_CHECK_PTR(OCI_IPC_STRING, str, FALSE);
00419 
00420     /* init output buffer in case of OCI failure */
00421 
00422     str[0] = 0;
00423 
00424     ostr = OCI_GetInputMetaString(str, &osize);
00425 
00426     OCI_CALL2
00427     (
00428         res, ref->con,
00429 
00430         OCIRefToHex((dvoid *) OCILib.env, ref->con->err, ref->handle,
00431                     (OraText *) ostr, (ub4 *) &osize)
00432     )
00433 
00434     OCI_GetOutputMetaString(ostr, str, &osize);
00435     OCI_ReleaseMetaString(ostr);
00436 
00437     /* set null string terminator */
00438 
00439     str[osize/ (int) sizeof(mtext)] = 0;
00440 
00441     OCI_RESULT(res);
00442 
00443     return res;
00444 }
00445 
00446 /* --------------------------------------------------------------------------------------------- *
00447  * OCI_RefGetHexSize
00448  * --------------------------------------------------------------------------------------------- */
00449 
00450 unsigned int OCI_API OCI_RefGetHexSize
00451 (
00452     OCI_Ref *ref
00453 )
00454 {
00455     ub4 size = 0;
00456 
00457     OCI_CHECK_PTR(OCI_IPC_REF, ref, 0);
00458 
00459     size = OCIRefHexSize(OCILib.env, (const OCIRef *) ref->handle);
00460 
00461     size /= (ub4) sizeof(mtext);
00462 
00463     OCI_RESULT(TRUE);
00464 
00465     return (unsigned int) size;
00466 }
00467 
00468 /* --------------------------------------------------------------------------------------------- *
00469  * OCI_CollRefGetTypeInfo
00470  * --------------------------------------------------------------------------------------------- */
00471 
00472 OCI_TypeInfo * OCI_API OCI_RefGetTypeInfo
00473 (
00474     OCI_Ref *ref
00475 )
00476 {
00477     OCI_CHECK_PTR(OCI_IPC_REF, ref, NULL);
00478 
00479     OCI_RESULT(TRUE);
00480 
00481     return ref->typinf;
00482 }
00483 

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