1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2015 The PHP Group |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 3.01 of the PHP license, |
8 | that is bundled with this package in the file LICENSE, and is |
9 | available through the world-wide-web at the following url: |
10 | http://www.php.net/license/3_01.txt |
11 | If you did not receive a copy of the PHP license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@php.net so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Stig S�ther Bakken <ssb@php.net> |
16 | Thies C. Arntzen <thies@thieso.net> |
17 | |
18 | Collection support by Andy Sautins <asautins@veripost.net> |
19 | Temporary LOB support by David Benson <dbenson@mancala.com> |
20 | ZTS per process OCIPLogon by Harald Radi <harald.radi@nme.at> |
21 | |
22 | Redesigned by: Antony Dovgal <antony@zend.com> |
23 | Andi Gutmans <andi@zend.com> |
24 | Wez Furlong <wez@omniti.com> |
25 +----------------------------------------------------------------------+
26 */
27
28 /* $Id$ */
29
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include "php.h"
36 #include "ext/standard/info.h"
37 #include "php_ini.h"
38
39 #if HAVE_OCI8
40
41 #include "php_oci8.h"
42 #include "php_oci8_int.h"
43
44 /* {{{ php_oci_statement_create()
45 Create statemend handle and allocate necessary resources */
php_oci_statement_create(php_oci_connection * connection,char * query,int query_len TSRMLS_DC)46 php_oci_statement *php_oci_statement_create (php_oci_connection *connection, char *query, int query_len TSRMLS_DC)
47 {
48 php_oci_statement *statement;
49
50 statement = ecalloc(1,sizeof(php_oci_statement));
51
52 if (!query_len) {
53 /* do not allocate stmt handle for refcursors, we'll get it from OCIStmtPrepare2() */
54 PHP_OCI_CALL(OCIHandleAlloc, (connection->env, (dvoid **)&(statement->stmt), OCI_HTYPE_STMT, 0, NULL));
55 }
56
57 PHP_OCI_CALL(OCIHandleAlloc, (connection->env, (dvoid **)&(statement->err), OCI_HTYPE_ERROR, 0, NULL));
58
59 if (query_len > 0) {
60 PHP_OCI_CALL_RETURN(connection->errcode, OCIStmtPrepare2,
61 (
62 connection->svc,
63 &(statement->stmt),
64 connection->err,
65 (text *)query,
66 query_len,
67 NULL,
68 0,
69 OCI_NTV_SYNTAX,
70 OCI_DEFAULT
71 )
72 );
73 if (connection->errcode != OCI_SUCCESS) {
74 connection->errcode = php_oci_error(connection->err, connection->errcode TSRMLS_CC);
75
76 PHP_OCI_CALL(OCIStmtRelease, (statement->stmt, statement->err, NULL, 0, statement->errcode ? OCI_STRLS_CACHE_DELETE : OCI_DEFAULT));
77 PHP_OCI_CALL(OCIHandleFree,(statement->err, OCI_HTYPE_ERROR));
78
79 efree(statement);
80 PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
81 return NULL;
82 }
83 }
84
85 if (query && query_len) {
86 statement->last_query = estrndup(query, query_len);
87 statement->last_query_len = query_len;
88 }
89 else {
90 statement->last_query = NULL;
91 statement->last_query_len = 0;
92 }
93
94 statement->connection = connection;
95 statement->has_data = 0;
96 statement->has_descr = 0;
97 statement->parent_stmtid = 0;
98 zend_list_addref(statement->connection->rsrc_id);
99
100 if (OCI_G(default_prefetch) >= 0) {
101 php_oci_statement_set_prefetch(statement, OCI_G(default_prefetch) TSRMLS_CC);
102 }
103
104 PHP_OCI_REGISTER_RESOURCE(statement, le_statement);
105
106 OCI_G(num_statements)++;
107
108 return statement;
109 }
110 /* }}} */
111
112 /* {{{ php_oci_statement_set_prefetch()
113 Set prefetch buffer size for the statement (we're assuming that one row is ~1K sized) */
php_oci_statement_set_prefetch(php_oci_statement * statement,long size TSRMLS_DC)114 int php_oci_statement_set_prefetch(php_oci_statement *statement, long size TSRMLS_DC)
115 {
116 ub4 prefetch = size;
117
118 if (size < 0) {
119 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Number of rows to be prefetched has to be greater than or equal to 0");
120 return 1;
121 }
122
123 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrSet, (statement->stmt, OCI_HTYPE_STMT, &prefetch, 0, OCI_ATTR_PREFETCH_ROWS, statement->err));
124
125 if (statement->errcode != OCI_SUCCESS) {
126 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
127 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
128 return 1;
129 }
130
131 return 0;
132 }
133 /* }}} */
134
135 /* {{{ php_oci_cleanup_pre_fetch()
136 Helper function to cleanup ref-cursors and descriptors from the previous row */
php_oci_cleanup_pre_fetch(void * data TSRMLS_DC)137 int php_oci_cleanup_pre_fetch(void *data TSRMLS_DC)
138 {
139 php_oci_out_column *outcol = data;
140
141 if (!outcol->is_descr && !outcol->is_cursor)
142 return ZEND_HASH_APPLY_KEEP;
143
144 switch(outcol->data_type) {
145 case SQLT_CLOB:
146 case SQLT_BLOB:
147 case SQLT_RDD:
148 case SQLT_BFILE:
149 if (outcol->descid) {
150 zend_list_delete(outcol->descid);
151 outcol->descid = 0;
152 }
153 break;
154 case SQLT_RSET:
155 if (outcol->stmtid) {
156 zend_list_delete(outcol->stmtid);
157 outcol->stmtid = 0;
158 outcol->nested_statement = NULL;
159 }
160 break;
161 default:
162 break;
163 }
164 return ZEND_HASH_APPLY_KEEP;
165
166 } /* }}} */
167
168
169 /* {{{ php_oci_statement_fetch()
170 Fetch a row from the statement */
php_oci_statement_fetch(php_oci_statement * statement,ub4 nrows TSRMLS_DC)171 int php_oci_statement_fetch(php_oci_statement *statement, ub4 nrows TSRMLS_DC)
172 {
173 int i;
174 void *handlepp;
175 ub4 typep, iterp, idxp;
176 ub1 in_outp, piecep;
177 zend_bool piecewisecols = 0;
178
179 php_oci_out_column *column;
180
181 if (statement->has_descr && statement->columns) {
182 zend_hash_apply(statement->columns, (apply_func_t) php_oci_cleanup_pre_fetch TSRMLS_CC);
183 }
184
185 PHP_OCI_CALL_RETURN(statement->errcode, OCIStmtFetch, (statement->stmt, statement->err, nrows, OCI_FETCH_NEXT, OCI_DEFAULT));
186
187 if ( statement->errcode == OCI_NO_DATA || nrows == 0 ) {
188 if (statement->last_query == NULL) {
189 /* reset define-list for refcursors */
190 if (statement->columns) {
191 zend_hash_destroy(statement->columns);
192 efree(statement->columns);
193 statement->columns = NULL;
194 statement->ncolumns = 0;
195 }
196 statement->executed = 0;
197 }
198
199 statement->errcode = 0; /* OCI_NO_DATA is NO error for us!!! */
200 statement->has_data = 0;
201
202 if (nrows == 0) {
203 /* this is exactly what we requested */
204 return 0;
205 }
206 return 1;
207 }
208
209 /* reset length for all piecewise columns */
210 for (i = 0; i < statement->ncolumns; i++) {
211 column = php_oci_statement_get_column(statement, i + 1, NULL, 0 TSRMLS_CC);
212 if (column->piecewise) {
213 column->retlen4 = 0;
214 piecewisecols = 1;
215 }
216 }
217
218 while (statement->errcode == OCI_NEED_DATA) {
219 if (piecewisecols) {
220 PHP_OCI_CALL_RETURN(statement->errcode,
221 OCIStmtGetPieceInfo,
222 (
223 statement->stmt,
224 statement->err,
225 &handlepp,
226 &typep,
227 &in_outp,
228 &iterp,
229 &idxp,
230 &piecep
231 )
232 );
233
234 /* scan through our columns for a piecewise column with a matching handle */
235 for (i = 0; i < statement->ncolumns; i++) {
236 column = php_oci_statement_get_column(statement, i + 1, NULL, 0 TSRMLS_CC);
237 if (column->piecewise && handlepp == column->oci_define) {
238 if (!column->data) {
239 column->data = (text *) ecalloc(1, PHP_OCI_PIECE_SIZE + 1);
240 } else {
241 column->data = erealloc(column->data, column->retlen4 + PHP_OCI_PIECE_SIZE + 1);
242 }
243 column->cb_retlen = PHP_OCI_PIECE_SIZE;
244
245 /* and instruct fetch to fetch waiting piece into our buffer */
246 PHP_OCI_CALL(OCIStmtSetPieceInfo,
247 (
248 (void *) column->oci_define,
249 OCI_HTYPE_DEFINE,
250 statement->err,
251 ((char*)column->data) + column->retlen4,
252 &(column->cb_retlen),
253 piecep,
254 &column->indicator,
255 &column->retcode
256 )
257 );
258 }
259 }
260 }
261
262 PHP_OCI_CALL_RETURN(statement->errcode, OCIStmtFetch, (statement->stmt, statement->err, nrows, OCI_FETCH_NEXT, OCI_DEFAULT));
263
264 if (piecewisecols) {
265 for (i = 0; i < statement->ncolumns; i++) {
266 column = php_oci_statement_get_column(statement, i + 1, NULL, 0 TSRMLS_CC);
267 if (column && column->piecewise && handlepp == column->oci_define) {
268 column->retlen4 += column->cb_retlen;
269 }
270 }
271 }
272 }
273
274 if (statement->errcode == OCI_SUCCESS_WITH_INFO || statement->errcode == OCI_SUCCESS) {
275 statement->has_data = 1;
276
277 /* do the stuff needed for OCIDefineByName */
278 for (i = 0; i < statement->ncolumns; i++) {
279 column = php_oci_statement_get_column(statement, i + 1, NULL, 0 TSRMLS_CC);
280 if (column == NULL) {
281 continue;
282 }
283
284 if (!column->define) {
285 continue;
286 }
287
288 zval_dtor(column->define->zval);
289 php_oci_column_to_zval(column, column->define->zval, 0 TSRMLS_CC);
290 }
291
292 return 0;
293 }
294
295 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
296 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
297
298 statement->has_data = 0;
299
300 return 1;
301 }
302 /* }}} */
303
304 /* {{{ php_oci_statement_get_column()
305 Get column from the result set */
php_oci_statement_get_column(php_oci_statement * statement,long column_index,char * column_name,int column_name_len TSRMLS_DC)306 php_oci_out_column *php_oci_statement_get_column(php_oci_statement *statement, long column_index, char *column_name, int column_name_len TSRMLS_DC)
307 {
308 php_oci_out_column *column = NULL;
309 int i;
310
311 if (statement->columns == NULL) { /* we release the columns at the end of a fetch */
312 return NULL;
313 }
314
315 if (column_name) {
316 for (i = 0; i < statement->ncolumns; i++) {
317 column = php_oci_statement_get_column(statement, i + 1, NULL, 0 TSRMLS_CC);
318 if (column == NULL) {
319 continue;
320 } else if (((int) column->name_len == column_name_len) && (!strncmp(column->name, column_name, column_name_len))) {
321 return column;
322 }
323 }
324 } else if (column_index != -1) {
325 if (zend_hash_index_find(statement->columns, column_index, (void **)&column) == FAILURE) {
326 return NULL;
327 }
328 return column;
329 }
330
331 return NULL;
332 }
333 /* }}} */
334
335 /* php_oci_define_callback() {{{ */
php_oci_define_callback(dvoid * ctx,OCIDefine * define,ub4 iter,dvoid ** bufpp,ub4 ** alenpp,ub1 * piecep,dvoid ** indpp,ub2 ** rcpp)336 sb4 php_oci_define_callback(dvoid *ctx, OCIDefine *define, ub4 iter, dvoid **bufpp, ub4 **alenpp, ub1 *piecep, dvoid **indpp, ub2 **rcpp)
337 {
338 php_oci_out_column *outcol = (php_oci_out_column *)ctx;
339 TSRMLS_FETCH();
340
341 if (!outcol) {
342
343 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid context pointer value");
344 return OCI_ERROR;
345 }
346
347 switch(outcol->data_type) {
348 case SQLT_RSET: {
349 php_oci_statement *nested_stmt;
350
351 nested_stmt = php_oci_statement_create(outcol->statement->connection, NULL, 0 TSRMLS_CC);
352 if (!nested_stmt) {
353 return OCI_ERROR;
354 }
355 nested_stmt->parent_stmtid = outcol->statement->id;
356 zend_list_addref(outcol->statement->id);
357 outcol->nested_statement = nested_stmt;
358 outcol->stmtid = nested_stmt->id;
359
360 *bufpp = nested_stmt->stmt;
361 *alenpp = &(outcol->retlen4);
362 *piecep = OCI_ONE_PIECE;
363 *indpp = &(outcol->indicator);
364 *rcpp = &(outcol->retcode);
365 return OCI_CONTINUE;
366 }
367 break;
368 case SQLT_RDD:
369 case SQLT_BLOB:
370 case SQLT_CLOB:
371 case SQLT_BFILE: {
372 php_oci_descriptor *descr;
373 int dtype;
374
375 if (outcol->data_type == SQLT_BFILE) {
376 dtype = OCI_DTYPE_FILE;
377 } else if (outcol->data_type == SQLT_RDD ) {
378 dtype = OCI_DTYPE_ROWID;
379 } else {
380 dtype = OCI_DTYPE_LOB;
381 }
382
383 descr = php_oci_lob_create(outcol->statement->connection, dtype TSRMLS_CC);
384 if (!descr) {
385 return OCI_ERROR;
386 }
387 outcol->descid = descr->id;
388 descr->charset_form = outcol->charset_form;
389
390 *bufpp = descr->descriptor;
391 *alenpp = &(outcol->retlen4);
392 *piecep = OCI_ONE_PIECE;
393 *indpp = &(outcol->indicator);
394 *rcpp = &(outcol->retcode);
395
396 return OCI_CONTINUE;
397 }
398 break;
399 }
400 return OCI_ERROR;
401 }
402 /* }}} */
403
404 /* {{{ php_oci_statement_execute()
405 Execute statement */
php_oci_statement_execute(php_oci_statement * statement,ub4 mode TSRMLS_DC)406 int php_oci_statement_execute(php_oci_statement *statement, ub4 mode TSRMLS_DC)
407 {
408 php_oci_out_column *outcol;
409 php_oci_out_column column;
410 OCIParam *param = NULL;
411 text *colname;
412 ub4 counter;
413 ub2 define_type;
414 ub4 iters;
415 ub4 colcount;
416 ub2 dynamic;
417 dvoid *buf;
418
419 switch (mode) {
420 case OCI_COMMIT_ON_SUCCESS:
421 case OCI_DESCRIBE_ONLY:
422 case OCI_DEFAULT:
423 /* only these are allowed */
424 break;
425 default:
426 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid execute mode given: %d", mode);
427 return 1;
428 break;
429 }
430
431 if (!statement->stmttype) {
432 /* get statement type */
433 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (ub2 *)&statement->stmttype, (ub4 *)0, OCI_ATTR_STMT_TYPE, statement->err));
434
435 if (statement->errcode != OCI_SUCCESS) {
436 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
437 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
438 return 1;
439 }
440 }
441
442 if (statement->stmttype == OCI_STMT_SELECT) {
443 iters = 0;
444 } else {
445 iters = 1;
446 }
447
448 if (statement->last_query) {
449 /* if we execute refcursors we don't have a query and
450 we don't want to execute!!! */
451
452 if (statement->binds) {
453 int result = 0;
454 zend_hash_apply_with_argument(statement->binds, (apply_func_arg_t) php_oci_bind_pre_exec, (void *)&result TSRMLS_CC);
455 if (result) {
456 return 1;
457 }
458 }
459
460 /* execute statement */
461 PHP_OCI_CALL_RETURN(statement->errcode, OCIStmtExecute, (statement->connection->svc, statement->stmt, statement->err, iters, 0, NULL, NULL, mode));
462
463 if (statement->errcode != OCI_SUCCESS) {
464 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
465 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
466 return 1;
467 }
468
469 if (statement->binds) {
470 zend_hash_apply(statement->binds, (apply_func_t) php_oci_bind_post_exec TSRMLS_CC);
471 }
472
473 if (mode & OCI_COMMIT_ON_SUCCESS) {
474 statement->connection->needs_commit = 0;
475 } else {
476 statement->connection->needs_commit = 1;
477 }
478 }
479
480 if (statement->stmttype == OCI_STMT_SELECT && statement->executed == 0) {
481 /* we only need to do the define step is this very statement is executed the first time! */
482 statement->executed = 1;
483
484 ALLOC_HASHTABLE(statement->columns);
485 zend_hash_init(statement->columns, 13, NULL, php_oci_column_hash_dtor, 0);
486
487 counter = 1;
488
489 /* get number of columns */
490 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (dvoid *)&colcount, (ub4 *)0, OCI_ATTR_PARAM_COUNT, statement->err));
491
492 if (statement->errcode != OCI_SUCCESS) {
493 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
494 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
495 return 1;
496 }
497
498 statement->ncolumns = colcount;
499
500 for (counter = 1; counter <= colcount; counter++) {
501 memset(&column,0,sizeof(php_oci_out_column));
502
503 if (zend_hash_index_update(statement->columns, counter, &column, sizeof(php_oci_out_column), (void**) &outcol) == FAILURE) {
504 efree(statement->columns);
505 /* out of memory */
506 return 1;
507 }
508
509 /* get column */
510 PHP_OCI_CALL_RETURN(statement->errcode, OCIParamGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, statement->err, (dvoid**)¶m, counter));
511
512 if (statement->errcode != OCI_SUCCESS) {
513 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
514 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
515 return 1;
516 }
517
518 /* get column datatype */
519 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->data_type, (ub4 *)0, OCI_ATTR_DATA_TYPE, statement->err));
520
521 if (statement->errcode != OCI_SUCCESS) {
522 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
523 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
524 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
525 return 1;
526 }
527
528 /* get character set form */
529 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->charset_form, (ub4 *)0, OCI_ATTR_CHARSET_FORM, statement->err));
530
531 if (statement->errcode != OCI_SUCCESS) {
532 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
533 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
534 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
535 return 1;
536 }
537
538 /* get character set id */
539 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->charset_id, (ub4 *)0, OCI_ATTR_CHARSET_ID, statement->err));
540
541 if (statement->errcode != OCI_SUCCESS) {
542 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
543 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
544 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
545 return 1;
546 }
547
548 /* get size of the column */
549 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->data_size, (dvoid *)0, OCI_ATTR_DATA_SIZE, statement->err));
550
551 if (statement->errcode != OCI_SUCCESS) {
552 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
553 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
554 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
555 return 1;
556 }
557
558 outcol->storage_size4 = outcol->data_size;
559 outcol->retlen = outcol->data_size;
560
561 /* get scale of the column */
562 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->scale, (dvoid *)0, OCI_ATTR_SCALE, statement->err));
563
564 if (statement->errcode != OCI_SUCCESS) {
565 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
566 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
567 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
568 return 1;
569 }
570
571 /* get precision of the column */
572 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid *)&outcol->precision, (dvoid *)0, OCI_ATTR_PRECISION, statement->err));
573
574 if (statement->errcode != OCI_SUCCESS) {
575 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
576 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
577 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
578 return 1;
579 }
580
581 /* get name of the column */
582 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)param, OCI_DTYPE_PARAM, (dvoid **)&colname, (ub4 *)&outcol->name_len, (ub4)OCI_ATTR_NAME, statement->err));
583
584 if (statement->errcode != OCI_SUCCESS) {
585 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
586 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
587 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
588 return 1;
589 }
590 PHP_OCI_CALL(OCIDescriptorFree, (param, OCI_DTYPE_PARAM));
591
592 outcol->name = estrndup((char*) colname, outcol->name_len);
593
594 /* find a user-setted define */
595 if (statement->defines) {
596 if (zend_hash_find(statement->defines,outcol->name,outcol->name_len,(void **) &outcol->define) == SUCCESS) {
597 if (outcol->define->type) {
598 outcol->data_type = outcol->define->type;
599 }
600 }
601 }
602
603 buf = 0;
604 switch (outcol->data_type) {
605 case SQLT_RSET:
606 outcol->statement = statement; /* parent handle */
607
608 define_type = SQLT_RSET;
609 outcol->is_cursor = 1;
610 outcol->statement->has_descr = 1;
611 outcol->storage_size4 = -1;
612 outcol->retlen = -1;
613 dynamic = OCI_DYNAMIC_FETCH;
614 break;
615
616 case SQLT_RDD: /* ROWID */
617 case SQLT_BLOB: /* binary LOB */
618 case SQLT_CLOB: /* character LOB */
619 case SQLT_BFILE: /* binary file LOB */
620 outcol->statement = statement; /* parent handle */
621
622 define_type = outcol->data_type;
623 outcol->is_descr = 1;
624 outcol->statement->has_descr = 1;
625 outcol->storage_size4 = -1;
626 dynamic = OCI_DYNAMIC_FETCH;
627 break;
628
629 case SQLT_LNG:
630 case SQLT_LBI:
631 if (outcol->data_type == SQLT_LBI) {
632 define_type = SQLT_BIN;
633 } else {
634 define_type = SQLT_CHR;
635 }
636 outcol->storage_size4 = PHP_OCI_MAX_DATA_SIZE;
637 outcol->piecewise = 1;
638 dynamic = OCI_DYNAMIC_FETCH;
639 break;
640
641 case SQLT_BIN:
642 default:
643 define_type = SQLT_CHR;
644 if (outcol->data_type == SQLT_BIN) {
645 define_type = SQLT_BIN;
646 }
647 if ((outcol->data_type == SQLT_DAT) || (outcol->data_type == SQLT_NUM)
648 #ifdef SQLT_TIMESTAMP
649 || (outcol->data_type == SQLT_TIMESTAMP)
650 #endif
651 #ifdef SQLT_TIMESTAMP_TZ
652 || (outcol->data_type == SQLT_TIMESTAMP_TZ)
653 #endif
654 #ifdef SQLT_TIMESTAMP_LTZ
655 || (outcol->data_type == SQLT_TIMESTAMP_LTZ)
656 #endif
657 #ifdef SQLT_INTERVAL_YM
658 || (outcol->data_type == SQLT_INTERVAL_YM)
659 #endif
660 #ifdef SQLT_INTERVAL_DS
661 || (outcol->data_type == SQLT_INTERVAL_DS)
662 #endif
663 ) {
664 outcol->storage_size4 = 512; /* XXX this should fit "most" NLS date-formats and Numbers */
665 #if defined(SQLT_IBFLOAT) && defined(SQLT_IBDOUBLE)
666 } else if (outcol->data_type == SQLT_IBFLOAT || outcol->data_type == SQLT_IBDOUBLE) {
667 outcol->storage_size4 = 1024;
668 #endif
669 } else {
670 outcol->storage_size4++; /* add one for string terminator */
671 }
672
673 outcol->storage_size4 *= 3;
674
675 dynamic = OCI_DEFAULT;
676 buf = outcol->data = (text *) safe_emalloc(1, outcol->storage_size4, 0);
677 memset(buf, 0, outcol->storage_size4);
678 break;
679 }
680
681 if (dynamic == OCI_DYNAMIC_FETCH) {
682 PHP_OCI_CALL_RETURN(statement->errcode,
683 OCIDefineByPos,
684 (
685 statement->stmt, /* IN/OUT handle to the requested SQL query */
686 (OCIDefine **)&outcol->oci_define, /* IN/OUT pointer to a pointer to a define handle */
687 statement->err, /* IN/OUT An error handle */
688 counter, /* IN position in the select list */
689 (dvoid *)NULL, /* IN/OUT pointer to a buffer */
690 outcol->storage_size4, /* IN The size of each valuep buffer in bytes */
691 define_type, /* IN The data type */
692 (dvoid *)&outcol->indicator, /* IN pointer to an indicator variable or arr */
693 (ub2 *)NULL, /* IN/OUT Pointer to array of length of data fetched */
694 (ub2 *)NULL, /* OUT Pointer to array of column-level return codes */
695 OCI_DYNAMIC_FETCH /* IN mode (OCI_DEFAULT, OCI_DYNAMIC_FETCH) */
696 )
697 );
698
699 } else {
700 PHP_OCI_CALL_RETURN(statement->errcode,
701 OCIDefineByPos,
702 (
703 statement->stmt, /* IN/OUT handle to the requested SQL query */
704 (OCIDefine **)&outcol->oci_define, /* IN/OUT pointer to a pointer to a define handle */
705 statement->err, /* IN/OUT An error handle */
706 counter, /* IN position in the select list */
707 (dvoid *)buf, /* IN/OUT pointer to a buffer */
708 outcol->storage_size4, /* IN The size of each valuep buffer in bytes */
709 define_type, /* IN The data type */
710 (dvoid *)&outcol->indicator, /* IN pointer to an indicator variable or arr */
711 (ub2 *)&outcol->retlen, /* IN/OUT Pointer to array of length of data fetched */
712 (ub2 *)&outcol->retcode, /* OUT Pointer to array of column-level return codes */
713 OCI_DEFAULT /* IN mode (OCI_DEFAULT, OCI_DYNAMIC_FETCH) */
714 )
715 );
716
717 }
718
719 if (statement->errcode != OCI_SUCCESS) {
720 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
721 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
722 return 0;
723 }
724
725 /* additional OCIDefineDynamic() call */
726 switch (outcol->data_type) {
727 case SQLT_RSET:
728 case SQLT_RDD:
729 case SQLT_BLOB:
730 case SQLT_CLOB:
731 case SQLT_BFILE:
732 PHP_OCI_CALL_RETURN(statement->errcode,
733 OCIDefineDynamic,
734 (
735 outcol->oci_define,
736 statement->err,
737 (dvoid *)outcol,
738 php_oci_define_callback
739 )
740 );
741
742 break;
743 }
744 }
745 }
746
747 return 0;
748 }
749 /* }}} */
750
751 /* {{{ php_oci_statement_cancel()
752 Cancel statement */
php_oci_statement_cancel(php_oci_statement * statement TSRMLS_DC)753 int php_oci_statement_cancel(php_oci_statement *statement TSRMLS_DC)
754 {
755
756 return php_oci_statement_fetch(statement, 0 TSRMLS_CC);
757
758 } /* }}} */
759
760 /* {{{ php_oci_statement_free()
761 Destroy statement handle and free associated resources */
php_oci_statement_free(php_oci_statement * statement TSRMLS_DC)762 void php_oci_statement_free(php_oci_statement *statement TSRMLS_DC)
763 {
764 if (statement->stmt) {
765 if (statement->last_query_len) { /* FIXME: magical */
766 PHP_OCI_CALL(OCIStmtRelease, (statement->stmt, statement->err, NULL, 0, statement->errcode ? OCI_STRLS_CACHE_DELETE : OCI_DEFAULT));
767 } else {
768 PHP_OCI_CALL(OCIHandleFree, (statement->stmt, OCI_HTYPE_STMT));
769 }
770 statement->stmt = 0;
771 }
772
773 if (statement->err) {
774 PHP_OCI_CALL(OCIHandleFree, (statement->err, OCI_HTYPE_ERROR));
775 statement->err = 0;
776 }
777
778 if (statement->last_query) {
779 efree(statement->last_query);
780 }
781
782 if (statement->columns) {
783 zend_hash_destroy(statement->columns);
784 efree(statement->columns);
785 }
786
787 if (statement->binds) {
788 zend_hash_destroy(statement->binds);
789 efree(statement->binds);
790 }
791
792 if (statement->defines) {
793 zend_hash_destroy(statement->defines);
794 efree(statement->defines);
795 }
796
797 if (statement->parent_stmtid) {
798 zend_list_delete(statement->parent_stmtid);
799 }
800
801 zend_list_delete(statement->connection->rsrc_id);
802 efree(statement);
803
804 OCI_G(num_statements)--;
805 } /* }}} */
806
807 /* {{{ php_oci_bind_pre_exec()
808 Helper function */
php_oci_bind_pre_exec(void * data,void * result TSRMLS_DC)809 int php_oci_bind_pre_exec(void *data, void *result TSRMLS_DC)
810 {
811 php_oci_bind *bind = (php_oci_bind *) data;
812
813 *(int *)result = 0;
814
815 if (Z_TYPE_P(bind->zval) == IS_ARRAY) {
816 /* These checks are currently valid for oci_bind_by_name, not
817 * oci_bind_array_by_name. Also bind->type and
818 * bind->indicator are not used for oci_bind_array_by_name.
819 */
820 return 0;
821 }
822 switch (bind->type) {
823 case SQLT_NTY:
824 case SQLT_BFILEE:
825 case SQLT_CFILEE:
826 case SQLT_CLOB:
827 case SQLT_BLOB:
828 case SQLT_RDD:
829 if (Z_TYPE_P(bind->zval) != IS_OBJECT) {
830 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid variable used for bind");
831 *(int *)result = 1;
832 }
833 break;
834
835 case SQLT_INT:
836 case SQLT_NUM:
837 if (Z_TYPE_P(bind->zval) == IS_RESOURCE || Z_TYPE_P(bind->zval) == IS_OBJECT) {
838 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid variable used for bind");
839 *(int *)result = 1;
840 }
841 break;
842
843 case SQLT_LBI:
844 case SQLT_BIN:
845 case SQLT_LNG:
846 case SQLT_AFC:
847 case SQLT_CHR:
848 if (Z_TYPE_P(bind->zval) == IS_RESOURCE || Z_TYPE_P(bind->zval) == IS_OBJECT) {
849 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid variable used for bind");
850 *(int *)result = 1;
851 }
852 break;
853
854 case SQLT_RSET:
855 if (Z_TYPE_P(bind->zval) != IS_RESOURCE) {
856 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid variable used for bind");
857 *(int *)result = 1;
858 }
859 break;
860 }
861
862 /* reset all bind stuff to a normal state..-. */
863 bind->indicator = 0;
864
865 return 0;
866 }
867 /* }}} */
868
869 /* {{{ php_oci_bind_post_exec()
870 Helper function */
php_oci_bind_post_exec(void * data TSRMLS_DC)871 int php_oci_bind_post_exec(void *data TSRMLS_DC)
872 {
873 php_oci_bind *bind = (php_oci_bind *) data;
874 php_oci_connection *connection = bind->parent_statement->connection;
875
876 if (bind->indicator == -1) { /* NULL */
877 zval *val = bind->zval;
878 if (Z_TYPE_P(val) == IS_STRING) {
879 *Z_STRVAL_P(val) = '\0'; /* XXX avoid warning in debug mode */
880 }
881 zval_dtor(val);
882 ZVAL_NULL(val);
883 } else if (Z_TYPE_P(bind->zval) == IS_STRING
884 && Z_STRLEN_P(bind->zval) > 0
885 && Z_STRVAL_P(bind->zval)[ Z_STRLEN_P(bind->zval) ] != '\0') {
886 /* The post- PHP 5.3 feature for "interned" strings disallows
887 * their reallocation but (i) any IN binds either interned or
888 * not should already be null terminated and (ii) for OUT
889 * binds, php_oci_bind_out_callback() should have allocated a
890 * new string that we can modify here.
891 */
892 Z_STRVAL_P(bind->zval) = erealloc(Z_STRVAL_P(bind->zval), Z_STRLEN_P(bind->zval)+1);
893 Z_STRVAL_P(bind->zval)[ Z_STRLEN_P(bind->zval) ] = '\0';
894 } else if (Z_TYPE_P(bind->zval) == IS_ARRAY) {
895 int i;
896 zval **entry;
897 HashTable *hash = HASH_OF(bind->zval);
898
899 zend_hash_internal_pointer_reset(hash);
900
901 switch (bind->array.type) {
902 case SQLT_NUM:
903 case SQLT_INT:
904 case SQLT_LNG:
905 for (i = 0; i < bind->array.current_length; i++) {
906 if ((i < bind->array.old_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
907 zval_dtor(*entry);
908 ZVAL_LONG(*entry, ((ub4 *)(bind->array.elements))[i]);
909 zend_hash_move_forward(hash);
910 } else {
911 add_next_index_long(bind->zval, ((ub4 *)(bind->array.elements))[i]);
912 }
913 }
914 break;
915 case SQLT_FLT:
916 for (i = 0; i < bind->array.current_length; i++) {
917 if ((i < bind->array.old_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
918 zval_dtor(*entry);
919 ZVAL_DOUBLE(*entry, ((double *)(bind->array.elements))[i]);
920 zend_hash_move_forward(hash);
921 } else {
922 add_next_index_double(bind->zval, ((double *)(bind->array.elements))[i]);
923 }
924 }
925 break;
926 case SQLT_ODT:
927 for (i = 0; i < bind->array.current_length; i++) {
928 oratext buff[1024];
929 ub4 buff_len = 1024;
930
931 memset((void*)buff,0,sizeof(buff));
932
933 if ((i < bind->array.old_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
934 PHP_OCI_CALL_RETURN(connection->errcode, OCIDateToText, (connection->err, &(((OCIDate *)(bind->array.elements))[i]), 0, 0, 0, 0, &buff_len, buff));
935 zval_dtor(*entry);
936
937 if (connection->errcode != OCI_SUCCESS) {
938 connection->errcode = php_oci_error(connection->err, connection->errcode TSRMLS_CC);
939 PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
940 ZVAL_NULL(*entry);
941 } else {
942 ZVAL_STRINGL(*entry, (char *)buff, buff_len, 1);
943 }
944 zend_hash_move_forward(hash);
945 } else {
946 PHP_OCI_CALL_RETURN(connection->errcode, OCIDateToText, (connection->err, &(((OCIDate *)(bind->array.elements))[i]), 0, 0, 0, 0, &buff_len, buff));
947 if (connection->errcode != OCI_SUCCESS) {
948 connection->errcode = php_oci_error(connection->err, connection->errcode TSRMLS_CC);
949 PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
950 add_next_index_null(bind->zval);
951 } else {
952 add_next_index_stringl(bind->zval, (char *)buff, buff_len, 1);
953 }
954 }
955 }
956 break;
957
958 case SQLT_AFC:
959 case SQLT_CHR:
960 case SQLT_VCS:
961 case SQLT_AVC:
962 case SQLT_STR:
963 case SQLT_LVC:
964 for (i = 0; i < bind->array.current_length; i++) {
965 /* int curr_element_length = strlen(((text *)bind->array.elements)+i*bind->array.max_length); */
966 int curr_element_length = bind->array.element_lengths[i];
967 if ((i < bind->array.old_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
968 zval_dtor(*entry);
969 ZVAL_STRINGL(*entry, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length, 1);
970 zend_hash_move_forward(hash);
971 } else {
972 add_next_index_stringl(bind->zval, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length, 1);
973 }
974 }
975 break;
976 }
977 }
978
979 return 0;
980 }
981 /* }}} */
982
983 /* {{{ php_oci_bind_by_name()
984 Bind zval to the given placeholder */
php_oci_bind_by_name(php_oci_statement * statement,char * name,int name_len,zval * var,long maxlength,ub2 type TSRMLS_DC)985 int php_oci_bind_by_name(php_oci_statement *statement, char *name, int name_len, zval* var, long maxlength, ub2 type TSRMLS_DC)
986 {
987 php_oci_collection *bind_collection = NULL;
988 php_oci_descriptor *bind_descriptor = NULL;
989 php_oci_statement *bind_statement = NULL;
990 dvoid *oci_desc = NULL;
991 /* dvoid *php_oci_collection = NULL; */
992 OCIStmt *oci_stmt = NULL;
993 dvoid *bind_data = NULL;
994 php_oci_bind bind, *old_bind, *bindp;
995 int mode = OCI_DATA_AT_EXEC;
996 sb4 value_sz = -1;
997
998 switch (type) {
999 case SQLT_NTY:
1000 {
1001 zval **tmp;
1002
1003 if (Z_TYPE_P(var) != IS_OBJECT || zend_hash_find(Z_OBJPROP_P(var), "collection", sizeof("collection"), (void **)&tmp) == FAILURE) {
1004 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find collection property");
1005 return 1;
1006 }
1007
1008 PHP_OCI_ZVAL_TO_COLLECTION_EX(*tmp, bind_collection);
1009 value_sz = sizeof(void*);
1010 mode = OCI_DEFAULT;
1011
1012 if (!bind_collection->collection) {
1013 return 1;
1014 }
1015 }
1016 break;
1017 case SQLT_BFILEE:
1018 case SQLT_CFILEE:
1019 case SQLT_CLOB:
1020 case SQLT_BLOB:
1021 case SQLT_RDD:
1022 {
1023 zval **tmp;
1024
1025 if (Z_TYPE_P(var) != IS_OBJECT || zend_hash_find(Z_OBJPROP_P(var), "descriptor", sizeof("descriptor"), (void **)&tmp) == FAILURE) {
1026 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find descriptor property");
1027 return 1;
1028 }
1029
1030 PHP_OCI_ZVAL_TO_DESCRIPTOR_EX(*tmp, bind_descriptor);
1031
1032 value_sz = sizeof(void*);
1033
1034 oci_desc = bind_descriptor->descriptor;
1035
1036 if (!oci_desc) {
1037 return 1;
1038 }
1039 }
1040 break;
1041
1042 case SQLT_INT:
1043 case SQLT_NUM:
1044 if (Z_TYPE_P(var) == IS_RESOURCE || Z_TYPE_P(var) == IS_OBJECT) {
1045 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid variable used for bind");
1046 return 1;
1047 }
1048 convert_to_long(var);
1049 bind_data = (ub4 *)&Z_LVAL_P(var);
1050 value_sz = sizeof(ub4);
1051 mode = OCI_DEFAULT;
1052 break;
1053
1054 case SQLT_LBI:
1055 case SQLT_BIN:
1056 case SQLT_LNG:
1057 case SQLT_AFC:
1058 case SQLT_CHR: /* SQLT_CHR is the default value when type was not specified */
1059 if (Z_TYPE_P(var) == IS_RESOURCE || Z_TYPE_P(var) == IS_OBJECT) {
1060 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid variable used for bind");
1061 return 1;
1062 }
1063 if (Z_TYPE_P(var) != IS_NULL) {
1064 convert_to_string(var);
1065 }
1066 if (maxlength == -1) {
1067 value_sz = (Z_TYPE_P(var) == IS_STRING) ? Z_STRLEN_P(var) : 0;
1068 } else {
1069 value_sz = maxlength;
1070 }
1071 break;
1072
1073 case SQLT_RSET:
1074 if (Z_TYPE_P(var) != IS_RESOURCE) {
1075 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid variable used for bind");
1076 return 1;
1077 }
1078 PHP_OCI_ZVAL_TO_STATEMENT_EX(var, bind_statement);
1079 value_sz = sizeof(void*);
1080
1081 oci_stmt = bind_statement->stmt;
1082
1083 if (!oci_stmt) {
1084 return 1;
1085 }
1086 break;
1087
1088 default:
1089 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown or unsupported datatype given: %d", (int)type);
1090 return 1;
1091 break;
1092 }
1093
1094 if (value_sz == 0) {
1095 value_sz = 1;
1096 }
1097
1098 if (!statement->binds) {
1099 ALLOC_HASHTABLE(statement->binds);
1100 zend_hash_init(statement->binds, 13, NULL, php_oci_bind_hash_dtor, 0);
1101 }
1102
1103 memset((void*)&bind,0,sizeof(php_oci_bind));
1104 if (zend_hash_find(statement->binds, name, name_len + 1, (void **)&old_bind) == SUCCESS) {
1105 bindp = old_bind;
1106 if (bindp->zval) {
1107 zval_ptr_dtor(&bindp->zval);
1108 }
1109 } else {
1110 zend_hash_update(statement->binds, name, name_len + 1, &bind, sizeof(php_oci_bind), (void **)&bindp);
1111 }
1112
1113 bindp->descriptor = oci_desc;
1114 bindp->statement = oci_stmt;
1115 bindp->parent_statement = statement;
1116 bindp->zval = var;
1117 bindp->type = type;
1118 zval_add_ref(&var);
1119
1120 PHP_OCI_CALL_RETURN(statement->errcode,
1121 OCIBindByName,
1122 (
1123 statement->stmt, /* statement handle */
1124 (OCIBind **)&bindp->bind, /* bind hdl (will alloc) */
1125 statement->err, /* error handle */
1126 (text*) name, /* placeholder name */
1127 name_len, /* placeholder length */
1128 (dvoid *)bind_data, /* in/out data */
1129 value_sz, /* PHP_OCI_MAX_DATA_SIZE, */ /* max size of input/output data */
1130 type, /* in/out data type */
1131 (dvoid *)&bindp->indicator, /* indicator (ignored) */
1132 (ub2 *)0, /* size array (ignored) */
1133 (ub2 *)&bindp->retcode, /* return code (ignored) */
1134 (ub4)0, /* maxarr_len (PL/SQL only?) */
1135 (ub4 *)0, /* actual array size (PL/SQL only?) */
1136 mode /* mode */
1137 )
1138 );
1139
1140 if (statement->errcode != OCI_SUCCESS) {
1141 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
1142 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1143 return 1;
1144 }
1145
1146 if (mode == OCI_DATA_AT_EXEC) {
1147 PHP_OCI_CALL_RETURN(statement->errcode, OCIBindDynamic,
1148 (
1149 bindp->bind,
1150 statement->err,
1151 (dvoid *)bindp,
1152 php_oci_bind_in_callback,
1153 (dvoid *)bindp,
1154 php_oci_bind_out_callback
1155 )
1156 );
1157
1158 if (statement->errcode != OCI_SUCCESS) {
1159 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
1160 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1161 return 1;
1162 }
1163 }
1164
1165 if (type == SQLT_NTY) {
1166 /* Bind object */
1167 PHP_OCI_CALL_RETURN(statement->errcode, OCIBindObject,
1168 (
1169 bindp->bind,
1170 statement->err,
1171 bind_collection->tdo,
1172 (dvoid **) &(bind_collection->collection),
1173 (ub4 *) 0,
1174 (dvoid **) 0,
1175 (ub4 *) 0
1176 )
1177 );
1178
1179 if (statement->errcode) {
1180 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
1181 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1182 return 1;
1183 }
1184 }
1185
1186 return 0;
1187 } /* }}} */
1188
1189 /* {{{ php_oci_bind_in_callback()
1190 Callback used when binding LOBs and VARCHARs */
php_oci_bind_in_callback(dvoid * ictxp,OCIBind * bindp,ub4 iter,ub4 index,dvoid ** bufpp,ub4 * alenp,ub1 * piecep,dvoid ** indpp)1191 sb4 php_oci_bind_in_callback(
1192 dvoid *ictxp, /* context pointer */
1193 OCIBind *bindp, /* bind handle */
1194 ub4 iter, /* 0-based execute iteration value */
1195 ub4 index, /* index of current array for PL/SQL or row index for SQL */
1196 dvoid **bufpp, /* pointer to data */
1197 ub4 *alenp, /* size after value/piece has been read */
1198 ub1 *piecep, /* which piece */
1199 dvoid **indpp) /* indicator value */
1200 {
1201 php_oci_bind *phpbind;
1202 zval *val;
1203 TSRMLS_FETCH();
1204
1205 if (!(phpbind=(php_oci_bind *)ictxp) || !(val = phpbind->zval)) {
1206 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid phpbind pointer value");
1207 return OCI_ERROR;
1208 }
1209
1210 if (ZVAL_IS_NULL(val)) {
1211 /* we're going to insert a NULL column */
1212 phpbind->indicator = -1;
1213 *bufpp = 0;
1214 *alenp = -1;
1215 *indpp = (dvoid *)&phpbind->indicator;
1216 } else if ((phpbind->descriptor == 0) && (phpbind->statement == 0)) {
1217 /* "normal string bind */
1218 convert_to_string(val);
1219
1220 *bufpp = Z_STRVAL_P(val);
1221 *alenp = Z_STRLEN_P(val);
1222 *indpp = (dvoid *)&phpbind->indicator;
1223 } else if (phpbind->statement != 0) {
1224 /* RSET */
1225 *bufpp = phpbind->statement;
1226 *alenp = -1; /* seems to be allright */
1227 *indpp = (dvoid *)&phpbind->indicator;
1228 } else {
1229 /* descriptor bind */
1230 *bufpp = phpbind->descriptor;
1231 *alenp = -1; /* seems to be allright */
1232 *indpp = (dvoid *)&phpbind->indicator;
1233 }
1234
1235 *piecep = OCI_ONE_PIECE; /* pass all data in one go */
1236
1237 return OCI_CONTINUE;
1238 }/* }}} */
1239
1240 /* {{{ php_oci_bind_out_callback()
1241 Callback used when binding LOBs and VARCHARs */
php_oci_bind_out_callback(dvoid * octxp,OCIBind * bindp,ub4 iter,ub4 index,dvoid ** bufpp,ub4 ** alenpp,ub1 * piecep,dvoid ** indpp,ub2 ** rcodepp)1242 sb4 php_oci_bind_out_callback(
1243 dvoid *octxp, /* context pointer */
1244 OCIBind *bindp, /* bind handle */
1245 ub4 iter, /* 0-based execute iteration value */
1246 ub4 index, /* index of current array for PL/SQL or row index for SQL */
1247 dvoid **bufpp, /* pointer to data */
1248 ub4 **alenpp, /* size after value/piece has been read */
1249 ub1 *piecep, /* which piece */
1250 dvoid **indpp, /* indicator value */
1251 ub2 **rcodepp) /* return code */
1252 {
1253 php_oci_bind *phpbind;
1254 zval *val;
1255 sb4 retval = OCI_ERROR;
1256 TSRMLS_FETCH();
1257
1258 if (!(phpbind=(php_oci_bind *)octxp) || !(val = phpbind->zval)) {
1259 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid phpbind pointer value");
1260 return retval;
1261 }
1262
1263 if (Z_TYPE_P(val) == IS_RESOURCE) {
1264 /* Processing for ref-cursor out binds */
1265 if (phpbind->statement != NULL) {
1266 *bufpp = phpbind->statement;
1267 *alenpp = &phpbind->dummy_len;
1268 *piecep = OCI_ONE_PIECE;
1269 *rcodepp = &phpbind->retcode;
1270 *indpp = &phpbind->indicator;
1271 }
1272 retval = OCI_CONTINUE;
1273 } else if (Z_TYPE_P(val) == IS_OBJECT) {
1274 zval **tmp;
1275 php_oci_descriptor *desc;
1276
1277 if (!phpbind->descriptor) {
1278 return OCI_ERROR;
1279 }
1280
1281 /* Do not use the cached lob size if the descriptor is an
1282 * out-bind as the contents would have been changed for in/out
1283 * binds (Bug #46994).
1284 */
1285 if (zend_hash_find(Z_OBJPROP_P(val), "descriptor", sizeof("descriptor"), (void **)&tmp) == FAILURE) {
1286 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find object outbind descriptor property");
1287 return OCI_ERROR;
1288 }
1289 PHP_OCI_ZVAL_TO_DESCRIPTOR_EX(*tmp, desc);
1290 desc->lob_size = -1; /* force OCI8 to update cached size */
1291
1292 *alenpp = &phpbind->dummy_len;
1293 *bufpp = phpbind->descriptor;
1294 *piecep = OCI_ONE_PIECE;
1295 *rcodepp = &phpbind->retcode;
1296 *indpp = &phpbind->indicator;
1297 retval = OCI_CONTINUE;
1298 } else {
1299 convert_to_string(val);
1300 zval_dtor(val);
1301
1302 Z_STRLEN_P(val) = PHP_OCI_PIECE_SIZE; /* 64K-1 is max XXX */
1303 Z_STRVAL_P(val) = ecalloc(1, Z_STRLEN_P(phpbind->zval) + 1);
1304
1305 /* XXX we assume that zend-zval len has 4 bytes */
1306 *alenpp = (ub4*) &Z_STRLEN_P(phpbind->zval);
1307 *bufpp = Z_STRVAL_P(phpbind->zval);
1308 *piecep = OCI_ONE_PIECE;
1309 *rcodepp = &phpbind->retcode;
1310 *indpp = &phpbind->indicator;
1311 retval = OCI_CONTINUE;
1312 }
1313
1314 return retval;
1315 }
1316 /* }}} */
1317
1318 /* {{{ php_oci_statement_get_column_helper()
1319 Helper function to get column by name and index */
php_oci_statement_get_column_helper(INTERNAL_FUNCTION_PARAMETERS,int need_data)1320 php_oci_out_column *php_oci_statement_get_column_helper(INTERNAL_FUNCTION_PARAMETERS, int need_data)
1321 {
1322 zval *z_statement, *column_index;
1323 php_oci_statement *statement;
1324 php_oci_out_column *column;
1325
1326 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz", &z_statement, &column_index) == FAILURE) {
1327 return NULL;
1328 }
1329
1330 statement = (php_oci_statement *) zend_fetch_resource(&z_statement TSRMLS_CC, -1, "oci8 statement", NULL, 1, le_statement);
1331
1332 if (!statement) {
1333 return NULL;
1334 }
1335
1336 if (need_data && !statement->has_data) {
1337 return NULL;
1338 }
1339
1340 if (Z_TYPE_P(column_index) == IS_STRING) {
1341 column = php_oci_statement_get_column(statement, -1, Z_STRVAL_P(column_index), Z_STRLEN_P(column_index) TSRMLS_CC);
1342 if (!column) {
1343 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid column name \"%s\"", Z_STRVAL_P(column_index));
1344 return NULL;
1345 }
1346 } else {
1347 zval tmp;
1348 /* NB: for PHP4 compat only, it should be using 'Z' instead */
1349 tmp = *column_index;
1350 zval_copy_ctor(&tmp);
1351 convert_to_long(&tmp);
1352 column = php_oci_statement_get_column(statement, Z_LVAL(tmp), NULL, 0 TSRMLS_CC);
1353 if (!column) {
1354 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid column index \"%ld\"", Z_LVAL(tmp));
1355 zval_dtor(&tmp);
1356 return NULL;
1357 }
1358 zval_dtor(&tmp);
1359 }
1360 return column;
1361 } /* }}} */
1362
1363 /* {{{ php_oci_statement_get_type()
1364 Return type of the statement */
php_oci_statement_get_type(php_oci_statement * statement,ub2 * type TSRMLS_DC)1365 int php_oci_statement_get_type(php_oci_statement *statement, ub2 *type TSRMLS_DC)
1366 {
1367 ub2 statement_type;
1368
1369 *type = 0;
1370
1371 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (ub2 *)&statement_type, (ub4 *)0, OCI_ATTR_STMT_TYPE, statement->err));
1372
1373 if (statement->errcode != OCI_SUCCESS) {
1374 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
1375 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1376 return 1;
1377 }
1378
1379 *type = statement_type;
1380
1381 return 0;
1382 } /* }}} */
1383
1384 /* {{{ php_oci_statement_get_numrows()
1385 Get the number of rows fetched to the clientside (NOT the number of rows in the result set) */
php_oci_statement_get_numrows(php_oci_statement * statement,ub4 * numrows TSRMLS_DC)1386 int php_oci_statement_get_numrows(php_oci_statement *statement, ub4 *numrows TSRMLS_DC)
1387 {
1388 ub4 statement_numrows;
1389
1390 *numrows = 0;
1391
1392 PHP_OCI_CALL_RETURN(statement->errcode, OCIAttrGet, ((dvoid *)statement->stmt, OCI_HTYPE_STMT, (ub4 *)&statement_numrows, (ub4 *)0, OCI_ATTR_ROW_COUNT, statement->err));
1393
1394 if (statement->errcode != OCI_SUCCESS) {
1395 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
1396 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1397 return 1;
1398 }
1399
1400 *numrows = statement_numrows;
1401
1402 return 0;
1403 } /* }}} */
1404
1405 /* {{{ php_oci_bind_array_by_name()
1406 Bind arrays to PL/SQL types */
php_oci_bind_array_by_name(php_oci_statement * statement,char * name,int name_len,zval * var,long max_table_length,long maxlength,long type TSRMLS_DC)1407 int php_oci_bind_array_by_name(php_oci_statement *statement, char *name, int name_len, zval* var, long max_table_length, long maxlength, long type TSRMLS_DC)
1408 {
1409 php_oci_bind *bind, *bindp;
1410
1411 convert_to_array(var);
1412
1413 if (maxlength < -1) {
1414 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid max length value (%ld)", maxlength);
1415 return 1;
1416 }
1417
1418 switch(type) {
1419 case SQLT_NUM:
1420 case SQLT_INT:
1421 case SQLT_LNG:
1422 bind = php_oci_bind_array_helper_number(var, max_table_length TSRMLS_CC);
1423 break;
1424
1425 case SQLT_FLT:
1426 bind = php_oci_bind_array_helper_double(var, max_table_length TSRMLS_CC);
1427 break;
1428
1429 case SQLT_AFC:
1430 case SQLT_CHR:
1431 case SQLT_VCS:
1432 case SQLT_AVC:
1433 case SQLT_STR:
1434 case SQLT_LVC:
1435 if (maxlength == -1 && zend_hash_num_elements(Z_ARRVAL_P(var)) == 0) {
1436 php_error_docref(NULL TSRMLS_CC, E_WARNING, "You must provide max length value for empty arrays");
1437 return 1;
1438 }
1439 bind = php_oci_bind_array_helper_string(var, max_table_length, maxlength TSRMLS_CC);
1440 break;
1441 case SQLT_ODT:
1442 bind = php_oci_bind_array_helper_date(var, max_table_length, statement->connection TSRMLS_CC);
1443 break;
1444 default:
1445 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown or unsupported datatype given: %ld", type);
1446 return 1;
1447 break;
1448 }
1449
1450 if (bind == NULL) {
1451 /* failed to generate bind struct */
1452 return 1;
1453 }
1454
1455 if (!statement->binds) {
1456 ALLOC_HASHTABLE(statement->binds);
1457 zend_hash_init(statement->binds, 13, NULL, php_oci_bind_hash_dtor, 0);
1458 }
1459
1460 zend_hash_update(statement->binds, name, name_len + 1, bind, sizeof(php_oci_bind), (void **)&bindp);
1461
1462 bindp->descriptor = NULL;
1463 bindp->statement = NULL;
1464 bindp->parent_statement = statement;
1465 bindp->bind = NULL;
1466 bindp->zval = var;
1467 bindp->array.type = type;
1468 bindp->indicator = 0; /* not used for array binds */
1469 bindp->type = 0; /* not used for array binds */
1470
1471 zval_add_ref(&var);
1472
1473 PHP_OCI_CALL_RETURN(statement->errcode,
1474 OCIBindByName,
1475 (
1476 statement->stmt,
1477 (OCIBind **)&bindp->bind,
1478 statement->err,
1479 (text *)name,
1480 name_len,
1481 (dvoid *) bindp->array.elements,
1482 (sb4) bind->array.max_length,
1483 (ub2)type,
1484 (dvoid *)bindp->array.indicators,
1485 (ub2 *)bind->array.element_lengths,
1486 (ub2 *)0, /* bindp->array.retcodes, */
1487 (ub4) max_table_length,
1488 (ub4 *) &(bindp->array.current_length),
1489 (ub4) OCI_DEFAULT
1490 )
1491 );
1492
1493
1494 if (statement->errcode != OCI_SUCCESS) {
1495 efree(bind);
1496 statement->errcode = php_oci_error(statement->err, statement->errcode TSRMLS_CC);
1497 PHP_OCI_HANDLE_ERROR(statement->connection, statement->errcode);
1498 return 1;
1499 }
1500 efree(bind);
1501 return 0;
1502 } /* }}} */
1503
1504 /* {{{ php_oci_bind_array_helper_string()
1505 Bind arrays to PL/SQL types */
php_oci_bind_array_helper_string(zval * var,long max_table_length,long maxlength TSRMLS_DC)1506 php_oci_bind *php_oci_bind_array_helper_string(zval* var, long max_table_length, long maxlength TSRMLS_DC)
1507 {
1508 php_oci_bind *bind;
1509 ub4 i;
1510 HashTable *hash;
1511 zval **entry;
1512
1513 hash = HASH_OF(var);
1514
1515 if (maxlength == -1) {
1516 zend_hash_internal_pointer_reset(hash);
1517 while (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE) {
1518 convert_to_string_ex(entry);
1519 if (Z_STRLEN_PP(entry) > maxlength) {
1520 maxlength = Z_STRLEN_PP(entry) + 1;
1521 }
1522 zend_hash_move_forward(hash);
1523 }
1524 }
1525
1526 bind = emalloc(sizeof(php_oci_bind));
1527 bind->array.elements = (text *)safe_emalloc(max_table_length * (maxlength + 1), sizeof(text), 0);
1528 memset(bind->array.elements, 0, max_table_length * (maxlength + 1) * sizeof(text));
1529 bind->array.current_length = zend_hash_num_elements(Z_ARRVAL_P(var));
1530 bind->array.old_length = bind->array.current_length;
1531 bind->array.max_length = maxlength;
1532 bind->array.element_lengths = safe_emalloc(max_table_length, sizeof(ub2), 0);
1533 memset(bind->array.element_lengths, 0, max_table_length*sizeof(ub2));
1534 bind->array.indicators = safe_emalloc(max_table_length, sizeof(sb2), 0);
1535 memset(bind->array.indicators, 0, max_table_length*sizeof(sb2));
1536
1537 zend_hash_internal_pointer_reset(hash);
1538
1539 for (i = 0; i < bind->array.current_length; i++) {
1540 if (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE) {
1541 convert_to_string_ex(entry);
1542 bind->array.element_lengths[i] = Z_STRLEN_PP(entry);
1543 if (Z_STRLEN_PP(entry) == 0) {
1544 bind->array.indicators[i] = -1;
1545 }
1546 zend_hash_move_forward(hash);
1547 } else {
1548 break;
1549 }
1550 }
1551
1552 zend_hash_internal_pointer_reset(hash);
1553 for (i = 0; i < max_table_length; i++) {
1554 if ((i < bind->array.current_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
1555 int element_length;
1556
1557 convert_to_string_ex(entry);
1558 element_length = (maxlength > Z_STRLEN_PP(entry)) ? Z_STRLEN_PP(entry) : maxlength;
1559
1560 memcpy((text *)bind->array.elements + i*maxlength, Z_STRVAL_PP(entry), element_length);
1561 ((text *)bind->array.elements)[i*maxlength + element_length] = '\0';
1562
1563 zend_hash_move_forward(hash);
1564 } else {
1565 ((text *)bind->array.elements)[i*maxlength] = '\0';
1566 }
1567 }
1568 zend_hash_internal_pointer_reset(hash);
1569
1570 return bind;
1571 } /* }}} */
1572
1573 /* {{{ php_oci_bind_array_helper_number()
1574 Bind arrays to PL/SQL types */
php_oci_bind_array_helper_number(zval * var,long max_table_length TSRMLS_DC)1575 php_oci_bind *php_oci_bind_array_helper_number(zval* var, long max_table_length TSRMLS_DC)
1576 {
1577 php_oci_bind *bind;
1578 ub4 i;
1579 HashTable *hash;
1580 zval **entry;
1581
1582 hash = HASH_OF(var);
1583
1584 bind = emalloc(sizeof(php_oci_bind));
1585 bind->array.elements = (ub4 *)safe_emalloc(max_table_length, sizeof(ub4), 0);
1586 bind->array.current_length = zend_hash_num_elements(Z_ARRVAL_P(var));
1587 bind->array.old_length = bind->array.current_length;
1588 bind->array.max_length = sizeof(ub4);
1589 bind->array.element_lengths = safe_emalloc(max_table_length, sizeof(ub2), 0);
1590 memset(bind->array.element_lengths, 0, max_table_length * sizeof(ub2));
1591 bind->array.indicators = NULL;
1592
1593 zend_hash_internal_pointer_reset(hash);
1594 for (i = 0; i < max_table_length; i++) {
1595 if (i < bind->array.current_length) {
1596 bind->array.element_lengths[i] = sizeof(ub4);
1597 }
1598 if ((i < bind->array.current_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
1599 convert_to_long_ex(entry);
1600 ((ub4 *)bind->array.elements)[i] = (ub4) Z_LVAL_PP(entry);
1601 zend_hash_move_forward(hash);
1602 } else {
1603 ((ub4 *)bind->array.elements)[i] = 0;
1604 }
1605 }
1606 zend_hash_internal_pointer_reset(hash);
1607
1608 return bind;
1609 } /* }}} */
1610
1611 /* {{{ php_oci_bind_array_helper_double()
1612 Bind arrays to PL/SQL types */
php_oci_bind_array_helper_double(zval * var,long max_table_length TSRMLS_DC)1613 php_oci_bind *php_oci_bind_array_helper_double(zval* var, long max_table_length TSRMLS_DC)
1614 {
1615 php_oci_bind *bind;
1616 ub4 i;
1617 HashTable *hash;
1618 zval **entry;
1619
1620 hash = HASH_OF(var);
1621
1622 bind = emalloc(sizeof(php_oci_bind));
1623 bind->array.elements = (double *)safe_emalloc(max_table_length, sizeof(double), 0);
1624 bind->array.current_length = zend_hash_num_elements(Z_ARRVAL_P(var));
1625 bind->array.old_length = bind->array.current_length;
1626 bind->array.max_length = sizeof(double);
1627 bind->array.element_lengths = safe_emalloc(max_table_length, sizeof(ub2), 0);
1628 memset(bind->array.element_lengths, 0, max_table_length * sizeof(ub2));
1629 bind->array.indicators = NULL;
1630
1631 zend_hash_internal_pointer_reset(hash);
1632 for (i = 0; i < max_table_length; i++) {
1633 if (i < bind->array.current_length) {
1634 bind->array.element_lengths[i] = sizeof(double);
1635 }
1636 if ((i < bind->array.current_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
1637 convert_to_double_ex(entry);
1638 ((double *)bind->array.elements)[i] = (double) Z_DVAL_PP(entry);
1639 zend_hash_move_forward(hash);
1640 } else {
1641 ((double *)bind->array.elements)[i] = 0;
1642 }
1643 }
1644 zend_hash_internal_pointer_reset(hash);
1645
1646 return bind;
1647 } /* }}} */
1648
1649 /* {{{ php_oci_bind_array_helper_date()
1650 Bind arrays to PL/SQL types */
php_oci_bind_array_helper_date(zval * var,long max_table_length,php_oci_connection * connection TSRMLS_DC)1651 php_oci_bind *php_oci_bind_array_helper_date(zval* var, long max_table_length, php_oci_connection *connection TSRMLS_DC)
1652 {
1653 php_oci_bind *bind;
1654 ub4 i;
1655 HashTable *hash;
1656 zval **entry;
1657
1658 hash = HASH_OF(var);
1659
1660 bind = emalloc(sizeof(php_oci_bind));
1661 bind->array.elements = (OCIDate *)safe_emalloc(max_table_length, sizeof(OCIDate), 0);
1662 bind->array.current_length = zend_hash_num_elements(Z_ARRVAL_P(var));
1663 bind->array.old_length = bind->array.current_length;
1664 bind->array.max_length = sizeof(OCIDate);
1665 bind->array.element_lengths = safe_emalloc(max_table_length, sizeof(ub2), 0);
1666 memset(bind->array.element_lengths, 0, max_table_length * sizeof(ub2));
1667 bind->array.indicators = NULL;
1668
1669 zend_hash_internal_pointer_reset(hash);
1670 for (i = 0; i < max_table_length; i++) {
1671 OCIDate oci_date;
1672 if (i < bind->array.current_length) {
1673 bind->array.element_lengths[i] = sizeof(OCIDate);
1674 }
1675 if ((i < bind->array.current_length) && (zend_hash_get_current_data(hash, (void **) &entry) != FAILURE)) {
1676
1677 convert_to_string_ex(entry);
1678 PHP_OCI_CALL_RETURN(connection->errcode, OCIDateFromText, (connection->err, (CONST text *)Z_STRVAL_PP(entry), Z_STRLEN_PP(entry), NULL, 0, NULL, 0, &oci_date));
1679
1680 if (connection->errcode != OCI_SUCCESS) {
1681 /* failed to convert string to date */
1682 efree(bind->array.element_lengths);
1683 efree(bind->array.elements);
1684 efree(bind);
1685 connection->errcode = php_oci_error(connection->err, connection->errcode TSRMLS_CC);
1686 PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
1687 return NULL;
1688 }
1689
1690 ((OCIDate *)bind->array.elements)[i] = oci_date;
1691 zend_hash_move_forward(hash);
1692 } else {
1693 PHP_OCI_CALL_RETURN(connection->errcode, OCIDateFromText, (connection->err, (CONST text *)"01-JAN-00", sizeof("01-JAN-00")-1, NULL, 0, NULL, 0, &oci_date));
1694
1695 if (connection->errcode != OCI_SUCCESS) {
1696 /* failed to convert string to date */
1697 efree(bind->array.element_lengths);
1698 efree(bind->array.elements);
1699 efree(bind);
1700 connection->errcode = php_oci_error(connection->err, connection->errcode TSRMLS_CC);
1701 PHP_OCI_HANDLE_ERROR(connection, connection->errcode);
1702 return NULL;
1703 }
1704
1705 ((OCIDate *)bind->array.elements)[i] = oci_date;
1706 }
1707 }
1708 zend_hash_internal_pointer_reset(hash);
1709
1710 return bind;
1711 } /* }}} */
1712
1713 #endif /* HAVE_OCI8 */
1714
1715 /*
1716 * Local variables:
1717 * tab-width: 4
1718 * c-basic-offset: 4
1719 * End:
1720 * vim600: noet sw=4 ts=4 fdm=marker
1721 * vim<600: noet sw=4 ts=4
1722 */
1723
