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(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
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
00120
00121 if (res == FALSE)
00122 {
00123 OCI_LobFree(lob);
00124 lob = NULL;
00125 }
00126
00127 return lob;
00128 }
00129
00130
00131
00132
00133
00134
00135
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
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
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
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
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
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
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
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
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
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
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
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
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
00684
00685
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
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
00775
00776
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
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
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
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
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
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
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
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 }