ExternalLobVar.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653
  1. //-----------------------------------------------------------------------------
  2. // ExternalLobVar.c
  3. // Defines the routines for handling LOB variables external to this module.
  4. //-----------------------------------------------------------------------------
  5. //-----------------------------------------------------------------------------
  6. // external LOB type
  7. //-----------------------------------------------------------------------------
  8. typedef struct {
  9. PyObject_HEAD
  10. udt_LobVar *lobVar;
  11. unsigned pos;
  12. unsigned internalFetchNum;
  13. } udt_ExternalLobVar;
  14. //-----------------------------------------------------------------------------
  15. // Declaration of external LOB variable functions.
  16. //-----------------------------------------------------------------------------
  17. static void ExternalLobVar_Free(udt_ExternalLobVar*);
  18. static PyObject *ExternalLobVar_Str(udt_ExternalLobVar*);
  19. static PyObject *ExternalLobVar_Size(udt_ExternalLobVar*, PyObject*);
  20. static PyObject *ExternalLobVar_Open(udt_ExternalLobVar*, PyObject*);
  21. static PyObject *ExternalLobVar_Close(udt_ExternalLobVar*, PyObject*);
  22. static PyObject *ExternalLobVar_Read(udt_ExternalLobVar*, PyObject*,
  23. PyObject*);
  24. static PyObject *ExternalLobVar_Write(udt_ExternalLobVar*, PyObject*,
  25. PyObject*);
  26. static PyObject *ExternalLobVar_Trim(udt_ExternalLobVar*, PyObject*,
  27. PyObject*);
  28. static PyObject *ExternalLobVar_GetChunkSize(udt_ExternalLobVar*, PyObject*);
  29. static PyObject *ExternalLobVar_IsOpen(udt_ExternalLobVar*, PyObject*);
  30. static PyObject *ExternalLobVar_GetFileName(udt_ExternalLobVar*, PyObject*);
  31. static PyObject *ExternalLobVar_SetFileName(udt_ExternalLobVar*, PyObject*);
  32. static PyObject *ExternalLobVar_FileExists(udt_ExternalLobVar*, PyObject*);
  33. static PyObject *ExternalLobVar_Reduce(udt_ExternalLobVar*);
  34. //-----------------------------------------------------------------------------
  35. // declaration of methods for Python type "ExternalLOBVar"
  36. //-----------------------------------------------------------------------------
  37. static PyMethodDef g_ExternalLobVarMethods[] = {
  38. { "size", (PyCFunction) ExternalLobVar_Size, METH_NOARGS },
  39. { "open", (PyCFunction) ExternalLobVar_Open, METH_NOARGS },
  40. { "close", (PyCFunction) ExternalLobVar_Close, METH_NOARGS },
  41. { "read", (PyCFunction) ExternalLobVar_Read,
  42. METH_VARARGS | METH_KEYWORDS },
  43. { "write", (PyCFunction) ExternalLobVar_Write,
  44. METH_VARARGS | METH_KEYWORDS },
  45. { "trim", (PyCFunction) ExternalLobVar_Trim,
  46. METH_VARARGS | METH_KEYWORDS },
  47. { "getchunksize", (PyCFunction) ExternalLobVar_GetChunkSize, METH_NOARGS },
  48. { "isopen", (PyCFunction) ExternalLobVar_IsOpen, METH_NOARGS },
  49. { "getfilename", (PyCFunction) ExternalLobVar_GetFileName, METH_NOARGS },
  50. { "setfilename", (PyCFunction) ExternalLobVar_SetFileName, METH_VARARGS },
  51. { "fileexists", (PyCFunction) ExternalLobVar_FileExists, METH_NOARGS },
  52. { "__reduce__", (PyCFunction) ExternalLobVar_Reduce, METH_NOARGS },
  53. { NULL, NULL }
  54. };
  55. //-----------------------------------------------------------------------------
  56. // Python type declaration
  57. //-----------------------------------------------------------------------------
  58. static PyTypeObject g_ExternalLobVarType = {
  59. PyVarObject_HEAD_INIT(NULL, 0)
  60. "cx_Oracle.LOB", // tp_name
  61. sizeof(udt_ExternalLobVar), // tp_basicsize
  62. 0, // tp_itemsize
  63. (destructor) ExternalLobVar_Free, // tp_dealloc
  64. 0, // tp_print
  65. 0, // tp_getattr
  66. 0, // tp_setattr
  67. 0, // tp_compare
  68. 0, // tp_repr
  69. 0, // tp_as_number
  70. 0, // tp_as_sequence
  71. 0, // tp_as_mapping
  72. 0, // tp_hash
  73. 0, // tp_call
  74. (reprfunc) ExternalLobVar_Str, // tp_str
  75. 0, // tp_getattro
  76. 0, // tp_setattro
  77. 0, // tp_as_buffer
  78. Py_TPFLAGS_DEFAULT, // tp_flags
  79. 0, // tp_doc
  80. 0, // tp_traverse
  81. 0, // tp_clear
  82. 0, // tp_richcompare
  83. 0, // tp_weaklistoffset
  84. 0, // tp_iter
  85. 0, // tp_iternext
  86. g_ExternalLobVarMethods, // tp_methods
  87. 0, // tp_members
  88. 0, // tp_getset
  89. 0, // tp_base
  90. 0, // tp_dict
  91. 0, // tp_descr_get
  92. 0, // tp_descr_set
  93. 0, // tp_dictoffset
  94. 0, // tp_init
  95. 0, // tp_alloc
  96. 0, // tp_new
  97. 0, // tp_free
  98. 0, // tp_is_gc
  99. 0 // tp_bases
  100. };
  101. //-----------------------------------------------------------------------------
  102. // ExternalLobVar_New()
  103. // Create a new external LOB variable.
  104. //-----------------------------------------------------------------------------
  105. PyObject *ExternalLobVar_New(
  106. udt_LobVar *var, // variable to encapsulate
  107. unsigned pos) // position in array to encapsulate
  108. {
  109. udt_ExternalLobVar *self;
  110. self = (udt_ExternalLobVar*)
  111. g_ExternalLobVarType.tp_alloc(&g_ExternalLobVarType, 0);
  112. if (!self)
  113. return NULL;
  114. self->pos = pos;
  115. self->internalFetchNum = var->internalFetchNum;
  116. Py_INCREF(var);
  117. self->lobVar = var;
  118. return (PyObject*) self;
  119. }
  120. //-----------------------------------------------------------------------------
  121. // ExternalLobVar_Free()
  122. // Free an external LOB variable.
  123. //-----------------------------------------------------------------------------
  124. static void ExternalLobVar_Free(
  125. udt_ExternalLobVar *self) // variable to free
  126. {
  127. Py_CLEAR(self->lobVar);
  128. Py_TYPE(self)->tp_free((PyObject*) self);
  129. }
  130. //-----------------------------------------------------------------------------
  131. // ExternalLobVar_Verify()
  132. // Verify that the external LOB var is still valid.
  133. //-----------------------------------------------------------------------------
  134. static int ExternalLobVar_Verify(
  135. udt_ExternalLobVar *var) // variable to verify
  136. {
  137. if (var->internalFetchNum != var->lobVar->internalFetchNum) {
  138. PyErr_SetString(g_ProgrammingErrorException,
  139. "LOB variable no longer valid after subsequent fetch");
  140. return -1;
  141. }
  142. return 0;
  143. }
  144. //-----------------------------------------------------------------------------
  145. // ExternalLobVar_InternalRead()
  146. // Return the size of the LOB variable for internal comsumption.
  147. //-----------------------------------------------------------------------------
  148. static int ExternalLobVar_InternalRead(
  149. udt_ExternalLobVar *var, // variable to return the size of
  150. char *buffer, // buffer in which to put data
  151. ub4 bufferSize, // size of buffer
  152. ub4 *length, // length of data (IN/OUT)
  153. int offset) // offset
  154. {
  155. ub2 charsetId;
  156. sword status;
  157. if (var->lobVar->isFile) {
  158. Py_BEGIN_ALLOW_THREADS
  159. status = OCILobFileOpen(var->lobVar->connection->handle,
  160. var->lobVar->environment->errorHandle,
  161. var->lobVar->data[var->pos], OCI_FILE_READONLY);
  162. Py_END_ALLOW_THREADS
  163. if (Environment_CheckForError(var->lobVar->environment, status,
  164. "ExternalLobVar_FileOpen()") < 0)
  165. return -1;
  166. }
  167. Py_BEGIN_ALLOW_THREADS
  168. if (var->lobVar->type == &vt_NCLOB)
  169. charsetId = OCI_UTF16ID;
  170. else charsetId = 0;
  171. status = OCILobRead(var->lobVar->connection->handle,
  172. var->lobVar->environment->errorHandle,
  173. var->lobVar->data[var->pos], length, offset, buffer,
  174. bufferSize, NULL, NULL, charsetId, var->lobVar->type->charsetForm);
  175. Py_END_ALLOW_THREADS
  176. if (Environment_CheckForError(var->lobVar->environment, status,
  177. "ExternalLobVar_LobRead()") < 0) {
  178. OCILobFileClose(var->lobVar->connection->handle,
  179. var->lobVar->environment->errorHandle,
  180. var->lobVar->data[var->pos]);
  181. return -1;
  182. }
  183. if (var->lobVar->isFile) {
  184. Py_BEGIN_ALLOW_THREADS
  185. status = OCILobFileClose(var->lobVar->connection->handle,
  186. var->lobVar->environment->errorHandle,
  187. var->lobVar->data[var->pos]);
  188. Py_END_ALLOW_THREADS
  189. if (Environment_CheckForError(var->lobVar->environment, status,
  190. "ExternalLobVar_FileClose()") < 0)
  191. return -1;
  192. }
  193. return 0;
  194. }
  195. //-----------------------------------------------------------------------------
  196. // ExternalLobVar_InternalSize()
  197. // Return the size of the LOB variable for internal comsumption.
  198. //-----------------------------------------------------------------------------
  199. static int ExternalLobVar_InternalSize(
  200. udt_ExternalLobVar *var) // variable to return the size of
  201. {
  202. sword status;
  203. ub4 length;
  204. Py_BEGIN_ALLOW_THREADS
  205. status = OCILobGetLength(var->lobVar->connection->handle,
  206. var->lobVar->environment->errorHandle,
  207. var->lobVar->data[var->pos], &length);
  208. Py_END_ALLOW_THREADS
  209. if (Environment_CheckForError(var->lobVar->environment, status,
  210. "ExternalLobVar_InternalSize()") < 0)
  211. return -1;
  212. return length;
  213. }
  214. //-----------------------------------------------------------------------------
  215. // ExternalLobVar_Value()
  216. // Return a portion (or all) of the data in the external LOB variable.
  217. //-----------------------------------------------------------------------------
  218. static PyObject *ExternalLobVar_Value(
  219. udt_ExternalLobVar *var, // variable to return the size of
  220. int offset, // offset into LOB
  221. int amount) // amount to read from LOB
  222. {
  223. ub4 length, bufferSize;
  224. PyObject *result;
  225. char *buffer;
  226. // modify the arguments
  227. if (offset < 0)
  228. offset = 1;
  229. if (amount < 0) {
  230. amount = ExternalLobVar_InternalSize(var);
  231. if (amount < 0)
  232. return NULL;
  233. amount = amount - offset + 1;
  234. if (amount <= 0)
  235. amount = 1;
  236. }
  237. length = amount;
  238. if (var->lobVar->type == &vt_CLOB)
  239. bufferSize = amount * var->lobVar->environment->maxBytesPerCharacter;
  240. else if (var->lobVar->type == &vt_NCLOB)
  241. bufferSize = amount * 2;
  242. else bufferSize = amount;
  243. // create a string for retrieving the value
  244. buffer = (char*) PyMem_Malloc(bufferSize);
  245. if (!buffer)
  246. return PyErr_NoMemory();
  247. if (ExternalLobVar_InternalRead(var, buffer, bufferSize, &length,
  248. offset) < 0) {
  249. PyMem_Free(buffer);
  250. return NULL;
  251. }
  252. // return the result
  253. if (var->lobVar->type == &vt_CLOB) {
  254. if (var->lobVar->environment->fixedWidth)
  255. length = length * var->lobVar->environment->maxBytesPerCharacter;
  256. result = cxString_FromEncodedString(buffer, length,
  257. var->lobVar->environment->encoding);
  258. } else if (var->lobVar->type == &vt_NCLOB) {
  259. result = PyUnicode_DecodeUTF16(buffer, length * 2, NULL, NULL);
  260. } else {
  261. result = PyBytes_FromStringAndSize(buffer, length);
  262. }
  263. PyMem_Free(buffer);
  264. return result;
  265. }
  266. //-----------------------------------------------------------------------------
  267. // ExternalLobVar_Size()
  268. // Return the size of the data in the LOB variable.
  269. //-----------------------------------------------------------------------------
  270. static PyObject *ExternalLobVar_Size(
  271. udt_ExternalLobVar *var, // variable to return the size of
  272. PyObject *args) // arguments
  273. {
  274. int length;
  275. if (ExternalLobVar_Verify(var) < 0)
  276. return NULL;
  277. length = ExternalLobVar_InternalSize(var);
  278. if (length < 0)
  279. return NULL;
  280. return PyInt_FromLong(length);
  281. }
  282. //-----------------------------------------------------------------------------
  283. // ExternalLobVar_Open()
  284. // Open the LOB to speed further accesses.
  285. //-----------------------------------------------------------------------------
  286. static PyObject *ExternalLobVar_Open(
  287. udt_ExternalLobVar *var, // variable to return the size of
  288. PyObject *args) // arguments
  289. {
  290. sword status;
  291. if (ExternalLobVar_Verify(var) < 0)
  292. return NULL;
  293. Py_BEGIN_ALLOW_THREADS
  294. status = OCILobOpen(var->lobVar->connection->handle,
  295. var->lobVar->environment->errorHandle,
  296. var->lobVar->data[var->pos], OCI_LOB_READWRITE);
  297. Py_END_ALLOW_THREADS
  298. if (Environment_CheckForError(var->lobVar->environment, status,
  299. "ExternalLobVar_Open()") < 0)
  300. return NULL;
  301. Py_INCREF(Py_None);
  302. return Py_None;
  303. }
  304. //-----------------------------------------------------------------------------
  305. // ExternalLobVar_Close()
  306. // Close the LOB.
  307. //-----------------------------------------------------------------------------
  308. static PyObject *ExternalLobVar_Close(
  309. udt_ExternalLobVar *var, // variable to return the size of
  310. PyObject *args) // arguments
  311. {
  312. sword status;
  313. if (ExternalLobVar_Verify(var) < 0)
  314. return NULL;
  315. Py_BEGIN_ALLOW_THREADS
  316. status = OCILobClose(var->lobVar->connection->handle,
  317. var->lobVar->environment->errorHandle,
  318. var->lobVar->data[var->pos]);
  319. Py_END_ALLOW_THREADS
  320. if (Environment_CheckForError(var->lobVar->environment, status,
  321. "ExternalLobVar_Close()") < 0)
  322. return NULL;
  323. Py_INCREF(Py_None);
  324. return Py_None;
  325. }
  326. //-----------------------------------------------------------------------------
  327. // ExternalLobVar_Read()
  328. // Return a portion (or all) of the data in the external LOB variable.
  329. //-----------------------------------------------------------------------------
  330. static PyObject *ExternalLobVar_Read(
  331. udt_ExternalLobVar *var, // variable to return the size of
  332. PyObject *args, // arguments
  333. PyObject *keywordArgs) // keyword arguments
  334. {
  335. static char *keywordList[] = { "offset", "amount", NULL };
  336. int offset, amount;
  337. // offset and amount are expected, both optional
  338. offset = amount = -1;
  339. if (!PyArg_ParseTupleAndKeywords(args, keywordArgs, "|ii", keywordList,
  340. &offset, &amount))
  341. return NULL;
  342. if (ExternalLobVar_Verify(var) < 0)
  343. return NULL;
  344. return ExternalLobVar_Value(var, offset, amount);
  345. }
  346. //-----------------------------------------------------------------------------
  347. // ExternalLobVar_Str()
  348. // Return all of the data in the external LOB variable.
  349. //-----------------------------------------------------------------------------
  350. static PyObject *ExternalLobVar_Str(
  351. udt_ExternalLobVar *var) // variable to return the string for
  352. {
  353. if (ExternalLobVar_Verify(var) < 0)
  354. return NULL;
  355. return ExternalLobVar_Value(var, 1, -1);
  356. }
  357. //-----------------------------------------------------------------------------
  358. // ExternalLobVar_Write()
  359. // Write a value to the LOB variable; return the number of bytes written.
  360. //-----------------------------------------------------------------------------
  361. static PyObject *ExternalLobVar_Write(
  362. udt_ExternalLobVar *var, // variable to perform write against
  363. PyObject *args, // arguments
  364. PyObject *keywordArgs) // keyword arguments
  365. {
  366. static char *keywordList[] = { "data", "offset", NULL };
  367. PyObject *dataObj;
  368. ub4 amount;
  369. int offset;
  370. // buffer and offset are expected, offset is optional
  371. offset = -1;
  372. if (!PyArg_ParseTupleAndKeywords(args, keywordArgs, "O|i", keywordList,
  373. &dataObj, &offset))
  374. return NULL;
  375. if (offset < 0)
  376. offset = 1;
  377. // perform the write, if possible
  378. if (ExternalLobVar_Verify(var) < 0)
  379. return NULL;
  380. if (LobVar_Write(var->lobVar, var->pos, dataObj, offset, &amount) < 0)
  381. return NULL;
  382. // return the result
  383. return PyInt_FromLong(amount);
  384. }
  385. //-----------------------------------------------------------------------------
  386. // ExternalLobVar_Trim()
  387. // Trim the LOB variable to the specified length.
  388. //-----------------------------------------------------------------------------
  389. static PyObject *ExternalLobVar_Trim(
  390. udt_ExternalLobVar *var, // variable to perform write against
  391. PyObject *args, // arguments
  392. PyObject *keywordArgs) // keyword arguments
  393. {
  394. static char *keywordList[] = { "newSize", NULL };
  395. sword status;
  396. ub4 newSize;
  397. // buffer and offset are expected, offset is optional
  398. newSize = 0;
  399. if (!PyArg_ParseTupleAndKeywords(args, keywordArgs, "|i", keywordList,
  400. &newSize))
  401. return NULL;
  402. // create a string for retrieving the value
  403. if (ExternalLobVar_Verify(var) < 0)
  404. return NULL;
  405. Py_BEGIN_ALLOW_THREADS
  406. status = OCILobTrim(var->lobVar->connection->handle,
  407. var->lobVar->environment->errorHandle, var->lobVar->data[var->pos],
  408. newSize);
  409. Py_END_ALLOW_THREADS
  410. if (Environment_CheckForError(var->lobVar->environment, status,
  411. "ExternalLobVar_Trim()") < 0)
  412. return NULL;
  413. // return the result
  414. Py_INCREF(Py_None);
  415. return Py_None;
  416. }
  417. //-----------------------------------------------------------------------------
  418. // ExternalLobVar_Reduce()
  419. // Method provided for pickling/unpickling of LOB variables.
  420. //-----------------------------------------------------------------------------
  421. static PyObject *ExternalLobVar_Reduce(
  422. udt_ExternalLobVar *self) // variable to dump
  423. {
  424. PyObject *result, *value;
  425. value = ExternalLobVar_Str(self);
  426. if (!value)
  427. return NULL;
  428. result = Py_BuildValue("(O(O))", Py_TYPE(value), value);
  429. Py_DECREF(value);
  430. return result;
  431. }
  432. //-----------------------------------------------------------------------------
  433. // ExternalLobVar_GetChunkSize()
  434. // Return the chunk size that should be used when reading/writing the LOB in
  435. // chunks.
  436. //-----------------------------------------------------------------------------
  437. static PyObject *ExternalLobVar_GetChunkSize(
  438. udt_ExternalLobVar *var, // variable to get chunk size for
  439. PyObject *args) // arguments
  440. {
  441. ub4 chunkSize;
  442. sword status;
  443. if (ExternalLobVar_Verify(var) < 0)
  444. return NULL;
  445. status = OCILobGetChunkSize(var->lobVar->connection->handle,
  446. var->lobVar->environment->errorHandle, var->lobVar->data[var->pos],
  447. &chunkSize);
  448. if (Environment_CheckForError(var->lobVar->environment, status,
  449. "ExternalLobVar_GetChunkSize()") < 0)
  450. return NULL;
  451. return PyInt_FromLong(chunkSize);
  452. }
  453. //-----------------------------------------------------------------------------
  454. // ExternalLobVar_IsOpen()
  455. // Return a boolean indicating if the lob is open or not.
  456. //-----------------------------------------------------------------------------
  457. static PyObject *ExternalLobVar_IsOpen(
  458. udt_ExternalLobVar *var, // variable to get chunk size for
  459. PyObject *args) // arguments
  460. {
  461. boolean isOpen;
  462. sword status;
  463. if (ExternalLobVar_Verify(var) < 0)
  464. return NULL;
  465. Py_BEGIN_ALLOW_THREADS
  466. status = OCILobIsOpen(var->lobVar->connection->handle,
  467. var->lobVar->environment->errorHandle, var->lobVar->data[var->pos],
  468. &isOpen);
  469. Py_END_ALLOW_THREADS
  470. if (Environment_CheckForError(var->lobVar->environment, status,
  471. "ExternalLobVar_IsOpen()") < 0)
  472. return NULL;
  473. return PyBool_FromLong(isOpen);
  474. }
  475. //-----------------------------------------------------------------------------
  476. // ExternalLobVar_GetFileName()
  477. // Return the directory alias and file name for the BFILE lob.
  478. //-----------------------------------------------------------------------------
  479. static PyObject *ExternalLobVar_GetFileName(
  480. udt_ExternalLobVar *var, // variable to get file name for
  481. PyObject *args) // arguments
  482. {
  483. char dirAlias[120], name[1020];
  484. ub2 dirAliasLength, nameLength;
  485. PyObject *result, *temp;
  486. sword status;
  487. // determine the directory alias and name
  488. if (ExternalLobVar_Verify(var) < 0)
  489. return NULL;
  490. nameLength = sizeof(name);
  491. dirAliasLength = sizeof(dirAlias);
  492. status = OCILobFileGetName(var->lobVar->environment->handle,
  493. var->lobVar->environment->errorHandle, var->lobVar->data[var->pos],
  494. (text*) dirAlias, &dirAliasLength, (text*) name, &nameLength);
  495. if (Environment_CheckForError(var->lobVar->environment, status,
  496. "ExternalLobVar_GetFileName()") < 0)
  497. return NULL;
  498. // create the two-tuple for returning
  499. result = PyTuple_New(2);
  500. if (!result)
  501. return NULL;
  502. temp = cxString_FromEncodedString(dirAlias, dirAliasLength,
  503. var->lobVar->environment->encoding);
  504. if (!temp) {
  505. Py_DECREF(result);
  506. return NULL;
  507. }
  508. PyTuple_SET_ITEM(result, 0, temp);
  509. temp = cxString_FromEncodedString(name, nameLength,
  510. var->lobVar->environment->encoding);
  511. if (!temp) {
  512. Py_DECREF(result);
  513. return NULL;
  514. }
  515. PyTuple_SET_ITEM(result, 1, temp);
  516. return result;
  517. }
  518. //-----------------------------------------------------------------------------
  519. // ExternalLobVar_SetFileName()
  520. // Set the directory alias and file name for the BFILE lob.
  521. //-----------------------------------------------------------------------------
  522. static PyObject *ExternalLobVar_SetFileName(
  523. udt_ExternalLobVar *var, // variable to set file name for
  524. PyObject *args) // arguments
  525. {
  526. int dirAliasLength, nameLength;
  527. char *dirAlias, *name;
  528. sword status;
  529. // get the directory alias and name as strings
  530. if (!PyArg_ParseTuple(args, "s#s#", &dirAlias, &dirAliasLength, &name,
  531. &nameLength))
  532. return NULL;
  533. // create a string for retrieving the value
  534. if (ExternalLobVar_Verify(var) < 0)
  535. return NULL;
  536. status = OCILobFileSetName(var->lobVar->environment->handle,
  537. var->lobVar->environment->errorHandle,
  538. &var->lobVar->data[var->pos], (text*) dirAlias,
  539. (ub2) dirAliasLength, (text*) name, (ub2) nameLength);
  540. if (Environment_CheckForError(var->lobVar->environment, status,
  541. "ExternalLobVar_SetFileName()") < 0)
  542. return NULL;
  543. // return the result
  544. Py_INCREF(Py_None);
  545. return Py_None;
  546. }
  547. //-----------------------------------------------------------------------------
  548. // ExternalLobVar_FileExists()
  549. // Return a boolean indicating if the BFIILE lob exists.
  550. //-----------------------------------------------------------------------------
  551. static PyObject *ExternalLobVar_FileExists(
  552. udt_ExternalLobVar *var, // variable to perform write against
  553. PyObject *args) // arguments
  554. {
  555. PyObject *result;
  556. sword status;
  557. boolean flag;
  558. if (ExternalLobVar_Verify(var) < 0)
  559. return NULL;
  560. Py_BEGIN_ALLOW_THREADS
  561. status = OCILobFileExists(var->lobVar->connection->handle,
  562. var->lobVar->environment->errorHandle, var->lobVar->data[var->pos],
  563. &flag);
  564. Py_END_ALLOW_THREADS
  565. if (Environment_CheckForError(var->lobVar->environment, status,
  566. "ExternalLobVar_FileExists()") < 0)
  567. return NULL;
  568. // return the result
  569. if (flag)
  570. result = Py_True;
  571. else result = Py_False;
  572. Py_INCREF(result);
  573. return result;
  574. }