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

D:/Perso/dev/ocilib/ocilib/src/lob.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: lob.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_LobInit
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 OCI_Lob * OCI_LobInit
00046 (
00047     OCI_Connection *con,
00048     OCI_Lob       **plob,
00049     OCILobLocator  *handle,
00050     ub4             type
00051 )
00052 {
00053     ub2 csid      = OCI_DEFAULT;
00054     ub1 csfrm     = OCI_DEFAULT;
00055     OCI_Lob * lob = NULL;
00056     boolean res   = TRUE;
00057     ub1 lobtype   = 0;
00058 
00059     OCI_CHECK(plob == NULL, NULL);
00060 
00061     if (*plob == NULL)
00062         *plob = (OCI_Lob *) OCI_MemAlloc(OCI_IPC_LOB, sizeof(*lob), (size_t) 1, TRUE);
00063 
00064     if (*plob != NULL)
00065     {
00066         lob = *plob;
00067 
00068         lob->type   = type;
00069         lob->con    = con;
00070         lob->handle = handle;
00071         lob->offset = 1;
00072 
00073         if ((lob->handle == NULL) || (lob->hstate == OCI_OBJECT_ALLOCATED_ARRAY))
00074         {
00075             ub4 empty = 0;
00076 
00077             if (lob->type == OCI_NCLOB)
00078             {
00079                 csfrm   = SQLCS_NCHAR;
00080                 lobtype = OCI_TEMP_CLOB;
00081             }
00082             else if (lob->type == OCI_CLOB)
00083             {
00084                 csfrm   = SQLCS_IMPLICIT;
00085                 lobtype = OCI_TEMP_CLOB;
00086             }
00087             else
00088                 lobtype = OCI_TEMP_BLOB;
00089 
00090             /* allocate handle for non fetched lob (temporary lob) */
00091 
00092             if (lob->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00093             {
00094                 lob->hstate = OCI_OBJECT_ALLOCATED;
00095 
00096                 res = (OCI_SUCCESS == OCI_DescriptorAlloc((dvoid  *) OCILib.env,
00097                                                           (dvoid **) (void *) &lob->handle,
00098                                                           (ub4) OCI_DTYPE_LOB,
00099                                                           (size_t) 0, (dvoid **) NULL));
00100             }
00101 
00102             OCI_CALL2
00103             (
00104                 res, lob->con,
00105 
00106                 OCIAttrSet((dvoid *) lob->handle, (ub4) OCI_DTYPE_LOB,
00107                            (dvoid *) &empty, (ub4) sizeof(empty),
00108                            (ub4) OCI_ATTR_LOBEMPTY, lob->con->err)
00109             )
00110 
00111             OCI_CALL2
00112             (
00113                 res, lob->con,
00114 
00115                 OCILobCreateTemporary(lob->con->cxt, lob->con->err,
00116                                       lob->handle, csid, csfrm, lobtype,
00117                                       FALSE, OCI_DURATION_SESSION)
00118             )
00119 
00120         }
00121         else
00122             lob->hstate = OCI_OBJECT_FETCHED_CLEAN;
00123     }
00124     else
00125         res = FALSE;
00126 
00127     /* check for failure */
00128 
00129     if (res == FALSE)
00130     {
00131         OCI_LobFree(lob);
00132         lob = NULL;
00133     }
00134 
00135     return lob;
00136 }
00137 
00138 /* ********************************************************************************************* *
00139  *                            PUBLIC FUNCTIONS
00140  * ********************************************************************************************* */
00141 
00142 /* --------------------------------------------------------------------------------------------- *
00143  * OCI_LobCreate
00144  * --------------------------------------------------------------------------------------------- */
00145 
00146 OCI_Lob * OCI_API OCI_LobCreate
00147 (
00148     OCI_Connection *con,
00149     unsigned int    type
00150 )
00151 {
00152     OCI_Lob *lob = NULL;
00153 
00154     OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
00155 
00156     lob = OCI_LobInit(con, &lob, NULL, type);
00157 
00158     OCI_RESULT(lob != NULL);
00159 
00160     return lob;
00161 }
00162 
00163 /* --------------------------------------------------------------------------------------------- *
00164  * OCI_LobFree
00165  * --------------------------------------------------------------------------------------------- */
00166 
00167 boolean OCI_API OCI_LobFree
00168 (
00169     OCI_Lob *lob
00170 )
00171 {
00172     boolean res = TRUE;
00173 
00174     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00175 
00176     OCI_CHECK_OBJECT_FETCHED(lob, FALSE);
00177 
00178     if (OCI_LobIsTemporary(lob) == TRUE)
00179     {
00180         OCI_CALL2
00181         (
00182             res, lob->con,
00183 
00184             OCILobFreeTemporary(lob->con->cxt, lob->con->err, lob->handle)
00185         )
00186     }
00187 
00188     if (lob->hstate == OCI_OBJECT_ALLOCATED)
00189     {
00190         OCI_DescriptorFree((dvoid *) lob->handle, (ub4) OCI_DTYPE_LOB);
00191     }
00192 
00193     if (lob->hstate != OCI_OBJECT_ALLOCATED_ARRAY)
00194     {
00195         OCI_FREE(lob);
00196     }
00197 
00198     OCI_RESULT(res);
00199 
00200     return res;
00201 }
00202 
00203 /* --------------------------------------------------------------------------------------------- *
00204  * OCI_LobArrayCreate
00205  * --------------------------------------------------------------------------------------------- */
00206 
00207 OCI_Lob ** OCI_API OCI_LobArrayCreate
00208 (
00209     OCI_Connection *con,
00210     unsigned int    type,
00211     unsigned int    nbelem
00212 )
00213 {
00214     OCI_Array *arr = NULL;
00215     OCI_Lob **lobs = NULL;
00216 
00217     arr = OCI_ArrayCreate(con, nbelem, OCI_CDT_LOB, type,
00218                           sizeof(OCILobLocator *), sizeof(OCI_Lob),
00219                           OCI_DTYPE_LOB, NULL);
00220 
00221     if (arr != NULL)
00222     {
00223         lobs = (OCI_Lob **) arr->tab_obj;
00224     }
00225 
00226     return lobs;
00227 }
00228 
00229 /* --------------------------------------------------------------------------------------------- *
00230  * OCI_LobArrayFree
00231  * --------------------------------------------------------------------------------------------- */
00232 
00233 boolean OCI_API OCI_LobArrayFree
00234 (
00235     OCI_Lob **lobs
00236 )
00237 {
00238     return OCI_ArrayFreeFromHandles((void **) lobs);
00239 }
00240 
00241 /* --------------------------------------------------------------------------------------------- *
00242  * OCI_LobGetType
00243  * --------------------------------------------------------------------------------------------- */
00244 
00245 unsigned int OCI_API OCI_LobGetType
00246 (
00247     OCI_Lob *lob
00248 )
00249 {
00250     OCI_CHECK_PTR(OCI_IPC_LOB, lob, OCI_UNKNOWN);
00251 
00252     OCI_RESULT(TRUE);
00253 
00254     return lob->type;
00255 }
00256 
00257 /* --------------------------------------------------------------------------------------------- *
00258  * OCI_LobSeek
00259  * --------------------------------------------------------------------------------------------- */
00260 
00261 boolean OCI_API OCI_LobSeek
00262 (
00263     OCI_Lob     *lob,
00264     big_uint     offset,
00265     unsigned int mode
00266 )
00267 {
00268     boolean res   = TRUE;
00269     big_uint size = 0;
00270 
00271     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00272 
00273     size = OCI_LobGetLength(lob);
00274 
00275     if ((mode == OCI_SEEK_CUR && (offset + lob->offset-1) > size))
00276         res = FALSE;
00277     else if (mode == OCI_SEEK_SET)
00278         lob->offset = offset + 1;
00279     else if (mode == OCI_SEEK_END)
00280         lob->offset = size-offset + 1;
00281     else if (mode == OCI_SEEK_CUR)
00282         lob->offset += offset;
00283     else
00284         res = FALSE;
00285 
00286     OCI_RESULT(res);
00287 
00288     return res;
00289 }
00290 
00291 /* --------------------------------------------------------------------------------------------- *
00292  * OCI_LobGetOffset
00293  * --------------------------------------------------------------------------------------------- */
00294 
00295 big_uint OCI_API OCI_LobGetOffset
00296 (
00297     OCI_Lob *lob
00298 )
00299 {
00300     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00301 
00302     OCI_RESULT(TRUE);
00303 
00304     return lob->offset - 1;
00305 }
00306 
00307 /* --------------------------------------------------------------------------------------------- *
00308  * OCI_LobRead2
00309  * --------------------------------------------------------------------------------------------- */
00310 
00311 boolean OCI_API OCI_LobRead2
00312 (
00313     OCI_Lob      *lob,
00314     void         *buffer,
00315     unsigned int *char_count,
00316     unsigned int *byte_count
00317 )
00318 {
00319     boolean res = TRUE;
00320     ub2 csid    = 0;
00321     ub1 csfrm   = 0;
00322 
00323     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00324     OCI_CHECK_PTR(OCI_IPC_LOB, char_count, FALSE);
00325     OCI_CHECK_PTR(OCI_IPC_LOB, byte_count, FALSE);
00326 
00327     if (lob->type != OCI_BLOB)
00328     {
00329 
00330         #ifdef OCI_USERDATA_WIDE
00331 
00332         csid = OCI_UTF16ID;
00333 
00334         #endif
00335 
00336         if (((*byte_count) == 0) && ((*char_count) > 0))
00337         {
00338             if (OCILib.nls_utf8 == TRUE)
00339             {
00340                 (*byte_count) = (*char_count) * (ub4) UTF8_BYTES_PER_CHAR;
00341             }
00342             else
00343             {
00344                 (*byte_count) = (*char_count) * (ub4) sizeof(odtext);
00345             }
00346         }
00347     }
00348 
00349     if (lob->type == OCI_NCLOB)
00350         csfrm = SQLCS_NCHAR;
00351     else
00352         csfrm = SQLCS_IMPLICIT;
00353 
00354     OCI_CHECK_MIN(lob->con, NULL, (*byte_count), 1, FALSE);
00355 
00356     #ifdef OCI_LOB2_API_ENABLED
00357 
00358     if (OCILib.use_lob_ub8)
00359     {
00360         ub8 size_in_out_char = (ub8) (*char_count);
00361         ub8 size_in_out_byte = (ub8) (*byte_count);
00362 
00363         OCI_CALL2
00364         (
00365             res, lob->con,
00366 
00367             OCILobRead2(lob->con->cxt, lob->con->err, lob->handle,
00368                         &size_in_out_byte, &size_in_out_char,
00369                         (ub8) lob->offset, buffer,(ub8) (*byte_count),
00370                         (ub1) OCI_ONE_PIECE, (void *) NULL,
00371                         NULL, csid, csfrm)
00372         )
00373 
00374             (*char_count) = (ub4) size_in_out_char;
00375         (*byte_count)     = (ub4) size_in_out_byte;
00376     }
00377 
00378     else
00379 
00380     #endif
00381 
00382     {
00383         ub4 size_in_out_char_byte = 0;
00384 
00385         if (lob->type == OCI_BLOB)
00386             size_in_out_char_byte = (*byte_count);
00387         else
00388             size_in_out_char_byte = (*char_count);
00389 
00390         OCI_CALL2
00391         (
00392             res, lob->con,
00393 
00394             OCILobRead(lob->con->cxt, lob->con->err, lob->handle,
00395                        &size_in_out_char_byte, (ub4) lob->offset,
00396                        buffer, (ub4) (*byte_count), (void *) NULL,
00397                        NULL, csid, csfrm)
00398         )
00399 
00400             (*char_count) = (ub4) size_in_out_char_byte;
00401         (*byte_count)     = (ub4) size_in_out_char_byte;
00402     }
00403 
00404     if (lob->type != OCI_BLOB)
00405     {
00406         unsigned int byte_offset = (ub4) (*byte_count);
00407 
00408         if (OCILib.nls_utf8 == FALSE)
00409             byte_offset *= sizeof(odtext);
00410 
00411         memset(((char *) buffer) + byte_offset, 0, sizeof(odtext));
00412 
00413         #ifndef OCI_LOB2_API_ENABLED
00414 
00415         if (OCILib.nls_utf8 == TRUE)
00416             (*char_count) = OCI_StringUTF8Length((const char *) buffer);
00417 
00418         #endif
00419 
00420     }
00421 
00422     if (res == TRUE)
00423     {
00424         if (lob->type == OCI_BLOB)
00425         {
00426             lob->offset += (big_uint) (*byte_count);
00427         }
00428         else
00429         {
00430             lob->offset += (big_uint) (*char_count);
00431 
00432             if (OCILib.nls_utf8 == FALSE)
00433             {
00434                 OCI_ConvertString(buffer, (int) (*char_count), sizeof(odtext), sizeof(dtext));
00435             }
00436         }
00437     }
00438 
00439     OCI_RESULT(res);
00440 
00441     return res;
00442 }
00443 
00444 /* --------------------------------------------------------------------------------------------- *
00445  * OCI_LobRead
00446  * --------------------------------------------------------------------------------------------- */
00447 
00448 unsigned int OCI_API OCI_LobRead
00449 (
00450     OCI_Lob     *lob,
00451     void        *buffer,
00452     unsigned int len
00453 )
00454 {
00455     unsigned int char_count = 0;
00456     unsigned int byte_count = 0;
00457     unsigned int *ptr_count = NULL;
00458 
00459     if (lob != NULL)
00460     {
00461         if(lob->type == OCI_BLOB)
00462         {
00463             byte_count = len;
00464             ptr_count  = &byte_count;
00465         }
00466         else
00467         {
00468             char_count = len;
00469             ptr_count  = &char_count;
00470         }
00471     }
00472 
00473     OCI_LobRead2(lob, buffer, &char_count, &byte_count);
00474 
00475     return (ptr_count ? *ptr_count : 0);
00476 }
00477 
00478 /* --------------------------------------------------------------------------------------------- *
00479  * OCI_LobWrite
00480  * --------------------------------------------------------------------------------------------- */
00481 
00482 boolean OCI_API OCI_LobWrite2
00483 (
00484     OCI_Lob      *lob,
00485     void         *buffer,
00486     unsigned int *char_count,
00487     unsigned int *byte_count
00488 )
00489 {
00490     boolean res = TRUE;
00491     ub2 csid    = 0;
00492     ub1 csfrm   = 0;
00493     void *obuf  = NULL;
00494 
00495     OCI_CHECK_PTR(OCI_IPC_LOB, char_count, FALSE);
00496     OCI_CHECK_PTR(OCI_IPC_LOB, byte_count, FALSE);
00497 
00498     if (lob->type != OCI_BLOB)
00499     {
00500 
00501         #ifdef OCI_USERDATA_WIDE
00502 
00503         csid = OCI_UTF16ID;
00504 
00505         #endif
00506 
00507         if (((*byte_count) == 0) && ((*char_count) > 0))
00508         {
00509             if (OCILib.nls_utf8 == TRUE)
00510             {
00511                 (*byte_count) = (unsigned int) strlen(buffer);
00512             }
00513             else
00514             {
00515                 (*byte_count) = (*char_count) * (ub4) sizeof(dtext);
00516             }
00517         }
00518 
00519         if (((*char_count) == 0) && ((*byte_count) > 0))
00520         {
00521             if (OCILib.nls_utf8 == TRUE)
00522             {
00523 
00524                 #ifndef OCI_LOB2_API_ENABLED
00525 
00526                     (*char_count) = OCI_StringUTF8Length((const char *) buffer);
00527 
00528                 #endif
00529 
00530             }
00531             else
00532             {
00533                 (*char_count) = (*byte_count) / (ub4) sizeof(dtext);
00534             }
00535         }
00536 
00537         obuf = OCI_GetInputDataString(buffer, (int *) byte_count);
00538 
00539         (*byte_count) *= sizeof(odtext);
00540     }
00541     else
00542     {
00543         obuf = buffer;
00544     }
00545 
00546     if (lob->type == OCI_NCLOB)
00547         csfrm = SQLCS_NCHAR;
00548     else
00549         csfrm = SQLCS_IMPLICIT;
00550 
00551     OCI_CHECK_MIN(lob->con, NULL, (*byte_count), 1, FALSE);
00552 
00553     #ifdef OCI_LOB2_API_ENABLED
00554 
00555     if (OCILib.use_lob_ub8)
00556     {
00557         ub8 size_in_out_char = (ub8) (*char_count);
00558         ub8 size_in_out_byte = (ub8) (*byte_count);
00559 
00560         OCI_CALL2
00561         (
00562             res, lob->con,
00563 
00564             OCILobWrite2(lob->con->cxt, lob->con->err, lob->handle,
00565                          &size_in_out_byte, &size_in_out_char,
00566                          (ub8) lob->offset, obuf, (ub8) (*byte_count),
00567                          (ub1) OCI_ONE_PIECE, (void *) NULL,
00568                          NULL, csid, csfrm)
00569         )
00570 
00571             (*char_count) = (ub4) size_in_out_char;
00572         (*byte_count)     = (ub4) size_in_out_byte;
00573     }
00574 
00575     else
00576 
00577     #endif
00578 
00579     {
00580         ub4 size_in_out_char_byte = 0;
00581 
00582         if ((lob->type == OCI_BLOB) || (OCILib.nls_utf8 == TRUE))
00583             size_in_out_char_byte = (*byte_count);
00584         else
00585             size_in_out_char_byte = (*char_count);
00586 
00587         OCI_CALL2
00588         (
00589             res, lob->con,
00590 
00591             OCILobWrite(lob->con->cxt, lob->con->err, lob->handle,
00592                         &size_in_out_char_byte, (ub4) lob->offset,
00593                         obuf, (ub4) (*byte_count), (ub1) OCI_ONE_PIECE,
00594                         (void *) NULL, NULL, csid, csfrm)
00595         )
00596 
00597         if (lob->type == OCI_BLOB)
00598             (*byte_count) = (ub4) size_in_out_char_byte;
00599         else
00600             (*char_count) = (ub4) size_in_out_char_byte;
00601     }
00602 
00603     if (res == TRUE)
00604     {
00605         if (lob->type == OCI_BLOB)
00606         {
00607             lob->offset += (big_uint) (*byte_count);
00608         }
00609         else
00610         {
00611             lob->offset += (big_uint) (*char_count);
00612 
00613             if (OCILib.nls_utf8 == FALSE)
00614             {
00615                 OCI_ReleaseDataString(obuf);
00616             }
00617         }
00618     }
00619 
00620     OCI_RESULT(res);
00621 
00622     return res;
00623 }
00624 
00625 /* --------------------------------------------------------------------------------------------- *
00626  * OCI_LobWrite
00627  * --------------------------------------------------------------------------------------------- */
00628 
00629 unsigned int OCI_API OCI_LobWrite
00630 (
00631     OCI_Lob     *lob,
00632     void        *buffer,
00633     unsigned int len
00634 )
00635 {
00636     unsigned int char_count = 0;
00637     unsigned int byte_count = 0;
00638     unsigned int *ptr_count = NULL;
00639 
00640     if (lob != NULL)
00641     {
00642         if(lob->type == OCI_BLOB)
00643         {
00644             byte_count = len;
00645             ptr_count  = &byte_count;
00646         }
00647         else
00648         {
00649             char_count = len;
00650             ptr_count  = &char_count;
00651         }
00652     }
00653 
00654     OCI_LobWrite2(lob, buffer, &char_count, &byte_count);
00655 
00656     return (ptr_count ? *ptr_count : 0);
00657 }
00658 
00659 /* --------------------------------------------------------------------------------------------- *
00660  * OCI_LobTruncate
00661  * --------------------------------------------------------------------------------------------- */
00662 
00663 boolean OCI_API OCI_LobTruncate
00664 (
00665     OCI_Lob *lob,
00666     big_uint size
00667 )
00668 {
00669     boolean res = TRUE;
00670 
00671     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00672 
00673     #ifdef OCI_LOB2_API_ENABLED
00674 
00675     if (OCILib.use_lob_ub8)
00676     {
00677         OCI_CALL2
00678         (
00679             res, lob->con,
00680 
00681             OCILobTrim2(lob->con->cxt, lob->con->err, lob->handle, (ub8) size)
00682         )
00683     }
00684     else
00685 
00686     #endif
00687 
00688     {
00689         OCI_CALL2
00690         (
00691             res, lob->con,
00692 
00693             OCILobTrim(lob->con->cxt, lob->con->err, lob->handle, (ub4) size)
00694         )
00695     }
00696 
00697     OCI_RESULT(res);
00698 
00699     return res;
00700 }
00701 
00702 /* --------------------------------------------------------------------------------------------- *
00703  * OCI_LobErase
00704  * --------------------------------------------------------------------------------------------- */
00705 
00706 big_uint OCI_API OCI_LobErase
00707 (
00708     OCI_Lob *lob,
00709     big_uint offset,
00710     big_uint size
00711 )
00712 {
00713     boolean res = TRUE;
00714 
00715     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00716     OCI_CHECK_MIN(lob->con, NULL, size, 1, 0);
00717 
00718     #ifdef OCI_LOB2_API_ENABLED
00719 
00720     if (OCILib.use_lob_ub8)
00721     {
00722         ub8 lob_size = (ub8) size;
00723 
00724         OCI_CALL2
00725         (
00726             res, lob->con,
00727 
00728             OCILobErase2(lob->con->cxt, lob->con->err, lob->handle,
00729                          (ub8 *) &lob_size, (ub8) (offset + 1))
00730         )
00731 
00732         size = (big_uint) lob_size;
00733     }
00734     else
00735 
00736     #endif
00737 
00738     {
00739         ub4 lob_size = (ub4) size;
00740 
00741         OCI_CALL2
00742         (
00743             res, lob->con,
00744 
00745             OCILobErase(lob->con->cxt, lob->con->err, lob->handle,
00746                         &lob_size, (ub4) offset + 1)
00747         )
00748 
00749         size = (big_uint) lob_size;
00750     }
00751 
00752     OCI_RESULT(res);
00753 
00754     return size;
00755 }
00756 
00757 /* --------------------------------------------------------------------------------------------- *
00758  * OCI_LobGetLength
00759  * --------------------------------------------------------------------------------------------- */
00760 
00761 big_uint OCI_API OCI_LobGetLength
00762 (
00763     OCI_Lob *lob
00764 )
00765 {
00766     boolean res   = TRUE;
00767     big_uint size = 0;
00768 
00769     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00770 
00771     #ifdef OCI_LOB2_API_ENABLED
00772 
00773     if (OCILib.use_lob_ub8)
00774     {
00775         ub8 lob_size = 0;
00776 
00777         OCI_CALL2
00778         (
00779             res, lob->con,
00780 
00781             OCILobGetLength2(lob->con->cxt, lob->con->err, lob->handle,
00782                              (ub8 *) &lob_size)
00783         )
00784 
00785         size = (big_uint) lob_size;
00786     }
00787     else
00788 
00789     #endif
00790 
00791     {
00792         ub4 lob_size = 0;
00793 
00794         OCI_CALL2
00795         (
00796             res, lob->con,
00797 
00798             OCILobGetLength(lob->con->cxt, lob->con->err, lob->handle, &lob_size)
00799         )
00800 
00801         size = (big_uint) lob_size;
00802     }
00803 
00804     OCI_RESULT(res);
00805 
00806     return size;
00807 }
00808 
00809 /* --------------------------------------------------------------------------------------------- *
00810  * OCI_LobGetChunkSize
00811  * --------------------------------------------------------------------------------------------- */
00812 
00813 unsigned int OCI_API OCI_LobGetChunkSize
00814 (
00815     OCI_Lob *lob
00816 )
00817 {
00818     boolean res = TRUE;
00819     ub4 size    = 0;
00820 
00821     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00822 
00823     OCI_CALL2
00824     (
00825         res, lob->con,
00826 
00827         OCILobGetChunkSize(lob->con->cxt, lob->con->err, lob->handle, &size)
00828     )
00829 
00830     OCI_RESULT(res);
00831 
00832     return (unsigned int) size;
00833 }
00834 
00835 /* --------------------------------------------------------------------------------------------- *
00836  * OCI_LobCopy
00837  * --------------------------------------------------------------------------------------------- */
00838 
00839 boolean OCI_API OCI_LobCopy
00840 (
00841     OCI_Lob *lob,
00842     OCI_Lob *lob_src,
00843     big_uint offset_dst,
00844     big_uint offset_src,
00845     big_uint count
00846 )
00847 {
00848     boolean res = TRUE;
00849 
00850     OCI_CHECK_PTR(OCI_IPC_LOB, lob,     FALSE);
00851     OCI_CHECK_PTR(OCI_IPC_LOB, lob_src, FALSE);
00852 
00853     #ifdef OCI_LOB2_API_ENABLED
00854 
00855     if (OCILib.use_lob_ub8)
00856     {
00857 
00858         OCI_CALL2
00859         (
00860             res, lob->con,
00861 
00862             OCILobCopy2(lob->con->cxt, lob->con->err, lob->handle,
00863                         lob_src->handle, (ub8) count,
00864                         (ub8) (offset_dst + 1),
00865                         (ub8) (offset_src + 1))
00866         )
00867     }
00868     else
00869 
00870     #endif
00871 
00872     {
00873         OCI_CALL2
00874         (
00875             res, lob->con,
00876 
00877             OCILobCopy(lob->con->cxt, lob->con->err, lob->handle,
00878                        lob_src->handle, (ub4) count,
00879                        (ub4) (offset_dst + 1),
00880                        (ub4) (offset_src + 1))
00881         )
00882     }
00883 
00884     OCI_RESULT(res);
00885 
00886     return res;
00887 }
00888 
00889 /* --------------------------------------------------------------------------------------------- *
00890  * OCI_LobCopyFromFile
00891  * --------------------------------------------------------------------------------------------- */
00892 
00893 boolean OCI_API OCI_LobCopyFromFile
00894 (
00895     OCI_Lob  *lob,
00896     OCI_File *file,
00897     big_uint  offset_dst,
00898     big_uint  offset_src,
00899     big_uint  count
00900 )
00901 {
00902     boolean res = TRUE;
00903 
00904     OCI_CHECK_PTR(OCI_IPC_LOB, lob,   FALSE);
00905     OCI_CHECK_PTR(OCI_IPC_FILE, file, FALSE);
00906 
00907     #ifdef OCI_LOB2_API_ENABLED
00908 
00909     if (OCILib.use_lob_ub8)
00910     {
00911         OCI_CALL2
00912         (
00913             res, lob->con,
00914 
00915             OCILobLoadFromFile2(lob->con->cxt, lob->con->err,
00916                                 lob->handle, file->handle,
00917                                 (ub8) count,
00918                                 (ub8) (offset_dst + 1),
00919                                 (ub8) (offset_src + 1))
00920         )
00921     }
00922     else
00923 
00924     #endif
00925 
00926     {
00927         OCI_CALL2
00928         (
00929             res, lob->con,
00930 
00931             OCILobLoadFromFile(lob->con->cxt, lob->con->err,
00932                                lob->handle, file->handle,
00933                                (ub4) count,
00934                                (ub4) (offset_dst + 1),
00935                                (ub4) (offset_src + 1))
00936         )
00937     }
00938 
00939     OCI_RESULT(res);
00940 
00941     return res;
00942 }
00943 
00944 /* --------------------------------------------------------------------------------------------- *
00945  * OCI_LobAppend2
00946  * --------------------------------------------------------------------------------------------- */
00947 
00948 boolean OCI_API OCI_LobAppend2
00949 (
00950     OCI_Lob      *lob,
00951     void         *buffer,
00952     unsigned int *char_count,
00953     unsigned int *byte_count
00954 )
00955 {
00956     boolean res = TRUE;
00957     ub2 csid    = 0;
00958     ub1 csfrm   = 0;
00959     void *obuf  = NULL;
00960 
00961     OCI_CHECK_PTR(OCI_IPC_LOB, char_count, FALSE);
00962     OCI_CHECK_PTR(OCI_IPC_LOB, byte_count, FALSE);
00963 
00964     /* OCILobWriteAppend() seems to cause problems on Oracle client 8.1 and 9.0
00965        It's an Oracle known bug #886191
00966        So we use OCI_LobSeek() + OCI_LobWrite() instead */
00967 
00968     if (OCILib.version_runtime < OCI_10_1)
00969     {
00970         return OCI_LobSeek(lob, OCI_LobGetLength(lob), OCI_SEEK_SET) &&
00971                OCI_LobWrite2(lob, buffer, char_count, byte_count);
00972     }
00973 
00974     if (lob->type != OCI_BLOB)
00975     {
00976 
00977         #ifdef OCI_USERDATA_WIDE
00978 
00979         csid = OCI_UTF16ID;
00980 
00981         #endif
00982 
00983         if (((*byte_count) == 0) && ((*char_count) > 0))
00984         {
00985             if (OCILib.nls_utf8 == TRUE)
00986             {
00987                 (*byte_count) = (unsigned int) strlen(buffer);
00988             }
00989             else
00990             {
00991                 (*byte_count) = (*char_count) * (ub4) sizeof(dtext);
00992             }
00993         }
00994 
00995         if (((*char_count) == 0) && ((*byte_count) > 0))
00996         {
00997             if (OCILib.nls_utf8 == TRUE)
00998             {
00999 
01000                 #ifndef OCI_LOB2_API_ENABLED
01001 
01002                     (*char_count) = OCI_StringUTF8Length((const char *) buffer);
01003 
01004                 #endif
01005 
01006             }
01007             else
01008             {
01009                 (*char_count) = (*byte_count) / (ub4) sizeof(dtext);
01010             }
01011         }
01012 
01013         obuf = OCI_GetInputDataString(buffer, (int *) byte_count);
01014 
01015         (*byte_count) *= sizeof(odtext);
01016     }
01017     else
01018     {
01019         obuf = buffer;
01020     }
01021 
01022     if (lob->type == OCI_NCLOB)
01023         csfrm = SQLCS_NCHAR;
01024     else
01025         csfrm = SQLCS_IMPLICIT;
01026 
01027     OCI_CHECK_MIN(lob->con, NULL, (*byte_count), 1, FALSE);
01028 
01029     #ifdef OCI_LOB2_API_ENABLED
01030 
01031     if (OCILib.use_lob_ub8)
01032     {
01033         ub8 size_in_out_char = (ub8) (*char_count);
01034         ub8 size_in_out_byte = (ub8) (*byte_count);
01035 
01036         OCI_CALL2
01037         (
01038             res, lob->con,
01039 
01040             OCILobWriteAppend2(lob->con->cxt, lob->con->err, lob->handle,
01041                                &size_in_out_byte, &size_in_out_char,
01042                                obuf, (ub8)  (*byte_count), (ub1) OCI_ONE_PIECE,
01043                                (dvoid *) NULL, NULL, csid, csfrm)
01044         )
01045 
01046             (*char_count) = (ub4) size_in_out_char;
01047         (*byte_count)     = (ub4) size_in_out_byte;
01048     }
01049 
01050     else
01051 
01052     #endif
01053 
01054     {
01055         ub4 size_in_out_char_byte = 0;
01056 
01057         if ((lob->type == OCI_BLOB) || (OCILib.nls_utf8 == TRUE))
01058             size_in_out_char_byte = (*byte_count);
01059         else
01060             size_in_out_char_byte = (*char_count);
01061 
01062         OCI_CALL2
01063         (
01064             res, lob->con,
01065 
01066             OCILobWriteAppend(lob->con->cxt, lob->con->err, lob->handle,
01067                               &size_in_out_char_byte, obuf,  (*byte_count),
01068                               (ub1) OCI_ONE_PIECE, (dvoid *) NULL, NULL, csid, csfrm)
01069         )
01070 
01071         if (lob->type == OCI_BLOB)
01072             (*byte_count) = (ub4) size_in_out_char_byte;
01073         else
01074             (*char_count) = (ub4) size_in_out_char_byte;
01075     }
01076 
01077     if (res == TRUE)
01078     {
01079         if (lob->type == OCI_BLOB)
01080         {
01081             lob->offset += (big_uint) (*byte_count);
01082         }
01083         else
01084         {
01085             lob->offset += (big_uint) (*char_count);
01086 
01087             if (OCILib.nls_utf8 == FALSE)
01088             {
01089                 OCI_ReleaseDataString(obuf);
01090             }
01091         }
01092     }
01093 
01094     OCI_RESULT(res);
01095 
01096     return res;
01097 }
01098 
01099 /* --------------------------------------------------------------------------------------------- *
01100  * OCI_LobAppend
01101  * --------------------------------------------------------------------------------------------- */
01102 
01103 unsigned int OCI_API OCI_LobAppend
01104 (
01105     OCI_Lob     *lob,
01106     void        *buffer,
01107     unsigned int len
01108 )
01109 {
01110     unsigned int char_count = 0;
01111     unsigned int byte_count = 0;
01112     unsigned int *ptr_count = NULL;
01113 
01114     if (lob != NULL)
01115     {
01116         if(lob->type == OCI_BLOB)
01117         {
01118             byte_count = len;
01119             ptr_count  = &byte_count;
01120         }
01121         else
01122         {
01123             char_count = len;
01124             ptr_count  = &char_count;
01125         }
01126     }
01127 
01128     OCI_LobAppend2(lob, buffer, &char_count, &byte_count);
01129 
01130     return (ptr_count ? *ptr_count : 0);
01131 }
01132 
01133 /* --------------------------------------------------------------------------------------------- *
01134  * OCI_LobAppendLob
01135  * --------------------------------------------------------------------------------------------- */
01136 
01137 boolean OCI_API OCI_LobAppendLob
01138 (
01139     OCI_Lob *lob,
01140     OCI_Lob *lob_src
01141 )
01142 {
01143     boolean res     = TRUE;
01144     big_uint length = 0;
01145 
01146     OCI_CHECK_PTR(OCI_IPC_LOB, lob,     FALSE);
01147     OCI_CHECK_PTR(OCI_IPC_LOB, lob_src, FALSE);
01148 
01149     /*
01150        this might cause an ORA-24805 on Oracle 8.1.x only !
01151        I couldn’t find a bug ID on Metalink, but Oracle 9i had many fixes for
01152        lobs !
01153     */
01154 
01155     OCI_CALL2
01156     (
01157         res, lob->con,
01158 
01159         OCILobAppend(lob->con->cxt, lob->con->err, lob->handle, lob_src->handle)
01160     )
01161 
01162     if (res == TRUE)
01163     {
01164         length = OCI_LobGetLength(lob);
01165 
01166         lob->offset += length;
01167     }
01168 
01169     OCI_RESULT(res);
01170 
01171     return res;
01172 }
01173 
01174 /* --------------------------------------------------------------------------------------------- *
01175  * OCI_LobIsTemporary
01176  * --------------------------------------------------------------------------------------------- */
01177 
01178 boolean OCI_API OCI_LobIsTemporary
01179 (
01180     OCI_Lob *lob
01181 )
01182 {
01183     boolean value = FALSE;
01184     boolean res   = TRUE;
01185 
01186     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
01187 
01188     OCI_CALL2
01189     (
01190         res, lob->con,
01191 
01192         OCILobIsTemporary(OCILib.env, lob->con->err, lob->handle, &value)
01193     )
01194 
01195     OCI_RESULT(res);
01196 
01197     return value;
01198 }
01199 
01200 /* --------------------------------------------------------------------------------------------- *
01201  * OCI_LobOpen
01202  * --------------------------------------------------------------------------------------------- */
01203 
01204 boolean OCI_API OCI_LobOpen
01205 (
01206     OCI_Lob     *lob,
01207     unsigned int mode
01208 )
01209 {
01210     boolean res = TRUE;
01211 
01212     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
01213 
01214     OCI_CALL2
01215     (
01216         res, lob->con,
01217 
01218         OCILobOpen(lob->con->cxt, lob->con->err, lob->handle, (ub1) mode)
01219     )
01220 
01221     OCI_RESULT(res);
01222 
01223     return res;
01224 }
01225 
01226 /* --------------------------------------------------------------------------------------------- *
01227  * OCI_LobClose
01228  * --------------------------------------------------------------------------------------------- */
01229 
01230 boolean OCI_API OCI_LobClose
01231 (
01232     OCI_Lob *lob
01233 )
01234 {
01235     boolean res = TRUE;
01236 
01237     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
01238 
01239     OCI_CALL2
01240     (
01241         res, lob->con,
01242 
01243         OCILobClose(lob->con->cxt, lob->con->err, lob->handle)
01244     )
01245 
01246     OCI_RESULT(res);
01247 
01248     return res;
01249 }
01250 
01251 /* --------------------------------------------------------------------------------------------- *
01252  * OCI_LobIsEqual
01253  * --------------------------------------------------------------------------------------------- */
01254 
01255 boolean OCI_API OCI_LobIsEqual
01256 (
01257     OCI_Lob *lob,
01258     OCI_Lob *lob2
01259 )
01260 {
01261     boolean value = FALSE;
01262     boolean res   = TRUE;
01263 
01264     OCI_CHECK_PTR(OCI_IPC_LOB, lob,FALSE);
01265     OCI_CHECK_PTR(OCI_IPC_LOB, lob2, FALSE);
01266 
01267     OCI_CALL2
01268     (
01269         res, lob->con,
01270 
01271         OCILobIsEqual(OCILib.env, lob->handle, lob2->handle, &value)
01272     )
01273 
01274     OCI_RESULT(res);
01275 
01276     return value;
01277 }
01278 
01279 /* --------------------------------------------------------------------------------------------- *
01280  * OCI_LobAssign
01281  * --------------------------------------------------------------------------------------------- */
01282 
01283 boolean OCI_API OCI_LobAssign
01284 (
01285     OCI_Lob *lob,
01286     OCI_Lob *lob_src
01287 )
01288 {
01289     boolean res = TRUE;
01290 
01291     OCI_CHECK_PTR(OCI_IPC_LOB, lob,     FALSE);
01292     OCI_CHECK_PTR(OCI_IPC_LOB, lob_src, FALSE);
01293 
01294     if (lob->hstate == OCI_OBJECT_ALLOCATED)
01295     {
01296         OCI_CALL2
01297         (
01298             res, lob->con,
01299 
01300             OCILobLocatorAssign(lob->con->cxt, lob->con->err,
01301                                 lob_src->handle, &lob->handle)
01302         )
01303     }
01304     else
01305     {
01306         OCI_CALL2
01307         (
01308             res, lob->con,
01309 
01310             OCILobAssign(OCILib.env, lob->con->err,
01311                          lob_src->handle, &lob->handle)
01312         )
01313     }
01314 
01315     OCI_RESULT(res);
01316 
01317     return res;
01318 }
01319 
01320 /* --------------------------------------------------------------------------------------------- *
01321  * OCI_LobGetMaxSize
01322  * --------------------------------------------------------------------------------------------- */
01323 
01324 big_uint OCI_API OCI_LobGetMaxSize
01325 (
01326     OCI_Lob *lob
01327 )
01328 {
01329     boolean res   = TRUE;
01330     big_uint size = 0;
01331 
01332     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
01333 
01334     #ifdef OCI_LOB2_API_ENABLED
01335 
01336     if (OCILib.use_lob_ub8)
01337     {
01338         OCI_CALL2
01339         (
01340             res, lob->con,
01341 
01342             OCILobGetStorageLimit(lob->con->cxt, lob->con->err, lob->handle,
01343                                   (ub8 *) &size)
01344         )
01345     }
01346 
01347     #endif
01348 
01349     OCI_RESULT(res);
01350 
01351     return size;
01352 }
01353 
01354 /* --------------------------------------------------------------------------------------------- *
01355  * OCI_LobFlush
01356  * --------------------------------------------------------------------------------------------- */
01357 
01358 boolean OCI_API OCI_LobFlush
01359 (
01360     OCI_Lob *lob
01361 )
01362 {
01363     boolean res = TRUE;
01364 
01365     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
01366 
01367     OCI_CALL2
01368     (
01369         res, lob->con,
01370 
01371         OCILobFlushBuffer(lob->con->cxt, lob->con->err, lob->handle, (ub4) OCI_DEFAULT)
01372     )
01373 
01374     OCI_RESULT(res);
01375 
01376     return res;
01377 }
01378 
01379 /* --------------------------------------------------------------------------------------------- *
01380  * OCI_LobEnableBuffering
01381  * --------------------------------------------------------------------------------------------- */
01382 
01383 boolean OCI_API OCI_LobEnableBuffering
01384 (
01385     OCI_Lob *lob,
01386     boolean  value
01387 )
01388 {
01389     boolean res = TRUE;
01390 
01391     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
01392 
01393     if (value == TRUE)
01394     {
01395         OCI_CALL2
01396         (
01397             res, lob->con,
01398 
01399             OCILobEnableBuffering(lob->con->cxt, lob->con->err, lob->handle)
01400         )
01401     }
01402     else
01403     {
01404         OCI_CALL2
01405         (
01406             res, lob->con,
01407 
01408             OCILobDisableBuffering(lob->con->cxt, lob->con->err, lob->handle)
01409         )
01410     }
01411 
01412     OCI_RESULT(res);
01413 
01414     return res;
01415 }
01416 

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