This source file includes following definitions.
- oci_stmt_dtor
- oci_stmt_execute
- oci_bind_input_cb
- oci_bind_output_cb
- oci_stmt_param_hook
- oci_stmt_fetch
- oci_define_callback
- oci_stmt_describe
- oci_blob_write
- oci_blob_read
- oci_blob_close
- oci_blob_flush
- oci_blob_seek
- oci_create_lob_stream
- oci_stmt_get_col
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include "php.h"
26 #include "php_ini.h"
27 #include "ext/standard/info.h"
28 #include "pdo/php_pdo.h"
29 #include "pdo/php_pdo_driver.h"
30 #include "php_pdo_oci.h"
31 #include "php_pdo_oci_int.h"
32 #include "Zend/zend_extensions.h"
33
34 #define PDO_OCI_LOBMAXSIZE (4294967295UL)
35
36 #define STMT_CALL(name, params) \
37 do { \
38 S->last_err = name params; \
39 S->last_err = _oci_error(S->err, stmt->dbh, stmt, #name, S->last_err, FALSE, __FILE__, __LINE__ TSRMLS_CC); \
40 if (S->last_err) { \
41 return 0; \
42 } \
43 } while(0)
44
45 #define STMT_CALL_MSG(name, msg, params) \
46 do { \
47 S->last_err = name params; \
48 S->last_err = _oci_error(S->err, stmt->dbh, stmt, #name ": " #msg, S->last_err, FALSE, __FILE__, __LINE__ TSRMLS_CC); \
49 if (S->last_err) { \
50 return 0; \
51 } \
52 } while(0)
53
54 static php_stream *oci_create_lob_stream(pdo_stmt_t *stmt, OCILobLocator *lob TSRMLS_DC);
55
56 static int oci_stmt_dtor(pdo_stmt_t *stmt TSRMLS_DC)
57 {
58 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
59 HashTable *BC = stmt->bound_columns;
60 HashTable *BP = stmt->bound_params;
61
62 int i;
63
64 if (S->stmt) {
65
66
67 OCIStmtFetch(S->stmt, S->err, 0, OCI_FETCH_NEXT, OCI_DEFAULT);
68
69
70 OCIHandleFree(S->stmt, OCI_HTYPE_STMT);
71 S->stmt = NULL;
72 }
73 if (S->err) {
74 OCIHandleFree(S->err, OCI_HTYPE_ERROR);
75 S->err = NULL;
76 }
77
78
79 if (BC) {
80 zend_hash_destroy(BC);
81 FREE_HASHTABLE(stmt->bound_columns);
82 stmt->bound_columns = NULL;
83 }
84
85 if (BP) {
86 zend_hash_destroy(BP);
87 FREE_HASHTABLE(stmt->bound_params);
88 stmt->bound_params = NULL;
89 }
90
91 if (S->einfo.errmsg) {
92 pefree(S->einfo.errmsg, stmt->dbh->is_persistent);
93 S->einfo.errmsg = NULL;
94 }
95
96 if (S->cols) {
97 for (i = 0; i < stmt->column_count; i++) {
98 if (S->cols[i].data) {
99 switch (S->cols[i].dtype) {
100 case SQLT_BLOB:
101 case SQLT_CLOB:
102 OCIDescriptorFree(S->cols[i].data, OCI_DTYPE_LOB);
103 break;
104 default:
105 efree(S->cols[i].data);
106 }
107 }
108 }
109 efree(S->cols);
110 S->cols = NULL;
111 }
112 efree(S);
113
114 stmt->driver_data = NULL;
115
116 return 1;
117 }
118
119 static int oci_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC)
120 {
121 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
122 ub4 rowcount;
123 b4 mode;
124
125 if (!S->stmt_type) {
126 STMT_CALL_MSG(OCIAttrGet, "OCI_ATTR_STMT_TYPE",
127 (S->stmt, OCI_HTYPE_STMT, &S->stmt_type, 0, OCI_ATTR_STMT_TYPE, S->err));
128 }
129
130 if (stmt->executed) {
131
132 OCIStmtFetch(S->stmt, S->err, 0, OCI_FETCH_NEXT, OCI_DEFAULT);
133 }
134
135 #ifdef OCI_STMT_SCROLLABLE_READONLY
136 if (S->exec_type == OCI_STMT_SCROLLABLE_READONLY) {
137 mode = OCI_STMT_SCROLLABLE_READONLY;
138 } else
139 #endif
140 if (stmt->dbh->auto_commit && !stmt->dbh->in_txn) {
141 mode = OCI_COMMIT_ON_SUCCESS;
142 } else {
143 mode = OCI_DEFAULT;
144 }
145
146 STMT_CALL(OCIStmtExecute, (S->H->svc, S->stmt, S->err,
147 (S->stmt_type == OCI_STMT_SELECT && !S->have_blobs) ? 0 : 1, 0, NULL, NULL,
148 mode));
149
150 if (!stmt->executed) {
151 ub4 colcount;
152
153
154
155 STMT_CALL_MSG(OCIAttrGet, "ATTR_PARAM_COUNT",
156 (S->stmt, OCI_HTYPE_STMT, &colcount, 0, OCI_ATTR_PARAM_COUNT, S->err));
157
158 stmt->column_count = (int)colcount;
159
160 if (S->cols) {
161 int i;
162 for (i = 0; i < stmt->column_count; i++) {
163 if (S->cols[i].data) {
164 switch (S->cols[i].dtype) {
165 case SQLT_BLOB:
166 case SQLT_CLOB:
167
168 break;
169 default:
170 efree(S->cols[i].data);
171 }
172 }
173 }
174 efree(S->cols);
175 }
176
177 S->cols = ecalloc(colcount, sizeof(pdo_oci_column));
178 }
179
180 STMT_CALL_MSG(OCIAttrGet, "ATTR_ROW_COUNT",
181 (S->stmt, OCI_HTYPE_STMT, &rowcount, 0, OCI_ATTR_ROW_COUNT, S->err));
182 stmt->row_count = (long)rowcount;
183
184 return 1;
185 }
186
187 static sb4 oci_bind_input_cb(dvoid *ctx, OCIBind *bindp, ub4 iter, ub4 index, dvoid **bufpp, ub4 *alenp, ub1 *piecep, dvoid **indpp)
188 {
189 struct pdo_bound_param_data *param = (struct pdo_bound_param_data*)ctx;
190 pdo_oci_bound_param *P = (pdo_oci_bound_param*)param->driver_data;
191 TSRMLS_FETCH();
192
193 if (!param || !param->parameter) {
194 php_error_docref(NULL TSRMLS_CC, E_WARNING, "param is NULL in oci_bind_input_cb; this should not happen");
195 return OCI_ERROR;
196 }
197
198 *indpp = &P->indicator;
199
200 if (P->thing) {
201 *bufpp = P->thing;
202 *alenp = sizeof(void*);
203 } else if (ZVAL_IS_NULL(param->parameter)) {
204
205 P->indicator = -1;
206 *bufpp = 0;
207 *alenp = -1;
208 } else if (!P->thing) {
209
210 convert_to_string(param->parameter);
211 *bufpp = Z_STRVAL_P(param->parameter);
212 *alenp = Z_STRLEN_P(param->parameter);
213 }
214
215 *piecep = OCI_ONE_PIECE;
216 return OCI_CONTINUE;
217 }
218
219 static sb4 oci_bind_output_cb(dvoid *ctx, OCIBind *bindp, ub4 iter, ub4 index, dvoid **bufpp, ub4 **alenpp, ub1 *piecep, dvoid **indpp, ub2 **rcodepp)
220 {
221 struct pdo_bound_param_data *param = (struct pdo_bound_param_data*)ctx;
222 pdo_oci_bound_param *P = (pdo_oci_bound_param*)param->driver_data;
223 TSRMLS_FETCH();
224
225 if (!param || !param->parameter) {
226 php_error_docref(NULL TSRMLS_CC, E_WARNING, "param is NULL in oci_bind_output_cb; this should not happen");
227 return OCI_ERROR;
228 }
229
230 if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {
231 P->actual_len = sizeof(OCILobLocator*);
232 *bufpp = P->thing;
233 *alenpp = &P->actual_len;
234 *piecep = OCI_ONE_PIECE;
235 *rcodepp = &P->retcode;
236 *indpp = &P->indicator;
237 return OCI_CONTINUE;
238 }
239
240 if (Z_TYPE_P(param->parameter) == IS_OBJECT || Z_TYPE_P(param->parameter) == IS_RESOURCE) {
241 return OCI_CONTINUE;
242 }
243
244 convert_to_string(param->parameter);
245 zval_dtor(param->parameter);
246
247 Z_STRLEN_P(param->parameter) = param->max_value_len;
248 Z_STRVAL_P(param->parameter) = ecalloc(1, Z_STRLEN_P(param->parameter)+1);
249 P->used_for_output = 1;
250
251 P->actual_len = Z_STRLEN_P(param->parameter);
252 *alenpp = &P->actual_len;
253 *bufpp = Z_STRVAL_P(param->parameter);
254 *piecep = OCI_ONE_PIECE;
255 *rcodepp = &P->retcode;
256 *indpp = &P->indicator;
257
258 return OCI_CONTINUE;
259 }
260
261 static int oci_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type TSRMLS_DC)
262 {
263 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
264
265
266 if (param->is_param) {
267 pdo_oci_bound_param *P;
268 sb4 value_sz = -1;
269
270 P = (pdo_oci_bound_param*)param->driver_data;
271
272 switch (event_type) {
273 case PDO_PARAM_EVT_FETCH_PRE:
274 case PDO_PARAM_EVT_FETCH_POST:
275 case PDO_PARAM_EVT_NORMALIZE:
276
277 break;
278
279 case PDO_PARAM_EVT_FREE:
280 P = param->driver_data;
281 if (P) {
282 efree(P);
283 }
284 break;
285
286 case PDO_PARAM_EVT_ALLOC:
287 P = (pdo_oci_bound_param*)ecalloc(1, sizeof(pdo_oci_bound_param));
288 param->driver_data = P;
289
290
291 switch (PDO_PARAM_TYPE(param->param_type)) {
292 case PDO_PARAM_STMT:
293 return 0;
294
295 case PDO_PARAM_LOB:
296
297 P->oci_type = SQLT_BLOB;
298 value_sz = sizeof(OCILobLocator*);
299 break;
300
301 case PDO_PARAM_STR:
302 default:
303 P->oci_type = SQLT_CHR;
304 value_sz = param->max_value_len;
305 if (param->max_value_len == 0) {
306 value_sz = 1332;
307 }
308
309 }
310
311 if (param->name) {
312 STMT_CALL(OCIBindByName, (S->stmt,
313 &P->bind, S->err, (text*)param->name,
314 param->namelen, 0, value_sz, P->oci_type,
315 &P->indicator, 0, &P->retcode, 0, 0,
316 OCI_DATA_AT_EXEC));
317 } else {
318 STMT_CALL(OCIBindByPos, (S->stmt,
319 &P->bind, S->err, param->paramno+1,
320 0, value_sz, P->oci_type,
321 &P->indicator, 0, &P->retcode, 0, 0,
322 OCI_DATA_AT_EXEC));
323 }
324
325 STMT_CALL(OCIBindDynamic, (P->bind,
326 S->err,
327 param, oci_bind_input_cb,
328 param, oci_bind_output_cb));
329
330 return 1;
331
332 case PDO_PARAM_EVT_EXEC_PRE:
333 P->indicator = 0;
334 P->used_for_output = 0;
335 if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {
336 ub4 empty = 0;
337 STMT_CALL(OCIDescriptorAlloc, (S->H->env, &P->thing, OCI_DTYPE_LOB, 0, NULL));
338 STMT_CALL(OCIAttrSet, (P->thing, OCI_DTYPE_LOB, &empty, 0, OCI_ATTR_LOBEMPTY, S->err));
339 S->have_blobs = 1;
340 }
341 return 1;
342
343 case PDO_PARAM_EVT_EXEC_POST:
344
345 if (P->used_for_output) {
346 if (P->indicator == -1) {
347
348 if (Z_TYPE_P(param->parameter) == IS_STRING
349 #if ZEND_EXTENSION_API_NO < 220040718
350 && Z_STRVAL_P(param->parameter) != empty_string
351 #endif
352 ) {
353
354 *Z_STRVAL_P(param->parameter) = '\0';
355 }
356 zval_dtor(param->parameter);
357 ZVAL_NULL(param->parameter);
358 } else if (Z_TYPE_P(param->parameter) == IS_STRING
359 #if ZEND_EXTENSION_API_NO < 220040718
360 && Z_STRVAL_P(param->parameter) != empty_string
361 #endif
362 ) {
363 Z_STRLEN_P(param->parameter) = P->actual_len;
364 Z_STRVAL_P(param->parameter) = erealloc(Z_STRVAL_P(param->parameter), P->actual_len+1);
365 Z_STRVAL_P(param->parameter)[P->actual_len] = '\0';
366 }
367 } else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB && P->thing) {
368 php_stream *stm;
369
370 if (Z_TYPE_P(param->parameter) == IS_NULL) {
371
372
373
374
375 stm = oci_create_lob_stream(stmt, (OCILobLocator*)P->thing TSRMLS_CC);
376 if (stm) {
377 OCILobOpen(S->H->svc, S->err, (OCILobLocator*)P->thing, OCI_LOB_READWRITE);
378 php_stream_to_zval(stm, param->parameter);
379 P->thing = NULL;
380 }
381 } else {
382
383 size_t n;
384 ub4 amt, offset = 1;
385 char *consume;
386
387 php_stream_from_zval_no_verify(stm, ¶m->parameter);
388 if (stm) {
389 OCILobOpen(S->H->svc, S->err, (OCILobLocator*)P->thing, OCI_LOB_READWRITE);
390 do {
391 char buf[8192];
392 n = php_stream_read(stm, buf, sizeof(buf));
393 if ((int)n <= 0) {
394 break;
395 }
396 consume = buf;
397 do {
398 amt = n;
399 OCILobWrite(S->H->svc, S->err, (OCILobLocator*)P->thing,
400 &amt, offset, consume, n,
401 OCI_ONE_PIECE,
402 NULL, NULL, 0, SQLCS_IMPLICIT);
403 offset += amt;
404 n -= amt;
405 consume += amt;
406 } while (n);
407 } while (1);
408 OCILobClose(S->H->svc, S->err, (OCILobLocator*)P->thing);
409 OCILobFlushBuffer(S->H->svc, S->err, (OCILobLocator*)P->thing, 0);
410 } else if (Z_TYPE_P(param->parameter) == IS_STRING) {
411
412 consume = Z_STRVAL_P(param->parameter);
413 n = Z_STRLEN_P(param->parameter);
414 if (n) {
415 OCILobOpen(S->H->svc, S->err, (OCILobLocator*)P->thing, OCI_LOB_READWRITE);
416 while (n) {
417 amt = n;
418 OCILobWrite(S->H->svc, S->err, (OCILobLocator*)P->thing,
419 &amt, offset, consume, n,
420 OCI_ONE_PIECE,
421 NULL, NULL, 0, SQLCS_IMPLICIT);
422 consume += amt;
423 n -= amt;
424 }
425 OCILobClose(S->H->svc, S->err, (OCILobLocator*)P->thing);
426 }
427 }
428 OCIDescriptorFree(P->thing, OCI_DTYPE_LOB);
429 P->thing = NULL;
430 }
431 }
432
433 return 1;
434 }
435 }
436
437 return 1;
438 }
439
440 static int oci_stmt_fetch(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
441 {
442 #if HAVE_OCISTMTFETCH2
443 ub4 ociori;
444 #endif
445 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
446
447 #if HAVE_OCISTMTFETCH2
448 switch (ori) {
449 case PDO_FETCH_ORI_NEXT: ociori = OCI_FETCH_NEXT; break;
450 case PDO_FETCH_ORI_PRIOR: ociori = OCI_FETCH_PRIOR; break;
451 case PDO_FETCH_ORI_FIRST: ociori = OCI_FETCH_FIRST; break;
452 case PDO_FETCH_ORI_LAST: ociori = OCI_FETCH_LAST; break;
453 case PDO_FETCH_ORI_ABS: ociori = OCI_FETCH_ABSOLUTE; break;
454 case PDO_FETCH_ORI_REL: ociori = OCI_FETCH_RELATIVE; break;
455 }
456 S->last_err = OCIStmtFetch2(S->stmt, S->err, 1, ociori, offset, OCI_DEFAULT);
457 #else
458 S->last_err = OCIStmtFetch(S->stmt, S->err, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
459 #endif
460
461 if (S->last_err == OCI_NO_DATA) {
462
463 return 0;
464 }
465
466 if (S->last_err == OCI_NEED_DATA) {
467 oci_stmt_error("OCI_NEED_DATA");
468 return 0;
469 }
470
471 if (S->last_err == OCI_SUCCESS_WITH_INFO || S->last_err == OCI_SUCCESS) {
472 return 1;
473 }
474
475 oci_stmt_error("OCIStmtFetch");
476
477 return 0;
478 }
479
480 static sb4 oci_define_callback(dvoid *octxp, OCIDefine *define, ub4 iter, dvoid **bufpp,
481 ub4 **alenpp, ub1 *piecep, dvoid **indpp, ub2 **rcodepp)
482 {
483 pdo_oci_column *col = (pdo_oci_column*)octxp;
484 TSRMLS_FETCH();
485
486 switch (col->dtype) {
487 case SQLT_BLOB:
488 case SQLT_CLOB:
489 *piecep = OCI_ONE_PIECE;
490 *bufpp = col->data;
491 *alenpp = &col->datalen;
492 *indpp = (dvoid *)&col->indicator;
493 break;
494
495 default:
496 php_error_docref(NULL TSRMLS_CC, E_WARNING,
497 "unhandled datatype in oci_define_callback; this should not happen");
498 return OCI_ERROR;
499 }
500
501 return OCI_CONTINUE;
502 }
503
504 static int oci_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
505 {
506 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
507 OCIParam *param = NULL;
508 text *colname;
509 ub2 dtype, data_size, scale, precis;
510 ub4 namelen;
511 struct pdo_column_data *col = &stmt->columns[colno];
512 zend_bool dyn = FALSE;
513
514
515 STMT_CALL(OCIParamGet, (S->stmt, OCI_HTYPE_STMT, S->err, (dvoid*)¶m, colno+1));
516
517
518 STMT_CALL_MSG(OCIAttrGet, "OCI_ATTR_DATA_TYPE",
519 (param, OCI_DTYPE_PARAM, &dtype, 0, OCI_ATTR_DATA_TYPE, S->err));
520
521
522 STMT_CALL_MSG(OCIAttrGet, "OCI_ATTR_DATA_SIZE",
523 (param, OCI_DTYPE_PARAM, &data_size, 0, OCI_ATTR_DATA_SIZE, S->err));
524
525
526 STMT_CALL_MSG(OCIAttrGet, "OCI_ATTR_SCALE",
527 (param, OCI_DTYPE_PARAM, &scale, 0, OCI_ATTR_SCALE, S->err));
528
529
530 STMT_CALL_MSG(OCIAttrGet, "OCI_ATTR_PRECISION",
531 (param, OCI_DTYPE_PARAM, &precis, 0, OCI_ATTR_PRECISION, S->err));
532
533
534 STMT_CALL_MSG(OCIAttrGet, "OCI_ATTR_NAME",
535 (param, OCI_DTYPE_PARAM, &colname, &namelen, OCI_ATTR_NAME, S->err));
536
537 col->precision = scale;
538 col->maxlen = data_size;
539 col->namelen = namelen;
540 col->name = estrndup((char *)colname, namelen);
541
542 S->cols[colno].dtype = dtype;
543
544
545 switch (dtype) {
546 case SQLT_LBI:
547 case SQLT_LNG:
548 if (dtype == SQLT_LBI) {
549 dtype = SQLT_BIN;
550 } else {
551 dtype = SQLT_CHR;
552 }
553 S->cols[colno].datalen = 512;
554 S->cols[colno].data = emalloc(S->cols[colno].datalen + 1);
555 col->param_type = PDO_PARAM_STR;
556 break;
557
558 case SQLT_BLOB:
559 case SQLT_CLOB:
560 col->param_type = PDO_PARAM_LOB;
561 STMT_CALL(OCIDescriptorAlloc, (S->H->env, (dvoid**)&S->cols[colno].data, OCI_DTYPE_LOB, 0, NULL));
562 S->cols[colno].datalen = sizeof(OCILobLocator*);
563 dyn = TRUE;
564 break;
565
566 case SQLT_BIN:
567 default:
568 if (dtype == SQLT_DAT || dtype == SQLT_NUM || dtype == SQLT_RDD
569 #ifdef SQLT_TIMESTAMP
570 || dtype == SQLT_TIMESTAMP
571 #endif
572 #ifdef SQLT_TIMESTAMP_TZ
573 || dtype == SQLT_TIMESTAMP_TZ
574 #endif
575 ) {
576
577 S->cols[colno].datalen = 512;
578 #if defined(SQLT_IBFLOAT) && defined(SQLT_IBDOUBLE)
579 } else if (dtype == SQLT_IBFLOAT || dtype == SQLT_IBDOUBLE) {
580 S->cols[colno].datalen = 1024;
581 #endif
582 } else {
583 S->cols[colno].datalen = col->maxlen;
584 }
585 if (dtype == SQLT_BIN) {
586 S->cols[colno].datalen *= 3;
587 }
588 S->cols[colno].data = emalloc(S->cols[colno].datalen + 1);
589 dtype = SQLT_CHR;
590
591
592 col->param_type = PDO_PARAM_STR;
593 }
594
595 STMT_CALL(OCIDefineByPos, (S->stmt, &S->cols[colno].def, S->err, colno+1,
596 S->cols[colno].data, S->cols[colno].datalen, dtype, &S->cols[colno].indicator,
597 &S->cols[colno].fetched_len, &S->cols[colno].retcode, dyn ? OCI_DYNAMIC_FETCH : OCI_DEFAULT));
598
599 if (dyn) {
600 STMT_CALL(OCIDefineDynamic, (S->cols[colno].def, S->err, &S->cols[colno],
601 oci_define_callback));
602 }
603
604 return 1;
605 }
606
607 struct oci_lob_self {
608 pdo_stmt_t *stmt;
609 pdo_oci_stmt *S;
610 OCILobLocator *lob;
611 ub4 offset;
612 };
613
614 static size_t oci_blob_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
615 {
616 struct oci_lob_self *self = (struct oci_lob_self*)stream->abstract;
617 ub4 amt;
618 sword r;
619
620 amt = count;
621 r = OCILobWrite(self->S->H->svc, self->S->err, self->lob,
622 &amt, self->offset, (char*)buf, count,
623 OCI_ONE_PIECE,
624 NULL, NULL, 0, SQLCS_IMPLICIT);
625
626 if (r != OCI_SUCCESS) {
627 return (size_t)-1;
628 }
629
630 self->offset += amt;
631 return amt;
632 }
633
634 static size_t oci_blob_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
635 {
636 struct oci_lob_self *self = (struct oci_lob_self*)stream->abstract;
637 ub4 amt;
638 sword r;
639
640 amt = count;
641 r = OCILobRead(self->S->H->svc, self->S->err, self->lob,
642 &amt, self->offset, buf, count,
643 NULL, NULL, 0, SQLCS_IMPLICIT);
644
645 if (r != OCI_SUCCESS && r != OCI_NEED_DATA) {
646 return (size_t)-1;
647 }
648
649 self->offset += amt;
650 if (amt < count) {
651 stream->eof = 1;
652 }
653 return amt;
654 }
655
656 static int oci_blob_close(php_stream *stream, int close_handle TSRMLS_DC)
657 {
658 struct oci_lob_self *self = (struct oci_lob_self*)stream->abstract;
659 pdo_stmt_t *stmt = self->stmt;
660
661 if (close_handle) {
662 OCILobClose(self->S->H->svc, self->S->err, self->lob);
663 efree(self);
664 }
665
666 php_pdo_stmt_delref(stmt TSRMLS_CC);
667 return 0;
668 }
669
670 static int oci_blob_flush(php_stream *stream TSRMLS_DC)
671 {
672 struct oci_lob_self *self = (struct oci_lob_self*)stream->abstract;
673 OCILobFlushBuffer(self->S->H->svc, self->S->err, self->lob, 0);
674 return 0;
675 }
676
677 static int oci_blob_seek(php_stream *stream, off_t offset, int whence, off_t *newoffset TSRMLS_DC)
678 {
679 struct oci_lob_self *self = (struct oci_lob_self*)stream->abstract;
680
681 if (offset >= PDO_OCI_LOBMAXSIZE) {
682 return -1;
683 } else {
684 self->offset = offset + 1;
685 return 0;
686 }
687 }
688
689 static php_stream_ops oci_blob_stream_ops = {
690 oci_blob_write,
691 oci_blob_read,
692 oci_blob_close,
693 oci_blob_flush,
694 "pdo_oci blob stream",
695 oci_blob_seek,
696 NULL,
697 NULL,
698 NULL
699 };
700
701 static php_stream *oci_create_lob_stream(pdo_stmt_t *stmt, OCILobLocator *lob TSRMLS_DC)
702 {
703 php_stream *stm;
704 struct oci_lob_self *self = ecalloc(1, sizeof(*self));
705 self->lob = lob;
706 self->offset = 1;
707 self->stmt = stmt;
708 self->S = (pdo_oci_stmt*)stmt->driver_data;
709
710 stm = php_stream_alloc(&oci_blob_stream_ops, self, 0, "r+b");
711
712 if (stm) {
713 php_pdo_stmt_addref(stmt TSRMLS_CC);
714 return stm;
715 }
716
717 efree(self);
718 return NULL;
719 }
720
721 static int oci_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC)
722 {
723 pdo_oci_stmt *S = (pdo_oci_stmt*)stmt->driver_data;
724 pdo_oci_column *C = &S->cols[colno];
725
726
727 if (C->indicator == -1) {
728
729 *ptr = NULL;
730 *len = 0;
731 return 1;
732 } else if (C->indicator == 0) {
733
734
735 if (C->dtype == SQLT_BLOB || C->dtype == SQLT_CLOB) {
736 if (C->data) {
737 *ptr = (char*)oci_create_lob_stream(stmt, (OCILobLocator*)C->data TSRMLS_CC);
738 OCILobOpen(S->H->svc, S->err, (OCILobLocator*)C->data, OCI_LOB_READONLY);
739 }
740 *len = 0;
741 return *ptr ? 1 : 0;
742 }
743
744 *ptr = C->data;
745 *len = C->fetched_len;
746 return 1;
747 } else {
748
749 php_error_docref(NULL TSRMLS_CC, E_WARNING, "column %d data was too large for buffer and was truncated to fit it", colno);
750
751 *ptr = C->data;
752 *len = C->fetched_len;
753 return 1;
754 }
755 }
756
757 struct pdo_stmt_methods oci_stmt_methods = {
758 oci_stmt_dtor,
759 oci_stmt_execute,
760 oci_stmt_fetch,
761 oci_stmt_describe,
762 oci_stmt_get_col,
763 oci_stmt_param_hook
764 };
765
766
767
768
769
770
771
772
773