C:/Users/vincent/Data/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    +----------------------------------------------------------------------+
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: lob.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 /* ------------------------------------------------------------------------ *
00042  * OCI_LobInit
00043  * ------------------------------------------------------------------------ */
00044 
00045  OCI_Lob * OCI_LobInit(OCI_Connection *con, OCI_Lob **plob,
00046                        OCILobLocator *handle, ub4 type)
00047 {
00048     ub2 csid      = OCI_DEFAULT;
00049     ub1 csfrm     = OCI_DEFAULT;
00050     OCI_Lob * lob = NULL;
00051     boolean res   = TRUE;
00052     ub1 lobtype   = 0;
00053 
00054     OCI_CHECK(plob == NULL, NULL);
00055 
00056     if (*plob == NULL)
00057         *plob = (OCI_Lob *) OCI_MemAlloc(OCI_IPC_LOB, sizeof(*lob), 1, TRUE);
00058 
00059     if (*plob != NULL)
00060     {
00061         lob = *plob;
00062 
00063         lob->type   = type;
00064         lob->con    = con;
00065         lob->handle = handle;
00066         lob->offset = 1;
00067 
00068         if (lob->handle == NULL)
00069         {
00070             ub4 empty = 0;
00071 
00072             /* allocate handle for non fetched lob (temporary lob) */
00073 
00074             lob->hstate = OCI_OBJECT_ALLOCATED;
00075 
00076             if (lob->type == OCI_NCLOB)
00077             {
00078                 csfrm   = SQLCS_NCHAR;
00079                 lobtype = OCI_TEMP_CLOB;
00080             }
00081             else if (lob->type == OCI_CLOB)
00082             {
00083                 csfrm   = SQLCS_IMPLICIT;
00084                 lobtype = OCI_TEMP_CLOB;
00085             }
00086             else
00087                 lobtype = OCI_TEMP_BLOB;
00088 
00089             res = (OCI_SUCCESS == OCI_DescriptorAlloc((dvoid  *) OCILib.env,
00090                                                       (dvoid **) (void *) &lob->handle,
00091                                                       (ub4) OCI_DTYPE_LOB, 
00092                                                       (size_t) 0, (dvoid **) NULL));
00093 
00094             OCI_CALL2
00095             (
00096                 res, lob->con, 
00097                 
00098                 OCIAttrSet((dvoid *) lob->handle, (ub4) OCI_DTYPE_LOB,
00099                            (dvoid *) &empty, (ub4) sizeof(empty), 
00100                            (ub4) OCI_ATTR_LOBEMPTY, lob->con->err)
00101             )
00102 
00103             OCI_CALL2
00104             (
00105                 res, lob->con, 
00106                 
00107                 OCILobCreateTemporary(lob->con->cxt, lob->con->err,
00108                                       lob->handle, csid, csfrm, lobtype,
00109                                       FALSE, OCI_DURATION_SESSION)
00110             )
00111 
00112         }
00113         else
00114             lob->hstate = OCI_OBJECT_FETCHED_CLEAN;
00115     }
00116     else
00117         res = FALSE;
00118 
00119     /* check for failure */
00120 
00121     if (res == FALSE)
00122     {
00123         OCI_LobFree(lob);
00124         lob = NULL;
00125     }
00126 
00127     return lob;
00128 }
00129 
00130 /* ************************************************************************ *
00131  *                            PUBLIC FUNCTIONS
00132  * ************************************************************************ */
00133 
00134 /* ------------------------------------------------------------------------ *
00135  * OCI_LobCreate
00136  * ------------------------------------------------------------------------ */
00137 
00138 OCI_Lob * OCI_API OCI_LobCreate(OCI_Connection *con, unsigned int type)
00139 {
00140     OCI_Lob *lob = NULL;
00141 
00142     OCI_CHECK_INITIALIZED(NULL);
00143 
00144     OCI_CHECK_PTR(OCI_IPC_CONNECTION, con, NULL);
00145 
00146     lob = OCI_LobInit(con, &lob, NULL, type);
00147 
00148     OCI_RESULT(lob != NULL);
00149 
00150     return lob;
00151 }
00152 
00153 /* ------------------------------------------------------------------------ *
00154  * OCI_LobFree
00155  * ------------------------------------------------------------------------ */
00156 
00157 boolean OCI_API OCI_LobFree(OCI_Lob *lob)
00158 {
00159     boolean res = TRUE;
00160 
00161     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00162  
00163     OCI_CHECK_OBJECT_FETCHED(lob, FALSE);
00164 
00165     if (OCI_LobIsTemporary(lob) == TRUE)
00166     {
00167         OCI_CALL2
00168         (
00169             res, lob->con, 
00170             
00171             OCILobFreeTemporary(lob->con->cxt, lob->con->err, lob->handle)
00172         )
00173     }
00174 
00175     if (lob->hstate == OCI_OBJECT_ALLOCATED)
00176     {
00177         OCI_DescriptorFree((dvoid *) lob->handle, (ub4) OCI_DTYPE_LOB);
00178     }
00179 
00180     OCI_FREE(lob);
00181 
00182     OCI_RESULT(res);
00183     
00184     return res;
00185 }
00186 
00187 /* ------------------------------------------------------------------------ *
00188  * OCI_LobGetType
00189  * ------------------------------------------------------------------------ */
00190 
00191 unsigned int OCI_API OCI_LobGetType(OCI_Lob *lob)
00192 {
00193     OCI_CHECK_PTR(OCI_IPC_LOB, lob,OCI_UNKNOWN);
00194 
00195     OCI_RESULT(TRUE);
00196 
00197     return lob->type;
00198 }
00199 
00200 /* ------------------------------------------------------------------------ *
00201  * OCI_LobSeek
00202  * ------------------------------------------------------------------------ */
00203 
00204 boolean OCI_API OCI_LobSeek(OCI_Lob *lob, big_uint offset, unsigned int mode)
00205 {
00206     boolean res   = TRUE;
00207     big_uint size = 0;
00208 
00209     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00210 
00211     size = OCI_LobGetLength(lob);
00212 
00213     if ((mode == OCI_SEEK_CUR && (offset + lob->offset-1) > size))
00214         res = FALSE;
00215     else if (mode == OCI_SEEK_SET)
00216         lob->offset  = offset + 1;
00217     else if (mode == OCI_SEEK_END)
00218         lob->offset  = size-offset + 1;
00219     else if (mode == OCI_SEEK_CUR)
00220         lob->offset += offset;
00221     else
00222         res = FALSE;
00223 
00224     OCI_RESULT(res);
00225 
00226     return res;
00227 }
00228 
00229 /* ------------------------------------------------------------------------ *
00230  * OCI_LobGetOffset
00231  * ------------------------------------------------------------------------ */
00232 
00233 big_uint OCI_API OCI_LobGetOffset(OCI_Lob *lob)
00234 {
00235     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00236 
00237     OCI_RESULT(TRUE);
00238 
00239     return lob->offset - 1;
00240 }
00241 
00242 /* ------------------------------------------------------------------------ *
00243  * OCI_LobRead
00244  * ------------------------------------------------------------------------ */
00245 
00246 unsigned int OCI_API OCI_LobRead(OCI_Lob *lob, void *buffer, unsigned int len)
00247 {
00248     boolean res  = TRUE;
00249     ub4 size_in  = 0;
00250     ub4 size_out = 0;
00251     ub2 csid     = 0;
00252     ub1 csfrm    = 0;
00253 
00254     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00255     OCI_CHECK_MIN(lob->con, NULL, len, 1, 0);
00256 
00257     size_out = size_in = len;
00258 
00259     if (lob->type != OCI_BLOB)
00260     {
00261 
00262 #ifndef OCI_CHARSET_ANSI
00263 
00264         csid = OCI_UTF16ID;
00265 
00266 #endif        
00267         
00268         size_in *= sizeof(odtext);
00269     }
00270 
00271     if (lob->type == OCI_NCLOB)
00272         csfrm = SQLCS_NCHAR;
00273     else
00274         csfrm = SQLCS_IMPLICIT;
00275 
00276 #ifdef OCI_LOB2_API_ENABLED
00277 
00278     if (OCILib.use_lob_ub8)
00279     {
00280         ub8 size_char = (ub8) len;
00281         ub8 size_byte = (ub8) size_in;
00282         
00283         OCI_CALL2
00284         (
00285             res, lob->con, 
00286             
00287             OCILobRead2(lob->con->cxt, lob->con->err,
00288                         lob->handle, &size_byte,
00289                         &size_char,  (ub8) lob->offset, 
00290                         buffer,(ub8) size_in, 
00291                         (ub1) OCI_ONE_PIECE,  (void *) NULL, 
00292                         NULL, csid, csfrm)
00293         )
00294 
00295         if (lob->type == OCI_BLOB)
00296             size_out = (ub4) size_byte;
00297         else
00298             size_out = (ub4) size_char;
00299     }
00300 
00301     else
00302 
00303 #endif
00304 
00305     {
00306         ub4 offset = (ub4) lob->offset;
00307 
00308         OCI_CALL2
00309         (
00310             res, lob->con, 
00311             
00312             OCILobRead(lob->con->cxt, lob->con->err,
00313                        lob->handle,  &size_out, offset,
00314                        buffer, size_in, (void *) NULL,
00315                        NULL, csid, csfrm)
00316         )
00317     }
00318 
00319     if (res == TRUE)
00320     {
00321         if (lob->type != OCI_BLOB)
00322             OCI_ConvertString(buffer, (int) size_out, sizeof(odtext), sizeof(dtext));
00323         
00324         lob->offset += (big_uint) size_out;
00325     }
00326 
00327     OCI_RESULT(res);
00328 
00329     return size_out;
00330 }
00331 
00332 /* ------------------------------------------------------------------------ *
00333  * OCI_LobWrite
00334  * ------------------------------------------------------------------------ */
00335 
00336 unsigned int OCI_API OCI_LobWrite(OCI_Lob *lob, void *buffer, unsigned int len)
00337 {
00338     boolean res  = TRUE;
00339     ub4 size_in  = 0;
00340     ub4 size_out = 0;
00341     ub2 csid     = 0;
00342     ub1 csfrm    = 0;
00343     void *obuf   = NULL;
00344 
00345     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00346     OCI_CHECK_MIN(lob->con, NULL, len, 1, 0);
00347 
00348     size_out = size_in = len;
00349     
00350     if (lob->type != OCI_BLOB)
00351     {
00352 
00353 #ifndef OCI_CHARSET_ANSI
00354 
00355         csid = OCI_UTF16ID;
00356 
00357 #endif
00358 
00359         size_in *= sizeof(dtext);
00360         obuf     = OCI_GetInputDataString(buffer, (int *) &size_in);
00361     }
00362     else
00363         obuf = buffer;
00364 
00365     if (lob->type == OCI_NCLOB)
00366         csfrm = SQLCS_NCHAR;
00367     else
00368         csfrm = SQLCS_IMPLICIT;
00369 
00370 #ifdef OCI_LOB2_API_ENABLED
00371 
00372     if (OCILib.use_lob_ub8)
00373     {
00374         ub8 size_char = (ub8) len;
00375         ub8 size_byte = (ub8) size_in;
00376         
00377         OCI_CALL2
00378         (
00379             res, lob->con, 
00380             
00381             OCILobWrite2(lob->con->cxt, lob->con->err, 
00382                          lob->handle, &size_byte,
00383                          &size_char, (ub8) lob->offset, 
00384                          obuf, (ub8) size_in,
00385                          (ub1) OCI_ONE_PIECE, (void *) NULL,
00386                          NULL , csid, csfrm)
00387         )
00388 
00389         if (lob->type == OCI_BLOB)
00390             size_out = (ub4) size_byte;
00391         else
00392             size_out = (ub4) size_char;
00393     }
00394 
00395     else
00396 
00397 #endif
00398 
00399     {
00400         ub4 offset = (ub4) lob->offset;
00401    
00402         OCI_CALL2
00403         (
00404             res, lob->con, 
00405             
00406             OCILobWrite(lob->con->cxt, lob->con->err,
00407                         lob->handle, &size_out,
00408                         offset, obuf, size_in, 
00409                         (ub1) OCI_ONE_PIECE, (void *) NULL, 
00410                         NULL, csid, csfrm)
00411         )
00412     }
00413 
00414     if (lob->type != OCI_BLOB)
00415         OCI_ReleaseDataString(obuf);
00416 
00417     if (res == TRUE)
00418         lob->offset += (big_uint) size_out;
00419 
00420     OCI_RESULT(res);
00421 
00422     return size_out;
00423 }
00424 
00425 /* ------------------------------------------------------------------------ *
00426  * OCI_LobTruncate
00427  * ------------------------------------------------------------------------ */
00428 
00429 boolean OCI_API OCI_LobTruncate(OCI_Lob *lob, big_uint size)
00430 {
00431     boolean res = TRUE;
00432 
00433     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00434 
00435 #ifdef OCI_LOB2_API_ENABLED
00436 
00437     if (OCILib.use_lob_ub8)
00438     {
00439          OCI_CALL2
00440          (
00441             res, lob->con, 
00442             
00443             OCILobTrim2(lob->con->cxt, lob->con->err, lob->handle, (ub8) size)
00444          )
00445     }
00446     else
00447 
00448 #endif
00449  
00450     {
00451         ub4 size32 = (ub4) size;
00452 
00453         OCI_CALL2
00454         (
00455             res, lob->con, 
00456             
00457             OCILobTrim(lob->con->cxt, lob->con->err, lob->handle, size32)
00458         )
00459     }
00460 
00461     OCI_RESULT(res);
00462 
00463     return res;
00464 }
00465 
00466 /* ------------------------------------------------------------------------ *
00467  * OCI_LobErase
00468  * ------------------------------------------------------------------------ */
00469 
00470 big_uint OCI_API OCI_LobErase(OCI_Lob *lob, big_uint offset, big_uint size)
00471 {
00472     boolean res  = TRUE;
00473 
00474     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00475     OCI_CHECK_MIN(lob->con, NULL, size, 1, 0);
00476 
00477  #ifdef OCI_LOB2_API_ENABLED
00478 
00479     if (OCILib.use_lob_ub8)
00480     {
00481         OCI_CALL2
00482         (
00483             res, lob->con, 
00484             
00485             OCILobErase2(lob->con->cxt, lob->con->err, lob->handle, 
00486                          (ub8 *) &size, (ub8) (offset + 1))
00487          )
00488     }
00489     else
00490 
00491 #endif
00492  
00493     {
00494         ub4 size32   = (ub4) size;
00495         ub4 offset32 = (ub4) offset;
00496 
00497         OCI_CALL2
00498         (
00499             res, lob->con, 
00500             
00501             OCILobErase(lob->con->cxt, lob->con->err, lob->handle, 
00502                         &size32, offset32 + 1)
00503         )
00504 
00505         size = (big_uint) size32;
00506     }
00507                             
00508     OCI_RESULT(res);
00509 
00510     return size;
00511 }
00512 
00513 /* ------------------------------------------------------------------------ *
00514  * OCI_LobGetLength
00515  * ------------------------------------------------------------------------ */
00516 
00517 big_uint OCI_API OCI_LobGetLength(OCI_Lob *lob)
00518 {
00519     boolean res   = TRUE;
00520     big_uint size = 0;
00521 
00522     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00523  
00524 #ifdef OCI_LOB2_API_ENABLED
00525 
00526     if (OCILib.use_lob_ub8)
00527     {
00528         OCI_CALL2
00529         (
00530             res, lob->con, 
00531             
00532             OCILobGetLength2(lob->con->cxt, lob->con->err, lob->handle, 
00533                              (ub8 *) &size)
00534         )
00535     }
00536     else
00537 
00538 #endif
00539  
00540     {
00541         ub4 size32 = (ub4) size;
00542    
00543         OCI_CALL2
00544         (
00545             res, lob->con, 
00546             
00547             OCILobGetLength(lob->con->cxt, lob->con->err, lob->handle, &size32)
00548         )
00549 
00550         size = (big_uint) size32;
00551     }
00552 
00553     OCI_RESULT(res);
00554 
00555     return size;
00556 }
00557 
00558 /* ------------------------------------------------------------------------ *
00559  * OCI_LobCopy
00560  * ------------------------------------------------------------------------ */
00561 
00562 boolean OCI_API OCI_LobCopy(OCI_Lob *lob, OCI_Lob *lob_src, big_uint offset_dst,
00563                             big_uint offset_src, big_uint count)
00564 {
00565     boolean res = TRUE;
00566 
00567     OCI_CHECK_PTR(OCI_IPC_LOB, lob,     FALSE);
00568     OCI_CHECK_PTR(OCI_IPC_LOB, lob_src, FALSE);
00569 
00570 #ifdef OCI_LOB2_API_ENABLED
00571 
00572     if (OCILib.use_lob_ub8)
00573     {
00574  
00575         OCI_CALL2
00576         (
00577             res, lob->con, 
00578             
00579             OCILobCopy2(lob->con->cxt, lob->con->err, lob->handle,
00580                        lob_src->handle, (ub8) count, 
00581                        (ub8) (offset_dst + 1), 
00582                        (ub8) (offset_src + 1))
00583         )
00584     }
00585     else
00586 
00587 #endif
00588  
00589     {
00590        ub4 count32      = (ub4) count;
00591        ub4 offset_src32 = (ub4) offset_src;
00592        ub4 offset_dst32 = (ub4) offset_dst;
00593 
00594 
00595         OCI_CALL2
00596         (
00597             res, lob->con, 
00598             
00599             OCILobCopy(lob->con->cxt, lob->con->err, lob->handle,
00600                        lob_src->handle, count32, offset_dst32 + 1,
00601                        offset_src32 + 1)
00602          )
00603     }
00604     
00605     OCI_RESULT(res);
00606 
00607     return res;
00608 }
00609 
00610 /* ------------------------------------------------------------------------ *
00611  * OCI_LobCopyFromFile
00612  * ------------------------------------------------------------------------ */
00613 
00614 boolean OCI_API OCI_LobCopyFromFile(OCI_Lob *lob, OCI_File *file,
00615                                     big_uint offset_dst,
00616                                     big_uint offset_src,
00617                                     big_uint count)
00618 {
00619     boolean res  = TRUE;
00620 
00621     OCI_CHECK_PTR(OCI_IPC_LOB, lob,   FALSE);
00622     OCI_CHECK_PTR(OCI_IPC_FILE, file, FALSE);
00623 
00624 #ifdef OCI_LOB2_API_ENABLED
00625 
00626     if (OCILib.use_lob_ub8)
00627     {
00628         OCI_CALL2
00629         (
00630             res, lob->con, 
00631             
00632             OCILobLoadFromFile2(lob->con->cxt, lob->con->err,
00633                                 lob->handle, file->handle,
00634                                 (ub8) count,
00635                                 (ub8) (offset_dst + 1),
00636                                 (ub8) (offset_src + 1))
00637         )
00638     }
00639     else
00640 
00641 #endif
00642  
00643     {
00644         ub4 count32      = (ub4) count;
00645         ub4 offset_src32 = (ub4) offset_src;
00646         ub4 offset_dst32 = (ub4) offset_dst;
00647 
00648         OCI_CALL2
00649         (
00650             res, lob->con, 
00651             
00652             OCILobLoadFromFile(lob->con->cxt, lob->con->err,
00653                                lob->handle, file->handle, count32,
00654                                offset_dst32 + 1, offset_src32 + 1)
00655         )
00656     }
00657 
00658     OCI_RESULT(res);
00659 
00660     return res;
00661 }
00662 
00663 /* ------------------------------------------------------------------------ *
00664  * OCI_LobAppend
00665  * ------------------------------------------------------------------------ */
00666 
00667 unsigned int OCI_API OCI_LobAppend(OCI_Lob *lob, void *buffer, unsigned int len)
00668 { 
00669     ub4 size_in  = 0;
00670     ub4 size_out = 0;
00671     ub2 csid     = 0;
00672     ub1 csfrm    = 0;
00673     void *obuf   = NULL;
00674     boolean res  = TRUE;
00675 
00676     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00677     OCI_CHECK_MIN(lob->con, NULL, len, 1, 0);
00678 
00679 #ifndef OCI_CHARSET_ANSI
00680     csid = OCI_UTF16ID;
00681 #endif
00682 
00683     /* OCILobWriteAppend() seems to cause problems on Oracle client 8.1 and 9.0 
00684        It's an Oracle known bug #886191
00685        So we use OCI_LobSeek() + OCI_LobWrite() instead */
00686 
00687     if (OCILib.version_runtime < OCI_10_1)
00688     {
00689        return OCI_LobSeek(lob, OCI_LobGetLength(lob), OCI_SEEK_SET) &&
00690               OCI_LobWrite(lob, buffer, len);
00691     }        
00692 
00693     size_out = size_in = len;
00694     
00695     if (lob->type != OCI_BLOB)
00696     {
00697         size_in *= sizeof(dtext);
00698         obuf  = OCI_GetInputDataString(buffer, (int *) &size_in);
00699     }
00700     else
00701        obuf = buffer;
00702 
00703     if (lob->type == OCI_NCLOB)
00704         csfrm = SQLCS_NCHAR;
00705     else
00706         csfrm = SQLCS_IMPLICIT;
00707 
00708 #ifdef OCI_LOB2_API_ENABLED
00709 
00710     if (OCILib.use_lob_ub8)
00711     {
00712         ub8 size_char = (ub8) len;
00713         ub8 size_byte = (ub8) size_in;
00714         
00715         OCI_CALL2
00716         (
00717             res, lob->con, 
00718             
00719             OCILobWriteAppend2(lob->con->cxt, lob->con->err, 
00720                                lob->handle, &size_byte,
00721                                &size_char, obuf, (ub8) size_in, 
00722                                (ub1) OCI_ONE_PIECE, 
00723                                (dvoid *) NULL,
00724                                NULL, csid, csfrm)
00725         )
00726 
00727         if (lob->type == OCI_BLOB)
00728             size_out = (ub4) size_byte;
00729         else
00730             size_out = (ub4) size_char;
00731     }
00732 
00733     else
00734 
00735 #endif
00736 
00737     {
00738         OCI_CALL2
00739         (
00740             res, lob->con, 
00741             
00742             OCILobWriteAppend(lob->con->cxt, lob->con->err,
00743                               lob->handle, &size_out,
00744                               obuf, size_in, 
00745                               (ub1) OCI_ONE_PIECE,
00746                               (dvoid *) NULL,
00747                               NULL, csid, csfrm)
00748         )
00749     }
00750 
00751     if (lob->type != OCI_BLOB)
00752         OCI_ReleaseDataString(obuf);
00753 
00754     if (res == TRUE)
00755         lob->offset += (big_uint) size_out;
00756 
00757     OCI_RESULT(res);
00758 
00759     return size_out;
00760 }
00761 
00762 /* ------------------------------------------------------------------------ *
00763  * OCI_LobAppendLob
00764  * ------------------------------------------------------------------------ */
00765 
00766 boolean OCI_API OCI_LobAppendLob(OCI_Lob *lob, OCI_Lob *lob_src)
00767 {
00768     boolean res  = TRUE;
00769 
00770     OCI_CHECK_PTR(OCI_IPC_LOB, lob,     FALSE);
00771     OCI_CHECK_PTR(OCI_IPC_LOB, lob_src, FALSE);
00772 
00773     /* 
00774        this might cause an ORA-24805 on Oracle 8.1.x only !
00775        I couldn’t find a bug ID on Metalink, but Oracle 9i had many fixes for
00776        lobs ! 
00777     */
00778 
00779     OCI_CALL2
00780     (
00781         res, lob->con, 
00782         
00783         OCILobAppend(lob->con->cxt, lob->con->err, lob->handle, lob_src->handle)
00784     )
00785 
00786     if (res == TRUE)
00787         lob->offset = OCI_LobGetLength(lob);
00788 
00789     OCI_RESULT(res);
00790 
00791     return res;
00792 }
00793 
00794 /* ------------------------------------------------------------------------ *
00795  * OCI_LobIsTemporary
00796  * ------------------------------------------------------------------------ */
00797 
00798 boolean OCI_API OCI_LobIsTemporary(OCI_Lob *lob)
00799 {
00800     boolean value = FALSE;
00801     boolean res   = TRUE;
00802 
00803     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00804 
00805     OCI_CALL2
00806     (
00807         res, lob->con, 
00808         
00809         OCILobIsTemporary(OCILib.env, lob->con->err, lob->handle, &value)
00810     )
00811 
00812     OCI_RESULT(res);
00813 
00814     return value;
00815 }
00816 
00817 /* ------------------------------------------------------------------------ *
00818  * OCI_LobOpen
00819  * ------------------------------------------------------------------------ */
00820 
00821 boolean OCI_API OCI_LobOpen(OCI_Lob *lob, unsigned int mode)
00822 {
00823     boolean res = TRUE;
00824 
00825     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00826 
00827     OCI_CALL2
00828     (
00829         res, lob->con, 
00830         
00831         OCILobOpen(lob->con->cxt, lob->con->err, lob->handle, (ub1) mode)
00832     )
00833 
00834     OCI_RESULT(res);
00835 
00836     return res;
00837 }
00838 
00839 /* ------------------------------------------------------------------------ *
00840  * OCI_LobClose
00841  * ------------------------------------------------------------------------ */
00842 
00843 boolean OCI_API OCI_LobClose(OCI_Lob *lob)
00844 {
00845     boolean res = TRUE;
00846 
00847     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00848 
00849     OCI_CALL2
00850     (
00851         res, lob->con, 
00852         
00853         OCILobClose(lob->con->cxt, lob->con->err, lob->handle)
00854     )
00855     
00856     OCI_RESULT(res);
00857 
00858     return res;
00859 }
00860 
00861 /* ------------------------------------------------------------------------ *
00862  * OCI_LobIsEqual
00863  * ------------------------------------------------------------------------ */
00864 
00865 boolean OCI_API OCI_LobIsEqual(OCI_Lob *lob, OCI_Lob *lob2)
00866 {
00867     boolean value = FALSE;
00868     boolean res   = TRUE;
00869 
00870     OCI_CHECK_PTR(OCI_IPC_LOB, lob,FALSE);
00871     OCI_CHECK_PTR(OCI_IPC_LOB, lob2, FALSE);
00872 
00873     OCI_CALL2
00874     (
00875         res, lob->con, 
00876         
00877         OCILobIsEqual(OCILib.env, lob->handle, lob2->handle, &value)
00878     )
00879 
00880     OCI_RESULT(res);
00881 
00882     return value;
00883 }
00884 
00885 /* ------------------------------------------------------------------------ *
00886  * OCI_LobAssign
00887  * ------------------------------------------------------------------------ */
00888 
00889 boolean OCI_API OCI_LobAssign(OCI_Lob *lob, OCI_Lob *lob_src)
00890 {
00891     boolean res   = TRUE;
00892 
00893     OCI_CHECK_PTR(OCI_IPC_LOB, lob,     FALSE);
00894     OCI_CHECK_PTR(OCI_IPC_LOB, lob_src, FALSE);
00895 
00896     if (lob->hstate == OCI_OBJECT_ALLOCATED)
00897     {
00898         OCI_CALL2
00899         (
00900             res, lob->con, 
00901             
00902             OCILobLocatorAssign(lob->con->cxt, lob->con->err,
00903                                 lob_src->handle, &lob->handle)
00904         )
00905   
00906     }
00907     else
00908     {
00909         OCI_CALL2
00910         (
00911             res, lob->con, 
00912             
00913             OCILobAssign(OCILib.env, lob->con->err,
00914                          lob_src->handle, &lob->handle)
00915         )
00916     }
00917 
00918     OCI_RESULT(res);
00919 
00920     return res;
00921 }
00922 
00923 /* ------------------------------------------------------------------------ *
00924  * OCI_LobGetMaxSize
00925  * ------------------------------------------------------------------------ */
00926 
00927 big_uint OCI_API OCI_LobGetMaxSize(OCI_Lob *lob)
00928 {
00929     boolean res   = TRUE;
00930     big_uint size = 0;
00931 
00932     OCI_CHECK_PTR(OCI_IPC_LOB, lob, 0);
00933 
00934 #if OCI_VERSION_COMPILE >= OCI_10_1
00935 
00936     OCI_CALL2
00937     (
00938         res, lob->con, 
00939         
00940         OCILobGetStorageLimit(lob->con->cxt, lob->con->err, lob->handle, (ub8 *) &size)
00941     )
00942 
00943 #endif 
00944 
00945     OCI_RESULT(res);
00946 
00947     return size;
00948 }
00949 
00950 /* ------------------------------------------------------------------------ *
00951  * OCI_LobFlush
00952  * ------------------------------------------------------------------------ */
00953 
00954 boolean OCI_API OCI_LobFlush(OCI_Lob *lob)
00955 {
00956     boolean res   = TRUE;
00957 
00958     OCI_CHECK_PTR(OCI_IPC_LOB, lob, FALSE);
00959 
00960     OCI_CALL2
00961     (
00962         res, lob->con, 
00963         
00964         OCILobFlushBuffer(lob->con->cxt, lob->con->err, lob->handle, (ub4) OCI_DEFAULT)
00965     )
00966 
00967     OCI_RESULT(res);
00968 
00969     return res;
00970 }

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