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

D:/Perso/dev/ocilib/ocilib/src/array.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: array.c, v 3.8.0 2010-10-24 21:53 Vincent Rogier $
00033  * --------------------------------------------------------------------------------------------- */
00034 
00035 #include "ocilib_internal.h"
00036 
00037 /* ********************************************************************************************* *
00038  *                            PRIVATE FUNCTIONS
00039  * ********************************************************************************************* */
00040 
00041 /* --------------------------------------------------------------------------------------------- *
00042  * OCI_ArrayInit
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 boolean OCI_ArrayInit
00046 (
00047     OCI_Array    *arr,
00048     OCI_TypeInfo *typinf
00049 )
00050 {
00051     unsigned int i;
00052 
00053     for (i = 0; i < arr->nb_elem; i++)
00054     {
00055         void *handle = NULL;
00056 
00057         if (arr->elem_type == OCI_CDT_DATETIME)
00058             handle = &(((OCIDate *)(arr->mem_handle))[i]);
00059         else
00060             handle = ((void **)(arr->mem_handle))[i];
00061 
00062         arr->tab_obj[i] = ((char *) arr->mem_struct) + (arr->struct_size * i);
00063 
00064         ((OCI_Datatype *) (arr->tab_obj[i]))->hstate = OCI_OBJECT_ALLOCATED_ARRAY;
00065 
00066         switch (arr->elem_type)
00067         {
00068         case OCI_CDT_DATETIME:
00069 
00070             OCI_DateInit(arr->con, (OCI_Date **) &arr->tab_obj[i],
00071                          handle, FALSE, FALSE);
00072 
00073             break;
00074 
00075         case OCI_CDT_LOB:
00076 
00077             OCI_LobInit(arr->con, (OCI_Lob **) &arr->tab_obj[i],
00078                         handle, arr->elem_subtype);
00079 
00080             break;
00081 
00082         case OCI_CDT_FILE:
00083 
00084             OCI_FileInit(arr->con, (OCI_File **) &arr->tab_obj[i],
00085                          handle, arr->elem_subtype);
00086             break;
00087 
00088         case OCI_CDT_TIMESTAMP:
00089 
00090             OCI_TimestampInit(arr->con, (OCI_Timestamp **) &arr->tab_obj[i],
00091                               handle, arr->elem_subtype);
00092 
00093             break;
00094 
00095         case OCI_CDT_INTERVAL:
00096 
00097             OCI_IntervalInit(arr->con, (OCI_Interval **) &arr->tab_obj[i],
00098                              handle, arr->elem_subtype);
00099 
00100             break;
00101 
00102         case OCI_CDT_OBJECT:
00103 
00104             OCI_ObjectInit(arr->con, (OCI_Object **) &arr->tab_obj[i],
00105                            handle, typinf, NULL, -1, TRUE);
00106 
00107             break;
00108 
00109         case OCI_CDT_COLLECTION:
00110 
00111             OCI_CollInit(arr->con, (OCI_Coll **) &arr->tab_obj[i],
00112                          handle, typinf);
00113 
00114             break;
00115 
00116         case OCI_CDT_REF:
00117 
00118             OCI_RefInit(arr->con, typinf, (OCI_Ref **) &arr->tab_obj[i],
00119                         handle);
00120 
00121             break;
00122         }
00123     }
00124 
00125     return TRUE;
00126 }
00127 
00128 /* --------------------------------------------------------------------------------------------- *
00129  * OCI_ArrayClose
00130  * --------------------------------------------------------------------------------------------- */
00131 
00132 boolean OCI_ArrayClose
00133 (
00134     OCI_Array *arr
00135 )
00136 {
00137     unsigned int i;
00138 
00139     OCI_CHECK_PTR(OCI_IPC_ARRAY, arr, FALSE);
00140 
00141     /* Cleanup OCILIB Objects */
00142 
00143     for (i = 0; i < arr->nb_elem; i++)
00144     {
00145         switch (arr->elem_type)
00146         {
00147         case OCI_CDT_DATETIME:
00148 
00149             OCI_DateFree((OCI_Date *) arr->tab_obj[i]);
00150 
00151             break;
00152 
00153         case OCI_CDT_LOB:
00154 
00155             OCI_LobFree((OCI_Lob *) arr->tab_obj[i]);
00156             break;
00157 
00158         case OCI_CDT_FILE:
00159 
00160             OCI_FileFree((OCI_File *) arr->tab_obj[i]);
00161             break;
00162 
00163         case OCI_CDT_TIMESTAMP:
00164 
00165             OCI_TimestampFree((OCI_Timestamp *) arr->tab_obj[i]);
00166 
00167             break;
00168 
00169         case OCI_CDT_INTERVAL:
00170 
00171             OCI_IntervalFree((OCI_Interval *) arr->tab_obj[i]);
00172 
00173             break;
00174 
00175         case OCI_CDT_OBJECT:
00176 
00177             OCI_ObjectFree((OCI_Object *) arr->tab_obj[i]);
00178 
00179             break;
00180 
00181         case OCI_CDT_COLLECTION:
00182 
00183             OCI_CollFree((OCI_Coll *) arr->tab_obj[i]);
00184 
00185             break;
00186 
00187         case OCI_CDT_REF:
00188 
00189             OCI_RefFree((OCI_Ref *) arr->tab_obj[i]);
00190             break;
00191         }
00192     }
00193 
00194     /* free OCI descriptors */
00195 
00196     if (arr->handle_type != 0)
00197     {
00198         OCI_DescriptorArrayFree
00199         (
00200             (dvoid **) arr->mem_handle,
00201             (ub4     ) arr->handle_type,
00202             (ub4     ) arr->nb_elem
00203         );
00204     }
00205 
00206     OCI_FREE(arr->mem_handle);
00207     OCI_FREE(arr->mem_struct);
00208     OCI_FREE(arr->tab_obj);
00209 
00210     return TRUE;
00211 }
00212 
00213 /* --------------------------------------------------------------------------------------------- *
00214  * OCI_ArrayCreate
00215  * --------------------------------------------------------------------------------------------- */
00216 
00217 OCI_Array * OCI_ArrayCreate
00218 (
00219     OCI_Connection *con,
00220     unsigned int    nb_elem,
00221     unsigned int    elem_type,
00222     unsigned int    elem_subtype,
00223     unsigned int    elem_size,
00224     unsigned int    struct_size,
00225     unsigned int    handle_type,
00226     OCI_TypeInfo   *typinf
00227 )
00228 {
00229     boolean res    = TRUE;
00230     OCI_Array *arr = NULL;
00231     OCI_Item *item = NULL;
00232 
00233     OCI_CHECK_INITIALIZED(NULL);
00234     OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
00235 
00236     /* create array object */
00237 
00238     item = OCI_ListAppend(OCILib.arrs, sizeof(*arr));
00239 
00240     if (item != NULL)
00241     {
00242         arr = (OCI_Array *) item->data;
00243 
00244         arr->con          = con;
00245         arr->elem_type    = elem_type;
00246         arr->elem_subtype = elem_subtype;
00247         arr->elem_size    = elem_size;
00248         arr->nb_elem      = nb_elem;
00249         arr->struct_size  = struct_size;
00250         arr->handle_type  = handle_type;
00251 
00252         /* allocate OCILIB Object array */
00253 
00254         if (res == TRUE)
00255         {
00256             if ((arr->elem_type != OCI_CDT_NUMERIC) &&
00257                 (arr->elem_type != OCI_CDT_TEXT   ) &&
00258                 (arr->elem_type != OCI_CDT_RAW    ))
00259             {
00260                 arr->tab_obj = (void **) OCI_MemAlloc(OCI_IPC_VOID,
00261                                                       sizeof(void *),
00262                                                       nb_elem, TRUE);
00263 
00264                 res = (arr->tab_obj != NULL) ;
00265             }
00266         }
00267 
00268         /* allocate OCI handle array */
00269 
00270         if (res == TRUE)
00271         {
00272             if (arr->elem_size > 0)
00273             {
00274                 arr->mem_handle = (void **) OCI_MemAlloc(OCI_IPC_VOID,
00275                                                          elem_size,
00276                                                          nb_elem, TRUE);
00277 
00278                 res = (arr->mem_handle != NULL) ;
00279             }
00280         }
00281 
00282         /* allocate OCILIB structure array */
00283 
00284         if (res == TRUE)
00285         {
00286             if (arr->struct_size > 0)
00287             {
00288                 arr->mem_struct = (void **) OCI_MemAlloc(OCI_IPC_VOID,
00289                                                          struct_size,
00290                                                          nb_elem, TRUE);
00291 
00292                 res = (arr->mem_struct != NULL) ;
00293             }
00294         }
00295 
00296         /* allocate OCI handle descriptors */
00297 
00298         if (res == TRUE)
00299         {
00300             if (handle_type != 0)
00301             {
00302                 res = (OCI_SUCCESS == OCI_DescriptorArrayAlloc
00303                        (
00304                            (dvoid  *) OCILib.env,
00305                            (dvoid **) arr->mem_handle,
00306                            (ub4     ) handle_type,
00307                            (ub4     ) nb_elem,
00308                            (size_t  ) 0,
00309                            (dvoid **) NULL
00310                        ));
00311             }
00312         }
00313 
00314         if ((res == TRUE) && (arr->mem_handle != NULL))
00315         {
00316             res = OCI_ArrayInit(arr, typinf);
00317         }
00318     }
00319     else
00320     {
00321         res = FALSE;
00322     }
00323 
00324     /* check for failure */
00325 
00326     if (res == FALSE)
00327     {
00328         OCI_ArrayClose(arr);
00329         OCI_FREE(arr);
00330     }
00331 
00332     OCI_RESULT(res);
00333 
00334     return arr;
00335 }
00336 
00337 /* --------------------------------------------------------------------------------------------- *
00338  * OCI_ArrayFreeFromHandles
00339  * --------------------------------------------------------------------------------------------- */
00340 
00341 boolean OCI_ArrayFreeFromHandles
00342 (
00343     void **handles
00344 )
00345 {
00346     boolean res    = FALSE;
00347     OCI_List *list = OCILib.arrs;
00348     OCI_Item *item = NULL;
00349     OCI_Array *arr = NULL;
00350 
00351     OCI_CHECK_PTR(OCI_IPC_VOID, handles, FALSE);
00352 
00353     OCI_CHECK(list == NULL, FALSE);
00354 
00355     if (list->mutex != NULL)
00356         OCI_MutexAcquire(list->mutex);
00357 
00358     item = list->head;
00359 
00360     while (item != NULL)
00361     {
00362         OCI_Array * tmp_arr = (OCI_Array *) item->data;
00363 
00364         if ((tmp_arr != NULL) && (tmp_arr->tab_obj == handles))
00365         {
00366             arr = tmp_arr;
00367             break;
00368         }
00369 
00370         item = item->next;
00371     }
00372 
00373     if (list->mutex != NULL)
00374         OCI_MutexRelease(list->mutex);
00375 
00376     if (arr != NULL)
00377     {
00378         res = OCI_ListRemove(OCILib.arrs, arr);
00379         OCI_ArrayClose(arr);
00380         OCI_FREE(arr);
00381     }
00382 
00383     OCI_RESULT(res);
00384 
00385     return res;
00386 }
00387 
00388 /* --------------------------------------------------------------------------------------------- *
00389  * OCI_ArrayGetOCIHandlesFromHandles
00390  * --------------------------------------------------------------------------------------------- */
00391 
00392 void * OCI_ArrayGetOCIHandlesFromHandles
00393 (
00394     void **handles
00395 )
00396 {
00397     OCI_List *list = OCILib.arrs;
00398     void *ret      = NULL;
00399     OCI_Item *item = NULL;
00400     OCI_Array *arr = NULL;
00401 
00402     OCI_CHECK(list == NULL, NULL);
00403     OCI_CHECK(list == NULL, NULL);
00404 
00405     if (list->mutex != NULL)
00406         OCI_MutexAcquire(list->mutex);
00407 
00408     item = list->head;
00409 
00410     while (item != NULL)
00411     {
00412         OCI_Array * tmp_arr = (OCI_Array *) item->data;
00413 
00414         if ((tmp_arr != NULL) && (tmp_arr->tab_obj == handles))
00415         {
00416             arr = tmp_arr;
00417             break;
00418         }
00419 
00420         item = item->next;
00421     }
00422 
00423     if (list->mutex != NULL)
00424         OCI_MutexRelease(list->mutex);
00425 
00426     if (arr != NULL)
00427     {
00428         ret = arr->mem_handle;
00429     }
00430 
00431     return ret;
00432 }

Generated on Sun Oct 24 2010 22:02:54 for OCILIB (C Driver for Oracle) by  doxygen 1.7.1