00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035 #include "ocilib_internal.h"
00036
00037
00038
00039
00040
00041
00042
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
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
00128
00129 if (res == FALSE)
00130 {
00131 OCI_LobFree(lob);
00132 lob = NULL;
00133 }
00134
00135 return lob;
00136 }
00137
00138
00139
00140
00141
00142
00143
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
00965
00966
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
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
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
01151
01152
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
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
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
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
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
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
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
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
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