Annotation of embedaddon/php/ext/odbc/php_odbc.c, revision 1.1.1.1
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2012 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: | Andreas Karajannis <Andreas.Karajannis@gmd.de> |
17: | Frank M. Kromann <frank@kromann.info> Support for DB/2 CLI |
18: | Kevin N. Shallow <kshallow@tampabay.rr.com> Birdstep Support|
19: | Daniel R. Kalowsky <kalowsky@php.net> |
20: +----------------------------------------------------------------------+
21: */
22:
23: /* $Id: php_odbc.c 321634 2012-01-01 13:15:04Z felipe $ */
24:
25: #ifdef HAVE_CONFIG_H
26: #include "config.h"
27: #endif
28:
29: #include "php.h"
30: #include "php_globals.h"
31:
32: #include "ext/standard/info.h"
33: #include "ext/standard/php_string.h"
34: #include "ext/standard/php_standard.h"
35:
36: #include "php_odbc.h"
37: #include "php_odbc_includes.h"
38: #include "php_globals.h"
39:
40: #if HAVE_UODBC
41:
42: #include <fcntl.h>
43: #include "ext/standard/head.h"
44: #include "php_ini.h"
45:
46: #ifdef PHP_WIN32
47: #include <winsock2.h>
48:
49: #define ODBC_TYPE "Win32"
50: #define PHP_ODBC_TYPE ODBC_TYPE
51:
52: #endif
53:
54: /*
55: * not defined elsewhere
56: */
57:
58: #ifndef TRUE
59: #define TRUE 1
60: #define FALSE 0
61: #endif
62:
63: void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent);
64:
65: static int le_result, le_conn, le_pconn;
66:
67: #define SAFE_SQL_NTS(n) ((SQLSMALLINT) ((n)?(SQL_NTS):0))
68:
69: /* {{{ arginfo */
70: ZEND_BEGIN_ARG_INFO(arginfo_odbc_close_all, 0)
71: ZEND_END_ARG_INFO()
72:
73: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_binmode, 0, 0, 2)
74: ZEND_ARG_INFO(0, result_id)
75: ZEND_ARG_INFO(0, mode)
76: ZEND_END_ARG_INFO()
77:
78: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_longreadlen, 0, 0, 2)
79: ZEND_ARG_INFO(0, result_id)
80: ZEND_ARG_INFO(0, length)
81: ZEND_END_ARG_INFO()
82:
83: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_prepare, 0, 0, 2)
84: ZEND_ARG_INFO(0, connection_id)
85: ZEND_ARG_INFO(0, query)
86: ZEND_END_ARG_INFO()
87:
88: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_execute, 0, 0, 1)
89: ZEND_ARG_INFO(0, result_id)
90: ZEND_ARG_INFO(0, parameters_array)
91: ZEND_END_ARG_INFO()
92:
93: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_cursor, 0, 0, 1)
94: ZEND_ARG_INFO(0, result_id)
95: ZEND_END_ARG_INFO()
96:
97: #ifdef HAVE_SQLDATASOURCES
98: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_data_source, 0, 0, 2)
99: ZEND_ARG_INFO(0, connection_id)
100: ZEND_ARG_INFO(0, fetch_type)
101: ZEND_END_ARG_INFO()
102: #endif
103:
104: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_exec, 0, 0, 2)
105: ZEND_ARG_INFO(0, connection_id)
106: ZEND_ARG_INFO(0, query)
107: ZEND_ARG_INFO(0, flags)
108: ZEND_END_ARG_INFO()
109:
110: #ifdef PHP_ODBC_HAVE_FETCH_HASH
111: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_object, 0, 0, 1)
112: ZEND_ARG_INFO(0, result)
113: ZEND_ARG_INFO(0, rownumber)
114: ZEND_END_ARG_INFO()
115:
116: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_array, 0, 0, 1)
117: ZEND_ARG_INFO(0, result)
118: ZEND_ARG_INFO(0, rownumber)
119: ZEND_END_ARG_INFO()
120: #endif
121:
122: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_into, 0, 0, 2)
123: ZEND_ARG_INFO(0, result_id)
124: ZEND_ARG_INFO(1, result_array)
125: ZEND_ARG_INFO(0, rownumber)
126: ZEND_END_ARG_INFO()
127:
128: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_fetch_row, 0, 0, 1)
129: ZEND_ARG_INFO(0, result_id)
130: ZEND_ARG_INFO(0, row_number)
131: ZEND_END_ARG_INFO()
132:
133: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_result, 0, 0, 2)
134: ZEND_ARG_INFO(0, result_id)
135: ZEND_ARG_INFO(0, field)
136: ZEND_END_ARG_INFO()
137:
138: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_result_all, 0, 0, 1)
139: ZEND_ARG_INFO(0, result_id)
140: ZEND_ARG_INFO(0, format)
141: ZEND_END_ARG_INFO()
142:
143: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_free_result, 0, 0, 1)
144: ZEND_ARG_INFO(0, result_id)
145: ZEND_END_ARG_INFO()
146:
147: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_connect, 0, 0, 3)
148: ZEND_ARG_INFO(0, dsn)
149: ZEND_ARG_INFO(0, user)
150: ZEND_ARG_INFO(0, password)
151: ZEND_ARG_INFO(0, cursor_option)
152: ZEND_END_ARG_INFO()
153:
154: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_pconnect, 0, 0, 3)
155: ZEND_ARG_INFO(0, dsn)
156: ZEND_ARG_INFO(0, user)
157: ZEND_ARG_INFO(0, password)
158: ZEND_ARG_INFO(0, cursor_option)
159: ZEND_END_ARG_INFO()
160:
161: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_close, 0, 0, 1)
162: ZEND_ARG_INFO(0, connection_id)
163: ZEND_END_ARG_INFO()
164:
165: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_num_rows, 0, 0, 1)
166: ZEND_ARG_INFO(0, result_id)
167: ZEND_END_ARG_INFO()
168:
169: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30)
170: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_next_result, 0, 0, 1)
171: ZEND_ARG_INFO(0, result_id)
172: ZEND_END_ARG_INFO()
173: #endif
174:
175: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_num_fields, 0, 0, 1)
176: ZEND_ARG_INFO(0, result_id)
177: ZEND_END_ARG_INFO()
178:
179: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_name, 0, 0, 2)
180: ZEND_ARG_INFO(0, result_id)
181: ZEND_ARG_INFO(0, field_number)
182: ZEND_END_ARG_INFO()
183:
184: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_type, 0, 0, 2)
185: ZEND_ARG_INFO(0, result_id)
186: ZEND_ARG_INFO(0, field_number)
187: ZEND_END_ARG_INFO()
188:
189: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_len, 0, 0, 2)
190: ZEND_ARG_INFO(0, result_id)
191: ZEND_ARG_INFO(0, field_number)
192: ZEND_END_ARG_INFO()
193:
194: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_scale, 0, 0, 2)
195: ZEND_ARG_INFO(0, result_id)
196: ZEND_ARG_INFO(0, field_number)
197: ZEND_END_ARG_INFO()
198:
199: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_field_num, 0, 0, 2)
200: ZEND_ARG_INFO(0, result_id)
201: ZEND_ARG_INFO(0, field_name)
202: ZEND_END_ARG_INFO()
203:
204: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_autocommit, 0, 0, 1)
205: ZEND_ARG_INFO(0, connection_id)
206: ZEND_ARG_INFO(0, onoff)
207: ZEND_END_ARG_INFO()
208:
209: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_commit, 0, 0, 1)
210: ZEND_ARG_INFO(0, connection_id)
211: ZEND_END_ARG_INFO()
212:
213: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_rollback, 0, 0, 1)
214: ZEND_ARG_INFO(0, connection_id)
215: ZEND_END_ARG_INFO()
216:
217: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_error, 0, 0, 0)
218: ZEND_ARG_INFO(0, connection_id)
219: ZEND_END_ARG_INFO()
220:
221: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_errormsg, 0, 0, 0)
222: ZEND_ARG_INFO(0, connection_id)
223: ZEND_END_ARG_INFO()
224:
225: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_setoption, 0, 0, 4)
226: ZEND_ARG_INFO(0, conn_id)
227: ZEND_ARG_INFO(0, which)
228: ZEND_ARG_INFO(0, option)
229: ZEND_ARG_INFO(0, value)
230: ZEND_END_ARG_INFO()
231:
232: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_tables, 0, 0, 1)
233: ZEND_ARG_INFO(0, connection_id)
234: ZEND_ARG_INFO(0, qualifier)
235: ZEND_ARG_INFO(0, owner)
236: ZEND_ARG_INFO(0, name)
237: ZEND_ARG_INFO(0, table_types)
238: ZEND_END_ARG_INFO()
239:
240: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_columns, 0, 0, 1)
241: ZEND_ARG_INFO(0, connection_id)
242: ZEND_ARG_INFO(0, qualifier)
243: ZEND_ARG_INFO(0, owner)
244: ZEND_ARG_INFO(0, table_name)
245: ZEND_ARG_INFO(0, column_name)
246: ZEND_END_ARG_INFO()
247:
248: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_gettypeinfo, 0, 0, 1)
249: ZEND_ARG_INFO(0, connection_id)
250: ZEND_ARG_INFO(0, data_type)
251: ZEND_END_ARG_INFO()
252:
253: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_primarykeys, 0, 0, 4)
254: ZEND_ARG_INFO(0, connection_id)
255: ZEND_ARG_INFO(0, qualifier)
256: ZEND_ARG_INFO(0, owner)
257: ZEND_ARG_INFO(0, table)
258: ZEND_END_ARG_INFO()
259:
260: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35)
261: #if !defined(HAVE_BIRDSTEP)
262: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_procedurecolumns, 0, 0, 1)
263: ZEND_ARG_INFO(0, connection_id)
264: ZEND_ARG_INFO(0, qualifier)
265: ZEND_ARG_INFO(0, owner)
266: ZEND_ARG_INFO(0, proc)
267: ZEND_ARG_INFO(0, column)
268: ZEND_END_ARG_INFO()
269: #endif
270:
271: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_procedures, 0, 0, 1)
272: ZEND_ARG_INFO(0, connection_id)
273: ZEND_ARG_INFO(0, qualifier)
274: ZEND_ARG_INFO(0, owner)
275: ZEND_ARG_INFO(0, name)
276: ZEND_END_ARG_INFO()
277:
278: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_foreignkeys, 0, 0, 7)
279: ZEND_ARG_INFO(0, connection_id)
280: ZEND_ARG_INFO(0, pk_qualifier)
281: ZEND_ARG_INFO(0, pk_owner)
282: ZEND_ARG_INFO(0, pk_table)
283: ZEND_ARG_INFO(0, fk_qualifier)
284: ZEND_ARG_INFO(0, fk_owner)
285: ZEND_ARG_INFO(0, fk_table)
286: ZEND_END_ARG_INFO()
287: #endif
288:
289: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_specialcolumns, 0, 0, 7)
290: ZEND_ARG_INFO(0, connection_id)
291: ZEND_ARG_INFO(0, type)
292: ZEND_ARG_INFO(0, qualifier)
293: ZEND_ARG_INFO(0, owner)
294: ZEND_ARG_INFO(0, table)
295: ZEND_ARG_INFO(0, scope)
296: ZEND_ARG_INFO(0, nullable)
297: ZEND_END_ARG_INFO()
298:
299: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_statistics, 0, 0, 6)
300: ZEND_ARG_INFO(0, connection_id)
301: ZEND_ARG_INFO(0, qualifier)
302: ZEND_ARG_INFO(0, owner)
303: ZEND_ARG_INFO(0, name)
304: ZEND_ARG_INFO(0, unique)
305: ZEND_ARG_INFO(0, accuracy)
306: ZEND_END_ARG_INFO()
307:
308: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) &&!defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP)
309: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_tableprivileges, 0, 0, 4)
310: ZEND_ARG_INFO(0, connection_id)
311: ZEND_ARG_INFO(0, qualifier)
312: ZEND_ARG_INFO(0, owner)
313: ZEND_ARG_INFO(0, name)
314: ZEND_END_ARG_INFO()
315:
316: ZEND_BEGIN_ARG_INFO_EX(arginfo_odbc_columnprivileges, 0, 0, 5)
317: ZEND_ARG_INFO(0, connection_id)
318: ZEND_ARG_INFO(0, catalog)
319: ZEND_ARG_INFO(0, schema)
320: ZEND_ARG_INFO(0, table)
321: ZEND_ARG_INFO(0, column)
322: ZEND_END_ARG_INFO()
323: #endif
324: /* }}} */
325:
326: /* {{{ odbc_functions[]
327: */
328: const zend_function_entry odbc_functions[] = {
329: PHP_FE(odbc_autocommit, arginfo_odbc_autocommit)
330: PHP_FE(odbc_binmode, arginfo_odbc_binmode)
331: PHP_FE(odbc_close, arginfo_odbc_close)
332: PHP_FE(odbc_close_all, arginfo_odbc_close_all)
333: PHP_FE(odbc_columns, arginfo_odbc_columns)
334: PHP_FE(odbc_commit, arginfo_odbc_commit)
335: PHP_FE(odbc_connect, arginfo_odbc_connect)
336: PHP_FE(odbc_cursor, arginfo_odbc_cursor)
337: #ifdef HAVE_SQLDATASOURCES
338: PHP_FE(odbc_data_source, arginfo_odbc_data_source)
339: #endif
340: PHP_FE(odbc_execute, arginfo_odbc_execute)
341: PHP_FE(odbc_error, arginfo_odbc_error)
342: PHP_FE(odbc_errormsg, arginfo_odbc_errormsg)
343: PHP_FE(odbc_exec, arginfo_odbc_exec)
344: #ifdef PHP_ODBC_HAVE_FETCH_HASH
345: PHP_FE(odbc_fetch_array, arginfo_odbc_fetch_array)
346: PHP_FE(odbc_fetch_object, arginfo_odbc_fetch_object)
347: #endif
348: PHP_FE(odbc_fetch_row, arginfo_odbc_fetch_row)
349: PHP_FE(odbc_fetch_into, arginfo_odbc_fetch_into)
350: PHP_FE(odbc_field_len, arginfo_odbc_field_len)
351: PHP_FE(odbc_field_scale, arginfo_odbc_field_scale)
352: PHP_FE(odbc_field_name, arginfo_odbc_field_name)
353: PHP_FE(odbc_field_type, arginfo_odbc_field_type)
354: PHP_FE(odbc_field_num, arginfo_odbc_field_num)
355: PHP_FE(odbc_free_result, arginfo_odbc_free_result)
356: PHP_FE(odbc_gettypeinfo, arginfo_odbc_gettypeinfo)
357: PHP_FE(odbc_longreadlen, arginfo_odbc_longreadlen)
358: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30)
359: PHP_FE(odbc_next_result, arginfo_odbc_next_result)
360: #endif
361: PHP_FE(odbc_num_fields, arginfo_odbc_num_fields)
362: PHP_FE(odbc_num_rows, arginfo_odbc_num_rows)
363: PHP_FE(odbc_pconnect, arginfo_odbc_pconnect)
364: PHP_FE(odbc_prepare, arginfo_odbc_prepare)
365: PHP_FE(odbc_result, arginfo_odbc_result)
366: PHP_FE(odbc_result_all, arginfo_odbc_result_all)
367: PHP_FE(odbc_rollback, arginfo_odbc_rollback)
368: PHP_FE(odbc_setoption, arginfo_odbc_setoption)
369: PHP_FE(odbc_specialcolumns, arginfo_odbc_specialcolumns)
370: PHP_FE(odbc_statistics, arginfo_odbc_statistics)
371: PHP_FE(odbc_tables, arginfo_odbc_tables)
372: PHP_FE(odbc_primarykeys, arginfo_odbc_primarykeys)
373: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) &&!defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP) /* not supported now */
374: PHP_FE(odbc_columnprivileges, arginfo_odbc_columnprivileges)
375: PHP_FE(odbc_tableprivileges, arginfo_odbc_tableprivileges)
376: #endif
377: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) /* not supported */
378: PHP_FE(odbc_foreignkeys, arginfo_odbc_foreignkeys)
379: PHP_FE(odbc_procedures, arginfo_odbc_procedures)
380: #if !defined(HAVE_BIRDSTEP)
381: PHP_FE(odbc_procedurecolumns, arginfo_odbc_procedurecolumns)
382: #endif
383: #endif
384: PHP_FALIAS(odbc_do, odbc_exec, arginfo_odbc_exec)
385: PHP_FALIAS(odbc_field_precision, odbc_field_len, arginfo_odbc_field_len)
386: PHP_FE_END
387: };
388: /* }}} */
389:
390: ZEND_DECLARE_MODULE_GLOBALS(odbc);
391: static PHP_GINIT_FUNCTION(odbc);
392:
393: /* {{{ odbc_module_entry
394: */
395: zend_module_entry odbc_module_entry = {
396: STANDARD_MODULE_HEADER,
397: "odbc",
398: odbc_functions,
399: PHP_MINIT(odbc),
400: PHP_MSHUTDOWN(odbc),
401: PHP_RINIT(odbc),
402: PHP_RSHUTDOWN(odbc),
403: PHP_MINFO(odbc),
404: "1.0",
405: PHP_MODULE_GLOBALS(odbc),
406: PHP_GINIT(odbc),
407: NULL,
408: NULL,
409: STANDARD_MODULE_PROPERTIES_EX
410: };
411: /* }}} */
412:
413: #ifdef COMPILE_DL_ODBC
414: ZEND_GET_MODULE(odbc)
415: #endif
416:
417: /* {{{ _free_odbc_result
418: */
419: static void _free_odbc_result(zend_rsrc_list_entry *rsrc TSRMLS_DC)
420: {
421: odbc_result *res = (odbc_result *)rsrc->ptr;
422: int i;
423: RETCODE rc;
424:
425: if (res) {
426: if (res->values) {
427: for(i = 0; i < res->numcols; i++) {
428: if (res->values[i].value)
429: efree(res->values[i].value);
430: }
431: efree(res->values);
432: res->values = NULL;
433: }
434: if (res->stmt) {
435: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30) || defined(HAVE_SOLID_35)
436: SQLTransact(res->conn_ptr->henv, res->conn_ptr->hdbc,
437: (SQLUSMALLINT) SQL_COMMIT);
438: #endif
439: rc = SQLFreeStmt(res->stmt,SQL_DROP);
440: /* We don't want the connection to be closed after the last statment has been closed
441: * Connections will be closed on shutdown
442: * zend_list_delete(res->conn_ptr->id);
443: */
444: }
445: efree(res);
446: }
447: }
448: /* }}} */
449:
450: /* {{{ safe_odbc_disconnect
451: * disconnect, and if it fails, then issue a rollback for any pending transaction (lurcher)
452: */
453: static void safe_odbc_disconnect( void *handle )
454: {
455: int ret;
456:
457: ret = SQLDisconnect( handle );
458: if ( ret == SQL_ERROR )
459: {
460: SQLTransact( NULL, handle, SQL_ROLLBACK );
461: SQLDisconnect( handle );
462: }
463: }
464: /* }}} */
465:
466: /* {{{ _close_odbc_conn
467: */
468: static void _close_odbc_conn(zend_rsrc_list_entry *rsrc TSRMLS_DC)
469: {
470: int i, nument, type;
471: void *ptr;
472: odbc_result *res;
473:
474: odbc_connection *conn = (odbc_connection *)rsrc->ptr;
475:
476: nument = zend_hash_next_free_element(&EG(regular_list));
477: for(i = 1; i < nument; i++) {
478: ptr = zend_list_find(i, &type);
479: if (ptr && (type == le_result)) {
480: res = (odbc_result *)ptr;
481: if (res->conn_ptr == conn) {
482: zend_list_delete(i);
483: }
484: }
485: }
486:
487: safe_odbc_disconnect(conn->hdbc);
488: SQLFreeConnect(conn->hdbc);
489: SQLFreeEnv(conn->henv);
490: efree(conn);
491: ODBCG(num_links)--;
492: }
493: /* }}} */
494:
495: /* {{{ void _close_odbc_pconn
496: */
497: static void _close_odbc_pconn(zend_rsrc_list_entry *rsrc TSRMLS_DC)
498: {
499: int i, nument, type;
500: void *ptr;
501: odbc_result *res;
502: odbc_connection *conn = (odbc_connection *)rsrc->ptr;
503:
504: nument = zend_hash_next_free_element(&EG(persistent_list));
505: for(i = 1; i < nument; i++) {
506: ptr = zend_list_find(i, &type);
507: if (ptr && (type == le_result)) {
508: res = (odbc_result *)ptr;
509: if (res->conn_ptr == conn) {
510: zend_list_delete(i);
511: }
512: }
513: }
514:
515: safe_odbc_disconnect(conn->hdbc);
516: SQLFreeConnect(conn->hdbc);
517: SQLFreeEnv(conn->henv);
518: free(conn);
519:
520: ODBCG(num_links)--;
521: ODBCG(num_persistent)--;
522: }
523: /* }}} */
524:
525: /* {{{ PHP_INI_DISP(display_link_nums)
526: */
527: static PHP_INI_DISP(display_link_nums)
528: {
529: char *value;
530: TSRMLS_FETCH();
531:
532: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
533: value = ini_entry->orig_value;
534: } else if (ini_entry->value) {
535: value = ini_entry->value;
536: } else {
537: value = NULL;
538: }
539:
540: if (value) {
541: if (atoi(value) == -1) {
542: PUTS("Unlimited");
543: } else {
544: php_printf("%s", value);
545: }
546: }
547: }
548: /* }}} */
549:
550: /* {{{ PHP_INI_DISP(display_defPW)
551: */
552: static PHP_INI_DISP(display_defPW)
553: {
554: char *value;
555: TSRMLS_FETCH();
556:
557: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
558: value = ini_entry->orig_value;
559: } else if (ini_entry->value) {
560: value = ini_entry->value;
561: } else {
562: value = NULL;
563: }
564:
565: if (value) {
566: #if PHP_DEBUG
567: php_printf("%s", value);
568: #else
569: PUTS("********");
570: #endif
571: } else {
572: if (PG(html_errors)) {
573: PUTS("<i>no value</i>");
574: } else {
575: PUTS("no value");
576: }
577: }
578: }
579: /* }}} */
580:
581: /* {{{ PHP_INI_DISP(display_binmode)
582: */
583: static PHP_INI_DISP(display_binmode)
584: {
585: char *value;
586: TSRMLS_FETCH();
587:
588: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
589: value = ini_entry->orig_value;
590: } else if (ini_entry->value) {
591: value = ini_entry->value;
592: } else {
593: value = NULL;
594: }
595:
596: if (value) {
597: switch(atoi(value)) {
598: case 0:
599: PUTS("passthru");
600: break;
601: case 1:
602: PUTS("return as is");
603: break;
604: case 2:
605: PUTS("return as char");
606: break;
607: }
608: }
609: }
610: /* }}} */
611:
612: /* {{{ PHP_INI_DISP(display_lrl)
613: */
614: static PHP_INI_DISP(display_lrl)
615: {
616: char *value;
617: TSRMLS_FETCH();
618:
619: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
620: value = ini_entry->orig_value;
621: } else if (ini_entry->value) {
622: value = ini_entry->value;
623: } else {
624: value = NULL;
625: }
626:
627: if (value) {
628: if (atoi(value) <= 0) {
629: PUTS("Passthru");
630: } else {
631: php_printf("return up to %s bytes", value);
632: }
633: }
634: }
635: /* }}} */
636:
637:
638: /* {{{ PHP_INI_DISP(display_cursortype)
639: */
640: static PHP_INI_DISP(display_cursortype)
641: {
642: char *value;
643: TSRMLS_FETCH();
644:
645: if (type == PHP_INI_DISPLAY_ORIG && ini_entry->modified) {
646: value = ini_entry->orig_value;
647: } else if (ini_entry->value) {
648: value = ini_entry->value;
649: } else {
650: value = NULL;
651: }
652:
653: if (value) {
654: switch (atoi (value))
655: {
656: case SQL_CURSOR_FORWARD_ONLY:
657: PUTS ("Forward Only cursor");
658: break;
659:
660: case SQL_CURSOR_STATIC:
661: PUTS ("Static cursor");
662: break;
663:
664: case SQL_CURSOR_KEYSET_DRIVEN:
665: PUTS ("Keyset driven cursor");
666: break;
667:
668: case SQL_CURSOR_DYNAMIC:
669: PUTS ("Dynamic cursor");
670: break;
671:
672: default:
673: php_printf("Unknown cursor model %s", value);
674: break;
675: }
676: }
677: }
678:
679: /* }}} */
680:
681: /* {{{ PHP_INI_BEGIN
682: */
683: PHP_INI_BEGIN()
684: STD_PHP_INI_BOOLEAN("odbc.allow_persistent", "1", PHP_INI_SYSTEM, OnUpdateLong,
685: allow_persistent, zend_odbc_globals, odbc_globals)
686: STD_PHP_INI_ENTRY_EX("odbc.max_persistent", "-1", PHP_INI_SYSTEM, OnUpdateLong,
687: max_persistent, zend_odbc_globals, odbc_globals, display_link_nums)
688: STD_PHP_INI_ENTRY_EX("odbc.max_links", "-1", PHP_INI_SYSTEM, OnUpdateLong,
689: max_links, zend_odbc_globals, odbc_globals, display_link_nums)
690: STD_PHP_INI_ENTRY("odbc.default_db", NULL, PHP_INI_ALL, OnUpdateString,
691: defDB, zend_odbc_globals, odbc_globals)
692: STD_PHP_INI_ENTRY("odbc.default_user", NULL, PHP_INI_ALL, OnUpdateString,
693: defUser, zend_odbc_globals, odbc_globals)
694: STD_PHP_INI_ENTRY_EX("odbc.default_pw", NULL, PHP_INI_ALL, OnUpdateString,
695: defPW, zend_odbc_globals, odbc_globals, display_defPW)
696: STD_PHP_INI_ENTRY_EX("odbc.defaultlrl", "4096", PHP_INI_ALL, OnUpdateLong,
697: defaultlrl, zend_odbc_globals, odbc_globals, display_lrl)
698: STD_PHP_INI_ENTRY_EX("odbc.defaultbinmode", "1", PHP_INI_ALL, OnUpdateLong,
699: defaultbinmode, zend_odbc_globals, odbc_globals, display_binmode)
700: STD_PHP_INI_BOOLEAN("odbc.check_persistent", "1", PHP_INI_SYSTEM, OnUpdateLong,
701: check_persistent, zend_odbc_globals, odbc_globals)
702: STD_PHP_INI_ENTRY_EX("odbc.default_cursortype", "3", PHP_INI_ALL, OnUpdateLong,
703: default_cursortype, zend_odbc_globals, odbc_globals, display_cursortype)
704: PHP_INI_END()
705: /* }}} */
706:
707: static PHP_GINIT_FUNCTION(odbc)
708: {
709: odbc_globals->num_persistent = 0;
710: }
711:
712: /* {{{ PHP_MINIT_FUNCTION */
713: PHP_MINIT_FUNCTION(odbc)
714: {
715: #ifdef SQLANY_BUG
716: ODBC_SQL_CONN_T foobar;
717: RETCODE rc;
718: #endif
719:
720: REGISTER_INI_ENTRIES();
721: le_result = zend_register_list_destructors_ex(_free_odbc_result, NULL, "odbc result", module_number);
722: le_conn = zend_register_list_destructors_ex(_close_odbc_conn, NULL, "odbc link", module_number);
723: le_pconn = zend_register_list_destructors_ex(NULL, _close_odbc_pconn, "odbc link persistent", module_number);
724: Z_TYPE(odbc_module_entry) = type;
725:
726: REGISTER_STRING_CONSTANT("ODBC_TYPE", PHP_ODBC_TYPE, CONST_CS | CONST_PERSISTENT);
727: REGISTER_LONG_CONSTANT("ODBC_BINMODE_PASSTHRU", 0, CONST_CS | CONST_PERSISTENT);
728: REGISTER_LONG_CONSTANT("ODBC_BINMODE_RETURN", 1, CONST_CS | CONST_PERSISTENT);
729: REGISTER_LONG_CONSTANT("ODBC_BINMODE_CONVERT", 2, CONST_CS | CONST_PERSISTENT);
730: /* Define Constants for options
731: these Constants are defined in <sqlext.h>
732: */
733: REGISTER_LONG_CONSTANT("SQL_ODBC_CURSORS", SQL_ODBC_CURSORS, CONST_PERSISTENT | CONST_CS);
734: REGISTER_LONG_CONSTANT("SQL_CUR_USE_DRIVER", SQL_CUR_USE_DRIVER, CONST_PERSISTENT | CONST_CS);
735: REGISTER_LONG_CONSTANT("SQL_CUR_USE_IF_NEEDED", SQL_CUR_USE_IF_NEEDED, CONST_PERSISTENT | CONST_CS);
736: REGISTER_LONG_CONSTANT("SQL_CUR_USE_ODBC", SQL_CUR_USE_ODBC, CONST_PERSISTENT | CONST_CS);
737:
738:
739: REGISTER_LONG_CONSTANT("SQL_CONCURRENCY", SQL_CONCURRENCY, CONST_PERSISTENT | CONST_CS);
740: REGISTER_LONG_CONSTANT("SQL_CONCUR_READ_ONLY", SQL_CONCUR_READ_ONLY, CONST_PERSISTENT | CONST_CS);
741: REGISTER_LONG_CONSTANT("SQL_CONCUR_LOCK", SQL_CONCUR_LOCK, CONST_PERSISTENT | CONST_CS);
742: REGISTER_LONG_CONSTANT("SQL_CONCUR_ROWVER", SQL_CONCUR_ROWVER, CONST_PERSISTENT | CONST_CS);
743: REGISTER_LONG_CONSTANT("SQL_CONCUR_VALUES", SQL_CONCUR_VALUES, CONST_PERSISTENT | CONST_CS);
744:
745: REGISTER_LONG_CONSTANT("SQL_CURSOR_TYPE", SQL_CURSOR_TYPE, CONST_PERSISTENT | CONST_CS);
746: REGISTER_LONG_CONSTANT("SQL_CURSOR_FORWARD_ONLY", SQL_CURSOR_FORWARD_ONLY, CONST_PERSISTENT | CONST_CS);
747: REGISTER_LONG_CONSTANT("SQL_CURSOR_KEYSET_DRIVEN", SQL_CURSOR_KEYSET_DRIVEN, CONST_PERSISTENT | CONST_CS);
748: REGISTER_LONG_CONSTANT("SQL_CURSOR_DYNAMIC", SQL_CURSOR_DYNAMIC, CONST_PERSISTENT | CONST_CS);
749: REGISTER_LONG_CONSTANT("SQL_CURSOR_STATIC", SQL_CURSOR_STATIC, CONST_PERSISTENT | CONST_CS);
750:
751: REGISTER_LONG_CONSTANT("SQL_KEYSET_SIZE", SQL_KEYSET_SIZE, CONST_PERSISTENT | CONST_CS);
752:
753: /* these are for the Data Source type */
754: REGISTER_LONG_CONSTANT("SQL_FETCH_FIRST", SQL_FETCH_FIRST, CONST_PERSISTENT | CONST_CS);
755: REGISTER_LONG_CONSTANT("SQL_FETCH_NEXT", SQL_FETCH_NEXT, CONST_PERSISTENT | CONST_CS);
756:
757: /*
758: * register the standard data types
759: */
760: REGISTER_LONG_CONSTANT("SQL_CHAR", SQL_CHAR, CONST_PERSISTENT | CONST_CS);
761: REGISTER_LONG_CONSTANT("SQL_VARCHAR", SQL_VARCHAR, CONST_PERSISTENT | CONST_CS);
762: REGISTER_LONG_CONSTANT("SQL_LONGVARCHAR", SQL_LONGVARCHAR, CONST_PERSISTENT | CONST_CS);
763: REGISTER_LONG_CONSTANT("SQL_DECIMAL", SQL_DECIMAL, CONST_PERSISTENT | CONST_CS);
764: REGISTER_LONG_CONSTANT("SQL_NUMERIC", SQL_NUMERIC, CONST_PERSISTENT | CONST_CS);
765: REGISTER_LONG_CONSTANT("SQL_BIT", SQL_BIT, CONST_PERSISTENT | CONST_CS);
766: REGISTER_LONG_CONSTANT("SQL_TINYINT", SQL_TINYINT, CONST_PERSISTENT | CONST_CS);
767: REGISTER_LONG_CONSTANT("SQL_SMALLINT", SQL_SMALLINT, CONST_PERSISTENT | CONST_CS);
768: REGISTER_LONG_CONSTANT("SQL_INTEGER", SQL_INTEGER, CONST_PERSISTENT | CONST_CS);
769: REGISTER_LONG_CONSTANT("SQL_BIGINT", SQL_BIGINT, CONST_PERSISTENT | CONST_CS);
770: REGISTER_LONG_CONSTANT("SQL_REAL", SQL_REAL, CONST_PERSISTENT | CONST_CS);
771: REGISTER_LONG_CONSTANT("SQL_FLOAT", SQL_FLOAT, CONST_PERSISTENT | CONST_CS);
772: REGISTER_LONG_CONSTANT("SQL_DOUBLE", SQL_DOUBLE, CONST_PERSISTENT | CONST_CS);
773: REGISTER_LONG_CONSTANT("SQL_BINARY", SQL_BINARY, CONST_PERSISTENT | CONST_CS);
774: REGISTER_LONG_CONSTANT("SQL_VARBINARY", SQL_VARBINARY, CONST_PERSISTENT | CONST_CS);
775: REGISTER_LONG_CONSTANT("SQL_LONGVARBINARY", SQL_LONGVARBINARY, CONST_PERSISTENT | CONST_CS);
776: REGISTER_LONG_CONSTANT("SQL_DATE", SQL_DATE, CONST_PERSISTENT | CONST_CS);
777: REGISTER_LONG_CONSTANT("SQL_TIME", SQL_TIME, CONST_PERSISTENT | CONST_CS);
778: REGISTER_LONG_CONSTANT("SQL_TIMESTAMP", SQL_TIMESTAMP, CONST_PERSISTENT | CONST_CS);
779: #if defined(ODBCVER) && (ODBCVER >= 0x0300)
780: REGISTER_LONG_CONSTANT("SQL_TYPE_DATE", SQL_TYPE_DATE, CONST_PERSISTENT | CONST_CS);
781: REGISTER_LONG_CONSTANT("SQL_TYPE_TIME", SQL_TYPE_TIME, CONST_PERSISTENT | CONST_CS);
782: REGISTER_LONG_CONSTANT("SQL_TYPE_TIMESTAMP", SQL_TYPE_TIMESTAMP, CONST_PERSISTENT | CONST_CS);
783:
784: /*
785: * SQLSpecialColumns values
786: */
787: REGISTER_LONG_CONSTANT("SQL_BEST_ROWID", SQL_BEST_ROWID, CONST_PERSISTENT | CONST_CS);
788: REGISTER_LONG_CONSTANT("SQL_ROWVER", SQL_ROWVER, CONST_PERSISTENT | CONST_CS);
789: REGISTER_LONG_CONSTANT("SQL_SCOPE_CURROW", SQL_SCOPE_CURROW, CONST_PERSISTENT | CONST_CS);
790: REGISTER_LONG_CONSTANT("SQL_SCOPE_TRANSACTION", SQL_SCOPE_TRANSACTION, CONST_PERSISTENT | CONST_CS);
791: REGISTER_LONG_CONSTANT("SQL_SCOPE_SESSION", SQL_SCOPE_SESSION, CONST_PERSISTENT | CONST_CS);
792: REGISTER_LONG_CONSTANT("SQL_NO_NULLS", SQL_NO_NULLS, CONST_PERSISTENT | CONST_CS);
793: REGISTER_LONG_CONSTANT("SQL_NULLABLE", SQL_NULLABLE, CONST_PERSISTENT | CONST_CS);
794:
795: /*
796: * SQLStatistics values
797: */
798: REGISTER_LONG_CONSTANT("SQL_INDEX_UNIQUE", SQL_INDEX_UNIQUE, CONST_PERSISTENT | CONST_CS);
799: REGISTER_LONG_CONSTANT("SQL_INDEX_ALL", SQL_INDEX_ALL, CONST_PERSISTENT | CONST_CS);
800: REGISTER_LONG_CONSTANT("SQL_ENSURE", SQL_ENSURE, CONST_PERSISTENT | CONST_CS);
801: REGISTER_LONG_CONSTANT("SQL_QUICK", SQL_QUICK, CONST_PERSISTENT | CONST_CS);
802: #endif
803:
804: #if defined(HAVE_IBMDB2) && defined(_AIX)
805: /* atexit() handler in the DB2/AIX library segfaults in PHP CLI */
806: /* DB2NOEXITLIST env variable prevents DB2 from invoking atexit() */
807: putenv("DB2NOEXITLIST=TRUE");
808: #endif
809:
810: return SUCCESS;
811: }
812: /* }}} */
813:
814: /* {{{ PHP_RINIT_FUNCTION */
815: PHP_RINIT_FUNCTION(odbc)
816: {
817: ODBCG(defConn) = -1;
818: ODBCG(num_links) = ODBCG(num_persistent);
819: memset(ODBCG(laststate), '\0', 6);
820: memset(ODBCG(lasterrormsg), '\0', SQL_MAX_MESSAGE_LENGTH);
821: return SUCCESS;
822: }
823: /* }}} */
824:
825: /* {{{ PHP_RSHUTDOWN_FUNCTION */
826: PHP_RSHUTDOWN_FUNCTION(odbc)
827: {
828: return SUCCESS;
829: }
830: /* }}} */
831:
832: /* {{{ PHP_MSHUTDOWN_FUNCTION */
833: PHP_MSHUTDOWN_FUNCTION(odbc)
834: {
835: UNREGISTER_INI_ENTRIES();
836: return SUCCESS;
837: }
838: /* }}} */
839:
840: /* {{{ PHP_MINFO_FUNCTION */
841: PHP_MINFO_FUNCTION(odbc)
842: {
843: char buf[32];
844:
845: php_info_print_table_start();
846: php_info_print_table_header(2, "ODBC Support", "enabled");
847: snprintf(buf, sizeof(buf), "%ld", ODBCG(num_persistent));
848: php_info_print_table_row(2, "Active Persistent Links", buf);
849: snprintf(buf, sizeof(buf), "%ld", ODBCG(num_links));
850: php_info_print_table_row(2, "Active Links", buf);
851: php_info_print_table_row(2, "ODBC library", PHP_ODBC_TYPE);
852: #ifndef PHP_WIN32
853: php_info_print_table_row(2, "ODBC_INCLUDE", PHP_ODBC_INCLUDE);
854: php_info_print_table_row(2, "ODBC_LFLAGS", PHP_ODBC_LFLAGS);
855: php_info_print_table_row(2, "ODBC_LIBS", PHP_ODBC_LIBS);
856: #endif
857: php_info_print_table_end();
858:
859: DISPLAY_INI_ENTRIES();
860:
861: }
862: /* }}} */
863:
864: /* {{{ odbc_sql_error */
865: void odbc_sql_error(ODBC_SQL_ERROR_PARAMS)
866: {
867: char state[6];
868: SQLINTEGER error; /* Not used */
869: char errormsg[SQL_MAX_MESSAGE_LENGTH];
870: SQLSMALLINT errormsgsize; /* Not used */
871: RETCODE rc;
872: ODBC_SQL_ENV_T henv;
873: ODBC_SQL_CONN_T conn;
874: TSRMLS_FETCH();
875:
876: if (conn_resource) {
877: henv = conn_resource->henv;
878: conn = conn_resource->hdbc;
879: } else {
880: henv = SQL_NULL_HENV;
881: conn = SQL_NULL_HDBC;
882: }
883:
884: /* This leads to an endless loop in many drivers!
885: *
886: while(henv != SQL_NULL_HENV){
887: do {
888: */
889: rc = SQLError(henv, conn, stmt, state, &error, errormsg, sizeof(errormsg)-1, &errormsgsize);
890: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
891: snprintf(state, sizeof(state), "HY000");
892: snprintf(errormsg, sizeof(errormsg), "Failed to fetch error message");
893: }
894: if (conn_resource) {
895: memcpy(conn_resource->laststate, state, sizeof(state));
896: memcpy(conn_resource->lasterrormsg, errormsg, sizeof(errormsg));
897: }
898: memcpy(ODBCG(laststate), state, sizeof(state));
899: memcpy(ODBCG(lasterrormsg), errormsg, sizeof(errormsg));
900: if (func) {
901: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQL error: %s, SQL state %s in %s", errormsg, state, func);
902: } else {
903: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQL error: %s, SQL state %s", errormsg, state);
904: }
905: /*
906: } while (SQL_SUCCEEDED(rc));
907: }
908: */
909: }
910: /* }}} */
911:
912: /* {{{ php_odbc_fetch_attribs */
913: void php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAMETERS, int mode)
914: {
915: odbc_result *result;
916: zval *pv_res;
917: long flag;
918:
919: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &flag) == FAILURE) {
920: return;
921: }
922:
923: if (Z_LVAL_P(pv_res)) {
924: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
925: if (mode) {
926: result->longreadlen = flag;
927: } else {
928: result->binmode = flag;
929: }
930: } else {
931: if (mode) {
932: ODBCG(defaultlrl) = flag;
933: } else {
934: ODBCG(defaultbinmode) = flag;
935: }
936: }
937: RETURN_TRUE;
938: }
939: /* }}} */
940:
941: /* {{{ odbc_bindcols */
942: int odbc_bindcols(odbc_result *result TSRMLS_DC)
943: {
944: RETCODE rc;
945: int i;
946: SQLSMALLINT colnamelen; /* Not used */
947: SQLLEN displaysize;
948:
949: result->values = (odbc_result_value *) safe_emalloc(sizeof(odbc_result_value), result->numcols, 0);
950:
951: result->longreadlen = ODBCG(defaultlrl);
952: result->binmode = ODBCG(defaultbinmode);
953:
954: for(i = 0; i < result->numcols; i++) {
955: rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_NAME,
956: result->values[i].name, sizeof(result->values[i].name), &colnamelen, 0);
957: rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_TYPE,
958: NULL, 0, NULL, &result->values[i].coltype);
959:
960: /* Don't bind LONG / BINARY columns, so that fetch behaviour can
961: * be controlled by odbc_binmode() / odbc_longreadlen()
962: */
963:
964: switch(result->values[i].coltype) {
965: case SQL_BINARY:
966: case SQL_VARBINARY:
967: case SQL_LONGVARBINARY:
968: case SQL_LONGVARCHAR:
969: result->values[i].value = NULL;
970: break;
971:
972: #ifdef HAVE_ADABAS
973: case SQL_TIMESTAMP:
974: result->values[i].value = (char *)emalloc(27);
975: SQLBindCol(result->stmt, (SQLUSMALLINT)(i+1), SQL_C_CHAR, result->values[i].value,
976: 27, &result->values[i].vallen);
977: break;
978: #endif /* HAVE_ADABAS */
979: default:
980: rc = SQLColAttributes(result->stmt, (SQLUSMALLINT)(i+1), SQL_COLUMN_DISPLAY_SIZE,
981: NULL, 0, NULL, &displaysize);
982: displaysize = displaysize <= result->longreadlen ? displaysize :
983: result->longreadlen;
984: /* Workaround for Oracle ODBC Driver bug (#50162) when fetching TIMESTAMP column */
985: if (result->values[i].coltype == SQL_TIMESTAMP) {
986: displaysize += 3;
987: }
988: result->values[i].value = (char *)emalloc(displaysize + 1);
989: rc = SQLBindCol(result->stmt, (SQLUSMALLINT)(i+1), SQL_C_CHAR, result->values[i].value,
990: displaysize + 1, &result->values[i].vallen);
991: break;
992: }
993: }
994: return 1;
995: }
996: /* }}} */
997:
998: /* {{{ odbc_transact */
999: void odbc_transact(INTERNAL_FUNCTION_PARAMETERS, int type)
1000: {
1001: odbc_connection *conn;
1002: RETCODE rc;
1003: zval *pv_conn;
1004:
1005: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_conn) == FAILURE) {
1006: return;
1007: }
1008:
1009: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
1010:
1011: rc = SQLTransact(conn->henv, conn->hdbc, (SQLUSMALLINT)((type)?SQL_COMMIT:SQL_ROLLBACK));
1012: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
1013: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLTransact");
1014: RETURN_FALSE;
1015: }
1016:
1017: RETURN_TRUE;
1018: }
1019: /* }}} */
1020:
1021: /* {{{ _close_pconn_with_id */
1022: static int _close_pconn_with_id(zend_rsrc_list_entry *le, int *id TSRMLS_DC)
1023: {
1024: if(Z_TYPE_P(le) == le_pconn && (((odbc_connection *)(le->ptr))->id == *id)){
1025: return 1;
1026: }else{
1027: return 0;
1028: }
1029: }
1030: /* }}} */
1031:
1032: /* {{{ odbc_column_lengths */
1033: void odbc_column_lengths(INTERNAL_FUNCTION_PARAMETERS, int type)
1034: {
1035: odbc_result *result;
1036: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30)
1037: /* this seems to be necessary for Solid2.3 ( tested by
1038: * tammy@synchronis.com) and Solid 3.0 (tested by eric@terra.telemediair.nl)
1039: * Solid does not seem to declare a SQLINTEGER, but it does declare a
1040: * SQL_INTEGER which does not work (despite being the same type as a SDWORD.
1041: * Solid 3.5 does not have this issue.
1042: */
1043: SDWORD len;
1044: #else
1045: SQLLEN len;
1046: #endif
1047: zval *pv_res;
1048: long pv_num;
1049:
1050: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) {
1051: return;
1052: }
1053:
1054: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
1055:
1056: if (result->numcols == 0) {
1057: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
1058: RETURN_FALSE;
1059: }
1060:
1061: if (pv_num > result->numcols) {
1062: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields");
1063: RETURN_FALSE;
1064: }
1065:
1066: if (pv_num < 1) {
1067: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1");
1068: RETURN_FALSE;
1069: }
1070:
1071: SQLColAttributes(result->stmt, (SQLUSMALLINT)pv_num, (SQLUSMALLINT) (type?SQL_COLUMN_SCALE:SQL_COLUMN_PRECISION), NULL, 0, NULL, &len);
1072:
1073: RETURN_LONG(len);
1074: }
1075: /* }}} */
1076:
1077: /* Main User Functions */
1078:
1079: /* {{{ proto void odbc_close_all(void)
1080: Close all ODBC connections */
1081: PHP_FUNCTION(odbc_close_all)
1082: {
1083: void *ptr;
1084: int type;
1085: int i;
1086: int nument;
1087:
1088: if (zend_parse_parameters_none() == FAILURE) {
1089: return;
1090: }
1091:
1092: nument = zend_hash_next_free_element(&EG(regular_list));
1093:
1094: /* Loop through list and close all statements */
1095: for(i = 1; i < nument; i++) {
1096: ptr = zend_list_find(i, &type);
1097: if (ptr && (type == le_result)){
1098: zend_list_delete(i);
1099: }
1100: }
1101:
1102: /* Second loop through list, now close all connections */
1103: nument = zend_hash_next_free_element(&EG(regular_list));
1104:
1105: for(i = 1; i < nument; i++) {
1106: ptr = zend_list_find(i, &type);
1107: if (ptr){
1108: if(type == le_conn){
1109: zend_list_delete(i);
1110: }else if(type == le_pconn){
1111: zend_list_delete(i);
1112: /* Delete the persistent connection */
1113: zend_hash_apply_with_argument(&EG(persistent_list),
1114: (apply_func_arg_t) _close_pconn_with_id, (void *) &i TSRMLS_CC);
1115: }
1116: }
1117: }
1118: }
1119: /* }}} */
1120:
1121: /* {{{ proto bool odbc_binmode(int result_id, int mode)
1122: Handle binary column data */
1123: PHP_FUNCTION(odbc_binmode)
1124: {
1125: php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
1126: }
1127: /* }}} */
1128:
1129: /* {{{ proto bool odbc_longreadlen(int result_id, int length)
1130: Handle LONG columns */
1131: PHP_FUNCTION(odbc_longreadlen)
1132: {
1133: php_odbc_fetch_attribs(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
1134: }
1135: /* }}} */
1136:
1137: /* {{{ proto resource odbc_prepare(resource connection_id, string query)
1138: Prepares a statement for execution */
1139: PHP_FUNCTION(odbc_prepare)
1140: {
1141: zval *pv_conn;
1142: char *query;
1143: int query_len;
1144: odbc_result *result = NULL;
1145: odbc_connection *conn;
1146: RETCODE rc;
1147: #ifdef HAVE_SQL_EXTENDED_FETCH
1148: SQLUINTEGER scrollopts;
1149: #endif
1150:
1151: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &pv_conn, &query, &query_len) == FAILURE) {
1152: return;
1153: }
1154:
1155: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
1156:
1157: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
1158:
1159: result->numparams = 0;
1160:
1161: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
1162: if (rc == SQL_INVALID_HANDLE) {
1163: efree(result);
1164: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
1165: RETURN_FALSE;
1166: }
1167:
1168: if (rc == SQL_ERROR) {
1169: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
1170: efree(result);
1171: RETURN_FALSE;
1172: }
1173:
1174: #ifdef HAVE_SQL_EXTENDED_FETCH
1175: /* Solid doesn't have ExtendedFetch, if DriverManager is used, get Info,
1176: whether Driver supports ExtendedFetch */
1177: rc = SQLGetInfo(conn->hdbc, SQL_FETCH_DIRECTION, (void *) &scrollopts, sizeof(scrollopts), NULL);
1178: if (rc == SQL_SUCCESS) {
1179: if ((result->fetch_abs = (scrollopts & SQL_FD_FETCH_ABSOLUTE))) {
1180: /* Try to set CURSOR_TYPE to dynamic. Driver will replace this with other
1181: type if not possible.
1182: */
1183: SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, ODBCG(default_cursortype));
1184: }
1185: } else {
1186: result->fetch_abs = 0;
1187: }
1188: #endif
1189:
1190: rc = SQLPrepare(result->stmt, query, SQL_NTS);
1191: switch (rc) {
1192: case SQL_SUCCESS:
1193: break;
1194: case SQL_SUCCESS_WITH_INFO:
1195: odbc_sql_error(conn, result->stmt, "SQLPrepare");
1196: break;
1197: default:
1198: odbc_sql_error(conn, result->stmt, "SQLPrepare");
1199: RETURN_FALSE;
1200: }
1201:
1202: SQLNumParams(result->stmt, &(result->numparams));
1203: SQLNumResultCols(result->stmt, &(result->numcols));
1204:
1205: if (result->numcols > 0) {
1206: if (!odbc_bindcols(result TSRMLS_CC)) {
1207: efree(result);
1208: RETURN_FALSE;
1209: }
1210: } else {
1211: result->values = NULL;
1212: }
1213: zend_list_addref(conn->id);
1214: result->conn_ptr = conn;
1215: result->fetched = 0;
1216: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
1217: }
1218: /* }}} */
1219:
1220: /*
1221: * Execute prepared SQL statement. Supports only input parameters.
1222: */
1223:
1224: /* {{{ proto bool odbc_execute(resource result_id [, array parameters_array])
1225: Execute a prepared statement */
1226: PHP_FUNCTION(odbc_execute)
1227: {
1228: zval *pv_res, *pv_param_arr, **tmp;
1229: typedef struct params_t {
1230: SQLLEN vallen;
1231: int fp;
1232: } params_t;
1233: params_t *params = NULL;
1234: char *filename;
1235: unsigned char otype;
1236: SQLSMALLINT sqltype, ctype, scale;
1237: SQLSMALLINT nullable;
1238: SQLULEN precision;
1239: odbc_result *result;
1240: int numArgs, i, ne;
1241: RETCODE rc;
1242:
1243: numArgs = ZEND_NUM_ARGS();
1244:
1245: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|a", &pv_res, &pv_param_arr) == FAILURE) {
1246: return;
1247: }
1248:
1249: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
1250:
1251: /* XXX check for already bound parameters*/
1252: if (result->numparams > 0 && numArgs == 1) {
1253: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No parameters to SQL statement given");
1254: RETURN_FALSE;
1255: }
1256:
1257: if (result->numparams > 0) {
1258: if ((ne = zend_hash_num_elements(Z_ARRVAL_P(pv_param_arr))) < result->numparams) {
1259: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Not enough parameters (%d should be %d) given", ne, result->numparams);
1260: RETURN_FALSE;
1261: }
1262:
1263: zend_hash_internal_pointer_reset(Z_ARRVAL_P(pv_param_arr));
1264: params = (params_t *)safe_emalloc(sizeof(params_t), result->numparams, 0);
1265: for(i = 0; i < result->numparams; i++) {
1266: params[i].fp = -1;
1267: }
1268:
1269: for(i = 1; i <= result->numparams; i++) {
1270: if (zend_hash_get_current_data(Z_ARRVAL_P(pv_param_arr), (void **) &tmp) == FAILURE) {
1271: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error getting parameter");
1272: SQLFreeStmt(result->stmt,SQL_RESET_PARAMS);
1273: for (i = 0; i < result->numparams; i++) {
1274: if (params[i].fp != -1) {
1275: close(params[i].fp);
1276: }
1277: }
1278: efree(params);
1279: RETURN_FALSE;
1280: }
1281:
1282: otype = (*tmp)->type;
1283: convert_to_string_ex(tmp);
1284: if (Z_TYPE_PP(tmp) != IS_STRING) {
1285: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Error converting parameter");
1286: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);
1287: for (i = 0; i < result->numparams; i++) {
1288: if (params[i].fp != -1) {
1289: close(params[i].fp);
1290: }
1291: }
1292: efree(params);
1293: RETURN_FALSE;
1294: }
1295:
1296: rc = SQLDescribeParam(result->stmt, (SQLUSMALLINT)i, &sqltype, &precision, &scale, &nullable);
1297: params[i-1].vallen = Z_STRLEN_PP(tmp);
1298: params[i-1].fp = -1;
1299: if (rc == SQL_ERROR) {
1300: odbc_sql_error(result->conn_ptr, result->stmt, "SQLDescribeParameter");
1301: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);
1302: for (i = 0; i < result->numparams; i++) {
1303: if (params[i].fp != -1) {
1304: close(params[i].fp);
1305: }
1306: }
1307: efree(params);
1308: RETURN_FALSE;
1309: }
1310:
1311: if (IS_SQL_BINARY(sqltype)) {
1312: ctype = SQL_C_BINARY;
1313: } else {
1314: ctype = SQL_C_CHAR;
1315: }
1316:
1317: if (Z_STRLEN_PP(tmp) > 2 &&
1318: Z_STRVAL_PP(tmp)[0] == '\'' &&
1319: Z_STRVAL_PP(tmp)[Z_STRLEN_PP(tmp) - 1] == '\'') {
1320: if (strlen(tmp) != Z_STRLEN_PP(tmp)) {
1321: RETURN_FALSE;
1322: }
1323:
1324: filename = estrndup(&Z_STRVAL_PP(tmp)[1], Z_STRLEN_PP(tmp) - 2);
1325:
1326: /* Check for safe mode. */
1327: if (PG(safe_mode) && (!php_checkuid(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
1328: efree(filename);
1329: efree(params);
1330: RETURN_FALSE;
1331: }
1332:
1333: /* Check the basedir */
1334: if (php_check_open_basedir(filename TSRMLS_CC)) {
1335: efree(filename);
1336: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);
1337: for (i = 0; i < result->numparams; i++) {
1338: if (params[i].fp != -1) {
1339: close(params[i].fp);
1340: }
1341: }
1342: efree(params);
1343: RETURN_FALSE;
1344: }
1345:
1346: if ((params[i-1].fp = open(filename,O_RDONLY)) == -1) {
1347: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Can't open file %s", filename);
1348: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);
1349: for (i = 0; i < result->numparams; i++) {
1350: if (params[i].fp != -1) {
1351: close(params[i].fp);
1352: }
1353: }
1354: efree(params);
1355: efree(filename);
1356: RETURN_FALSE;
1357: }
1358:
1359: efree(filename);
1360:
1361: params[i-1].vallen = SQL_LEN_DATA_AT_EXEC(0);
1362:
1363: rc = SQLBindParameter(result->stmt, (SQLUSMALLINT)i, SQL_PARAM_INPUT,
1364: ctype, sqltype, precision, scale,
1365: (void *)params[i-1].fp, 0,
1366: ¶ms[i-1].vallen);
1367: } else {
1368: #ifdef HAVE_DBMAKER
1369: precision = params[i-1].vallen;
1370: #endif
1371: if (otype == IS_NULL) {
1372: params[i-1].vallen = SQL_NULL_DATA;
1373: }
1374:
1375: rc = SQLBindParameter(result->stmt, (SQLUSMALLINT)i, SQL_PARAM_INPUT,
1376: ctype, sqltype, precision, scale,
1377: Z_STRVAL_PP(tmp), 0,
1378: ¶ms[i-1].vallen);
1379: }
1380: if (rc == SQL_ERROR) {
1381: odbc_sql_error(result->conn_ptr, result->stmt, "SQLBindParameter");
1382: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);
1383: for (i = 0; i < result->numparams; i++) {
1384: if (params[i].fp != -1) {
1385: close(params[i].fp);
1386: }
1387: }
1388: efree(params);
1389: RETURN_FALSE;
1390: }
1391: zend_hash_move_forward(Z_ARRVAL_P(pv_param_arr));
1392: }
1393: }
1394: /* Close cursor, needed for doing multiple selects */
1395: rc = SQLFreeStmt(result->stmt, SQL_CLOSE);
1396:
1397: if (rc == SQL_ERROR) {
1398: odbc_sql_error(result->conn_ptr, result->stmt, "SQLFreeStmt");
1399: }
1400:
1401: rc = SQLExecute(result->stmt);
1402:
1403: result->fetched = 0;
1404: if (rc == SQL_NEED_DATA) {
1405: char buf[4096];
1406: int fp, nbytes;
1407: while (rc == SQL_NEED_DATA) {
1408: rc = SQLParamData(result->stmt, (void*)&fp);
1409: if (rc == SQL_NEED_DATA) {
1410: while ((nbytes = read(fp, &buf, 4096)) > 0) {
1411: SQLPutData(result->stmt, (void*)&buf, nbytes);
1412: }
1413: }
1414: }
1415: } else {
1416: switch (rc) {
1417: case SQL_SUCCESS:
1418: break;
1419: case SQL_NO_DATA_FOUND:
1420: case SQL_SUCCESS_WITH_INFO:
1421: odbc_sql_error(result->conn_ptr, result->stmt, "SQLExecute");
1422: break;
1423: default:
1424: odbc_sql_error(result->conn_ptr, result->stmt, "SQLExecute");
1425: RETVAL_FALSE;
1426: }
1427: }
1428:
1429: if (result->numparams > 0) {
1430: SQLFreeStmt(result->stmt, SQL_RESET_PARAMS);
1431: for(i = 0; i < result->numparams; i++) {
1432: if (params[i].fp != -1) {
1433: close(params[i].fp);
1434: }
1435: }
1436: efree(params);
1437: }
1438:
1439: if (rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO || rc == SQL_NO_DATA_FOUND) {
1440: RETVAL_TRUE;
1441: }
1442:
1443: if (result->numcols == 0) {
1444: SQLNumResultCols(result->stmt, &(result->numcols));
1445:
1446: if (result->numcols > 0) {
1447: if (!odbc_bindcols(result TSRMLS_CC)) {
1448: efree(result);
1449: RETVAL_FALSE;
1450: }
1451: } else {
1452: result->values = NULL;
1453: }
1454: }
1455: }
1456: /* }}} */
1457:
1458: /* {{{ proto string odbc_cursor(resource result_id)
1459: Get cursor name */
1460: PHP_FUNCTION(odbc_cursor)
1461: {
1462: zval *pv_res;
1463: SQLUSMALLINT max_len;
1464: SQLSMALLINT len;
1465: char *cursorname;
1466: odbc_result *result;
1467: RETCODE rc;
1468:
1469: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
1470: return;
1471: }
1472:
1473: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
1474:
1475: rc = SQLGetInfo(result->conn_ptr->hdbc,SQL_MAX_CURSOR_NAME_LEN, (void *)&max_len,sizeof(max_len),&len);
1476: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
1477: RETURN_FALSE;
1478: }
1479:
1480: if (max_len > 0) {
1481: cursorname = emalloc(max_len + 1);
1482: rc = SQLGetCursorName(result->stmt,cursorname,(SQLSMALLINT)max_len,&len);
1483: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
1484: char state[6]; /* Not used */
1485: SQLINTEGER error; /* Not used */
1486: char errormsg[SQL_MAX_MESSAGE_LENGTH];
1487: SQLSMALLINT errormsgsize; /* Not used */
1488:
1489: SQLError( result->conn_ptr->henv, result->conn_ptr->hdbc,
1490: result->stmt, state, &error, errormsg,
1491: sizeof(errormsg)-1, &errormsgsize);
1492: if (!strncmp(state,"S1015",5)) {
1493: snprintf(cursorname, max_len+1, "php_curs_%d", (int)result->stmt);
1494: if (SQLSetCursorName(result->stmt,cursorname,SQL_NTS) != SQL_SUCCESS) {
1495: odbc_sql_error(result->conn_ptr, result->stmt, "SQLSetCursorName");
1496: RETVAL_FALSE;
1497: } else {
1498: RETVAL_STRING(cursorname,1);
1499: }
1500: } else {
1501: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQL error: %s, SQL state %s", errormsg, state);
1502: RETVAL_FALSE;
1503: }
1504: } else {
1505: RETVAL_STRING(cursorname,1);
1506: }
1507: efree(cursorname);
1508: } else {
1509: RETVAL_FALSE;
1510: }
1511: }
1512: /* }}} */
1513:
1514: #ifdef HAVE_SQLDATASOURCES
1515: /* {{{ proto array odbc_data_source(resource connection_id, int fetch_type)
1516: Return information about the currently connected data source */
1517: PHP_FUNCTION(odbc_data_source)
1518: {
1519: zval *zv_conn;
1520: long zv_fetch_type;
1521: RETCODE rc = 0; /* assume all is good */
1522: odbc_connection *conn;
1523: UCHAR server_name[100], desc[200];
1524: SQLSMALLINT len1=0, len2=0, fetch_type;
1525:
1526: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zv_conn, &zv_fetch_type) == FAILURE) {
1527: return;
1528: }
1529:
1530: fetch_type = (SQLSMALLINT) zv_fetch_type;
1531:
1532: if (!(fetch_type == SQL_FETCH_FIRST || fetch_type == SQL_FETCH_NEXT)) {
1533: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid fetch type (%d)", fetch_type);
1534: RETURN_FALSE;
1535: }
1536:
1537: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &zv_conn, -1, "ODBC-Link", le_conn, le_pconn);
1538:
1539: /* now we have the "connection" lets call the DataSource object */
1540: rc = SQLDataSources(conn->henv,
1541: fetch_type,
1542: server_name,
1543: (SQLSMALLINT)sizeof(server_name),
1544: &len1,
1545: desc,
1546: (SQLSMALLINT)sizeof(desc),
1547: &len2);
1548:
1549: if (rc != SQL_SUCCESS) {
1550: /* ummm.... he did it */
1551: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLDataSources");
1552: RETURN_FALSE;
1553: }
1554:
1555: if (len1 == 0 || len2 == 0) {
1556: /* we have a non-valid entry... so stop the looping */
1557: RETURN_FALSE;
1558: }
1559:
1560: array_init(return_value);
1561:
1562: add_assoc_string_ex(return_value, "server", sizeof("server"), server_name, 1);
1563: add_assoc_string_ex(return_value, "description", sizeof("description"), desc, 1);
1564:
1565: }
1566: /* }}} */
1567: #endif /* HAVE_SQLDATASOURCES */
1568:
1569: /* {{{ proto resource odbc_exec(resource connection_id, string query [, int flags])
1570: Prepare and execute an SQL statement */
1571: /* XXX Use flags */
1572: PHP_FUNCTION(odbc_exec)
1573: {
1574: zval *pv_conn;
1575: long pv_flags;
1576: char *query;
1577: int numArgs, query_len;
1578: odbc_result *result = NULL;
1579: odbc_connection *conn;
1580: RETCODE rc;
1581: #ifdef HAVE_SQL_EXTENDED_FETCH
1582: SQLUINTEGER scrollopts;
1583: #endif
1584:
1585: numArgs = ZEND_NUM_ARGS();
1586:
1587: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &pv_conn, &query, &query_len, &pv_flags) == FAILURE) {
1588: return;
1589: }
1590:
1591: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
1592:
1593: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
1594:
1595: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
1596: if (rc == SQL_INVALID_HANDLE) {
1597: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
1598: efree(result);
1599: RETURN_FALSE;
1600: }
1601:
1602: if (rc == SQL_ERROR) {
1603: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
1604: efree(result);
1605: RETURN_FALSE;
1606: }
1607:
1608: #ifdef HAVE_SQL_EXTENDED_FETCH
1609: /* Solid doesn't have ExtendedFetch, if DriverManager is used, get Info,
1610: whether Driver supports ExtendedFetch */
1611: rc = SQLGetInfo(conn->hdbc, SQL_FETCH_DIRECTION, (void *) &scrollopts, sizeof(scrollopts), NULL);
1612: if (rc == SQL_SUCCESS) {
1613: if ((result->fetch_abs = (scrollopts & SQL_FD_FETCH_ABSOLUTE))) {
1614: /* Try to set CURSOR_TYPE to dynamic. Driver will replace this with other
1615: type if not possible.
1616: */
1617: SQLSetStmtOption(result->stmt, SQL_CURSOR_TYPE, ODBCG(default_cursortype));
1618: }
1619: } else {
1620: result->fetch_abs = 0;
1621: }
1622: #endif
1623:
1624: rc = SQLExecDirect(result->stmt, query, SQL_NTS);
1625: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO && rc != SQL_NO_DATA_FOUND) {
1626: /* XXX FIXME we should really check out SQLSTATE with SQLError
1627: * in case rc is SQL_SUCCESS_WITH_INFO here.
1628: */
1629: odbc_sql_error(conn, result->stmt, "SQLExecDirect");
1630: SQLFreeStmt(result->stmt, SQL_DROP);
1631: efree(result);
1632: RETURN_FALSE;
1633: }
1634:
1635: SQLNumResultCols(result->stmt, &(result->numcols));
1636:
1637: /* For insert, update etc. cols == 0 */
1638: if (result->numcols > 0) {
1639: if (!odbc_bindcols(result TSRMLS_CC)) {
1640: efree(result);
1641: RETURN_FALSE;
1642: }
1643: } else {
1644: result->values = NULL;
1645: }
1646: zend_list_addref(conn->id);
1647: result->conn_ptr = conn;
1648: result->fetched = 0;
1649: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
1650: }
1651: /* }}} */
1652:
1653: #ifdef PHP_ODBC_HAVE_FETCH_HASH
1654: #define ODBC_NUM 1
1655: #define ODBC_OBJECT 2
1656:
1657: /* {{{ php_odbc_fetch_hash */
1658: static void php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type)
1659: {
1660: int i;
1661: odbc_result *result;
1662: RETCODE rc;
1663: SQLSMALLINT sql_c_type;
1664: char *buf = NULL;
1665: #ifdef HAVE_SQL_EXTENDED_FETCH
1666: SQLULEN crow;
1667: SQLUSMALLINT RowStatus[1];
1668: SQLLEN rownum;
1669: zval *pv_res, *tmp;
1670: long pv_row = -1;
1671:
1672: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_res, &pv_row) == FAILURE) {
1673: return;
1674: }
1675:
1676: rownum = pv_row;
1677: #else
1678: zval *pv_res, *tmp;
1679:
1680: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
1681: return;
1682: }
1683: #endif
1684:
1685: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
1686:
1687: if (result->numcols == 0) {
1688: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
1689: RETURN_FALSE;
1690: }
1691:
1692: #ifdef HAVE_SQL_EXTENDED_FETCH
1693: if (result->fetch_abs) {
1694: if (rownum > 0) {
1695: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus);
1696: } else {
1697: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus);
1698: }
1699: } else
1700: #endif
1701: rc = SQLFetch(result->stmt);
1702:
1703: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
1704: RETURN_FALSE;
1705: }
1706:
1707: array_init(return_value);
1708:
1709: #ifdef HAVE_SQL_EXTENDED_FETCH
1710: if (rownum > 0 && result->fetch_abs)
1711: result->fetched = rownum;
1712: else
1713: #endif
1714: result->fetched++;
1715:
1716: for(i = 0; i < result->numcols; i++) {
1717: ALLOC_INIT_ZVAL(tmp);
1718: Z_TYPE_P(tmp) = IS_STRING;
1719: Z_STRLEN_P(tmp) = 0;
1720: sql_c_type = SQL_C_CHAR;
1721:
1722: switch(result->values[i].coltype) {
1723: case SQL_BINARY:
1724: case SQL_VARBINARY:
1725: case SQL_LONGVARBINARY:
1726: if (result->binmode <= 0) {
1727: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
1728: break;
1729: }
1730: if (result->binmode == 1) {
1731: sql_c_type = SQL_C_BINARY;
1732: }
1733: case SQL_LONGVARCHAR:
1734: if (IS_SQL_LONG(result->values[i].coltype) && result->longreadlen <= 0) {
1735: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
1736: break;
1737: }
1738: if (buf == NULL) {
1739: buf = emalloc(result->longreadlen + 1);
1740: }
1741:
1742: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(i + 1), sql_c_type, buf, result->longreadlen + 1, &result->values[i].vallen);
1743:
1744: if (rc == SQL_ERROR) {
1745: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData");
1746: efree(buf);
1747: RETURN_FALSE;
1748: }
1749:
1750: if (rc == SQL_SUCCESS_WITH_INFO) {
1751: Z_STRLEN_P(tmp) = result->longreadlen;
1752: } else if (result->values[i].vallen == SQL_NULL_DATA) {
1753: ZVAL_NULL(tmp);
1754: break;
1755: } else {
1756: Z_STRLEN_P(tmp) = result->values[i].vallen;
1757: }
1758: Z_STRVAL_P(tmp) = estrndup(buf, Z_STRLEN_P(tmp));
1759: break;
1760:
1761: default:
1762: if (result->values[i].vallen == SQL_NULL_DATA) {
1763: ZVAL_NULL(tmp);
1764: break;
1765: }
1766: Z_STRLEN_P(tmp) = result->values[i].vallen;
1767: Z_STRVAL_P(tmp) = estrndup(result->values[i].value,Z_STRLEN_P(tmp));
1768: break;
1769: }
1770:
1771: if (result_type & ODBC_NUM) {
1772: zend_hash_index_update(Z_ARRVAL_P(return_value), i, &tmp, sizeof(zval *), NULL);
1773: } else {
1774: if (!*(result->values[i].name)) {
1775: zend_hash_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(tmp), Z_STRLEN_P(tmp)+1, &tmp, sizeof(zval *), NULL);
1776: } else {
1777: zend_hash_update(Z_ARRVAL_P(return_value), result->values[i].name, strlen(result->values[i].name)+1, &tmp, sizeof(zval *), NULL);
1778: }
1779: }
1780: }
1781: if (buf) {
1782: efree(buf);
1783: }
1784: }
1785: /* }}} */
1786:
1787:
1788: /* {{{ proto object odbc_fetch_object(int result [, int rownumber])
1789: Fetch a result row as an object */
1790: PHP_FUNCTION(odbc_fetch_object)
1791: {
1792: php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, ODBC_OBJECT);
1793: if (Z_TYPE_P(return_value) == IS_ARRAY) {
1794: object_and_properties_init(return_value, ZEND_STANDARD_CLASS_DEF_PTR, Z_ARRVAL_P(return_value));
1795: }
1796: }
1797: /* }}} */
1798:
1799: /* {{{ proto array odbc_fetch_array(int result [, int rownumber])
1800: Fetch a result row as an associative array */
1801: PHP_FUNCTION(odbc_fetch_array)
1802: {
1803: php_odbc_fetch_hash(INTERNAL_FUNCTION_PARAM_PASSTHRU, ODBC_OBJECT);
1804: }
1805: /* }}} */
1806: #endif
1807:
1808: /* {{{ proto int odbc_fetch_into(resource result_id, array &result_array, [, int rownumber])
1809: Fetch one result row into an array */
1810: PHP_FUNCTION(odbc_fetch_into)
1811: {
1812: int i;
1813: odbc_result *result;
1814: RETCODE rc;
1815: SQLSMALLINT sql_c_type;
1816: char *buf = NULL;
1817: zval *pv_res, **pv_res_arr, *tmp;
1818: #ifdef HAVE_SQL_EXTENDED_FETCH
1819: long pv_row = 0;
1820: SQLULEN crow;
1821: SQLUSMALLINT RowStatus[1];
1822: SQLLEN rownum = -1;
1823: #endif /* HAVE_SQL_EXTENDED_FETCH */
1824:
1825: #ifdef HAVE_SQL_EXTENDED_FETCH
1826: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ|l", &pv_res, &pv_res_arr, &pv_row) == FAILURE) {
1827: return;
1828: }
1829:
1830: rownum = pv_row;
1831: #else
1832: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pv_res, &pv_res_arr) == FAILURE) {
1833: return;
1834: }
1835: #endif /* HAVE_SQL_EXTENDED_FETCH */
1836:
1837: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
1838:
1839: if (result->numcols == 0) {
1840: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
1841: RETURN_FALSE;
1842: }
1843:
1844: if (Z_TYPE_PP(pv_res_arr) != IS_ARRAY) {
1845: array_init(*pv_res_arr);
1846: }
1847:
1848: #ifdef HAVE_SQL_EXTENDED_FETCH
1849: if (result->fetch_abs) {
1850: if (rownum > 0) {
1851: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus);
1852: } else {
1853: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus);
1854: }
1855: } else
1856: #endif
1857: rc = SQLFetch(result->stmt);
1858:
1859: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
1860: RETURN_FALSE;
1861: }
1862:
1863: #ifdef HAVE_SQL_EXTENDED_FETCH
1864: if (rownum > 0 && result->fetch_abs)
1865: result->fetched = rownum;
1866: else
1867: #endif
1868: result->fetched++;
1869:
1870: for(i = 0; i < result->numcols; i++) {
1871: MAKE_STD_ZVAL(tmp);
1872: Z_TYPE_P(tmp) = IS_STRING;
1873: Z_STRLEN_P(tmp) = 0;
1874: sql_c_type = SQL_C_CHAR;
1875:
1876: switch(result->values[i].coltype) {
1877: case SQL_BINARY:
1878: case SQL_VARBINARY:
1879: case SQL_LONGVARBINARY:
1880: if (result->binmode <= 0) {
1881: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
1882: break;
1883: }
1884: if (result->binmode == 1) sql_c_type = SQL_C_BINARY;
1885: case SQL_LONGVARCHAR:
1886: if (IS_SQL_LONG(result->values[i].coltype) && result->longreadlen <= 0) {
1887: Z_STRVAL_P(tmp) = STR_EMPTY_ALLOC();
1888: break;
1889: }
1890:
1891: if (buf == NULL) {
1892: buf = emalloc(result->longreadlen + 1);
1893: }
1894: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(i + 1),sql_c_type, buf, result->longreadlen + 1, &result->values[i].vallen);
1895:
1896: if (rc == SQL_ERROR) {
1897: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData");
1898: efree(buf);
1899: RETURN_FALSE;
1900: }
1901: if (rc == SQL_SUCCESS_WITH_INFO) {
1902: Z_STRLEN_P(tmp) = result->longreadlen;
1903: } else if (result->values[i].vallen == SQL_NULL_DATA) {
1904: ZVAL_NULL(tmp);
1905: break;
1906: } else {
1907: Z_STRLEN_P(tmp) = result->values[i].vallen;
1908: }
1909: Z_STRVAL_P(tmp) = estrndup(buf, Z_STRLEN_P(tmp));
1910: break;
1911:
1912: default:
1913: if (result->values[i].vallen == SQL_NULL_DATA) {
1914: ZVAL_NULL(tmp);
1915: break;
1916: }
1917: Z_STRLEN_P(tmp) = result->values[i].vallen;
1918: Z_STRVAL_P(tmp) = estrndup(result->values[i].value,Z_STRLEN_P(tmp));
1919: break;
1920: }
1921: zend_hash_index_update(Z_ARRVAL_PP(pv_res_arr), i, &tmp, sizeof(zval *), NULL);
1922: }
1923: if (buf) efree(buf);
1924: RETURN_LONG(result->numcols);
1925: }
1926: /* }}} */
1927:
1928: /* {{{ proto bool solid_fetch_prev(resource result_id)
1929: */
1930: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30) || defined(HAVE_SOLID_35)
1931: PHP_FUNCTION(solid_fetch_prev)
1932: {
1933: odbc_result *result;
1934: RETCODE rc;
1935: zval *pv_res;
1936:
1937: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
1938: return;
1939: }
1940:
1941: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
1942: if (result->numcols == 0) {
1943: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
1944: RETURN_FALSE;
1945: }
1946: rc = SQLFetchPrev(result->stmt);
1947:
1948: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
1949: RETURN_FALSE;
1950: }
1951:
1952: if (result->fetched > 1) {
1953: result->fetched--;
1954: }
1955:
1956: RETURN_TRUE;
1957: }
1958: #endif
1959: /* }}} */
1960:
1961: /* {{{ proto bool odbc_fetch_row(resource result_id [, int row_number])
1962: Fetch a row */
1963: PHP_FUNCTION(odbc_fetch_row)
1964: {
1965: SQLLEN rownum;
1966: odbc_result *result;
1967: RETCODE rc;
1968: zval *pv_res;
1969: long pv_row = 1;
1970: #ifdef HAVE_SQL_EXTENDED_FETCH
1971: SQLULEN crow;
1972: SQLUSMALLINT RowStatus[1];
1973: #endif
1974:
1975: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_res, &pv_row) == FAILURE) {
1976: return;
1977: }
1978:
1979: rownum = pv_row;
1980:
1981: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
1982:
1983: if (result->numcols == 0) {
1984: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
1985: RETURN_FALSE;
1986: }
1987:
1988: #ifdef HAVE_SQL_EXTENDED_FETCH
1989: if (result->fetch_abs) {
1990: if (ZEND_NUM_ARGS() > 1) {
1991: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_ABSOLUTE,rownum,&crow,RowStatus);
1992: } else {
1993: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus);
1994: }
1995: } else
1996: #endif
1997: rc = SQLFetch(result->stmt);
1998:
1999: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
2000: RETURN_FALSE;
2001: }
2002:
2003: if (ZEND_NUM_ARGS() > 1) {
2004: result->fetched = rownum;
2005: } else {
2006: result->fetched++;
2007: }
2008:
2009: RETURN_TRUE;
2010: }
2011: /* }}} */
2012:
2013: /* {{{ proto mixed odbc_result(resource result_id, mixed field)
2014: Get result data */
2015: PHP_FUNCTION(odbc_result)
2016: {
2017: char *field;
2018: int field_ind;
2019: SQLSMALLINT sql_c_type = SQL_C_CHAR;
2020: odbc_result *result;
2021: int i = 0;
2022: RETCODE rc;
2023: SQLLEN fieldsize;
2024: zval *pv_res, **pv_field;
2025: #ifdef HAVE_SQL_EXTENDED_FETCH
2026: SQLULEN crow;
2027: SQLUSMALLINT RowStatus[1];
2028: #endif
2029:
2030: field_ind = -1;
2031: field = NULL;
2032:
2033: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rZ", &pv_res, &pv_field) == FAILURE) {
2034: return;
2035: }
2036:
2037: if (Z_TYPE_PP(pv_field) == IS_STRING) {
2038: field = Z_STRVAL_PP(pv_field);
2039: } else {
2040: convert_to_long_ex(pv_field);
2041: field_ind = Z_LVAL_PP(pv_field) - 1;
2042: }
2043:
2044: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2045:
2046: if ((result->numcols == 0)) {
2047: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
2048: RETURN_FALSE;
2049: }
2050:
2051: /* get field index if the field parameter was a string */
2052: if (field != NULL) {
2053: if (result->values == NULL) {
2054: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Result set contains no data");
2055: RETURN_FALSE;
2056: }
2057:
2058: for(i = 0; i < result->numcols; i++) {
2059: if (!strcasecmp(result->values[i].name, field)) {
2060: field_ind = i;
2061: break;
2062: }
2063: }
2064:
2065: if (field_ind < 0) {
2066: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field %s not found", field);
2067: RETURN_FALSE;
2068: }
2069: } else {
2070: /* check for limits of field_ind if the field parameter was an int */
2071: if (field_ind >= result->numcols || field_ind < 0) {
2072: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index is larger than the number of fields");
2073: RETURN_FALSE;
2074: }
2075: }
2076:
2077: if (result->fetched == 0) {
2078: /* User forgot to call odbc_fetch_row(), or wants to reload the results, do it now */
2079: #ifdef HAVE_SQL_EXTENDED_FETCH
2080: if (result->fetch_abs)
2081: rc = SQLExtendedFetch(result->stmt, SQL_FETCH_NEXT, 1, &crow,RowStatus);
2082: else
2083: #endif
2084: rc = SQLFetch(result->stmt);
2085:
2086: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
2087: RETURN_FALSE;
2088: }
2089:
2090: result->fetched++;
2091: }
2092:
2093: switch(result->values[field_ind].coltype) {
2094: case SQL_BINARY:
2095: case SQL_VARBINARY:
2096: case SQL_LONGVARBINARY:
2097: if (result->binmode <= 1) {
2098: sql_c_type = SQL_C_BINARY;
2099: }
2100: if (result->binmode <= 0) {
2101: break;
2102: }
2103: case SQL_LONGVARCHAR:
2104: if (IS_SQL_LONG(result->values[field_ind].coltype)) {
2105: if (result->longreadlen <= 0) {
2106: break;
2107: } else {
2108: fieldsize = result->longreadlen;
2109: }
2110: } else {
2111: SQLColAttributes(result->stmt, (SQLUSMALLINT)(field_ind + 1),
2112: (SQLUSMALLINT)((sql_c_type == SQL_C_BINARY) ? SQL_COLUMN_LENGTH :
2113: SQL_COLUMN_DISPLAY_SIZE),
2114: NULL, 0, NULL, &fieldsize);
2115: }
2116: /* For char data, the length of the returned string will be longreadlen - 1 */
2117: fieldsize = (result->longreadlen <= 0) ? 4096 : result->longreadlen;
2118: field = emalloc(fieldsize);
2119:
2120: /* SQLGetData will truncate CHAR data to fieldsize - 1 bytes and append \0.
2121: * For binary data it is truncated to fieldsize bytes.
2122: */
2123: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(field_ind + 1), sql_c_type,
2124: field, fieldsize, &result->values[field_ind].vallen);
2125:
2126: if (rc == SQL_ERROR) {
2127: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData");
2128: efree(field);
2129: RETURN_FALSE;
2130: }
2131:
2132: if (result->values[field_ind].vallen == SQL_NULL_DATA) {
2133: efree(field);
2134: RETURN_NULL();
2135: } else if (rc == SQL_NO_DATA_FOUND) {
2136: efree(field);
2137: RETURN_FALSE;
2138: }
2139: /* Reduce fieldlen by 1 if we have char data. One day we might
2140: have binary strings... */
2141: if (result->values[field_ind].coltype == SQL_LONGVARCHAR) {
2142: fieldsize -= 1;
2143: }
2144: /* Don't duplicate result, saves one emalloc.
2145: For SQL_SUCCESS, the length is in vallen.
2146: */
2147: RETURN_STRINGL(field, (rc == SQL_SUCCESS_WITH_INFO) ? fieldsize : result->values[field_ind].vallen, 0);
2148: break;
2149:
2150: default:
2151: if (result->values[field_ind].vallen == SQL_NULL_DATA) {
2152: RETURN_NULL();
2153: } else {
2154: RETURN_STRINGL(result->values[field_ind].value, result->values[field_ind].vallen, 1);
2155: }
2156: break;
2157: }
2158:
2159: /* If we come here, output unbound LONG and/or BINARY column data to the client */
2160:
2161: /* We emalloc 1 byte more for SQL_C_CHAR (trailing \0) */
2162: fieldsize = (sql_c_type == SQL_C_CHAR) ? 4096 : 4095;
2163: field = emalloc(fieldsize);
2164:
2165: /* Call SQLGetData() until SQL_SUCCESS is returned */
2166: while(1) {
2167: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(field_ind + 1),sql_c_type, field, fieldsize, &result->values[field_ind].vallen);
2168:
2169: if (rc == SQL_ERROR) {
2170: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData");
2171: efree(field);
2172: RETURN_FALSE;
2173: }
2174:
2175: if (result->values[field_ind].vallen == SQL_NULL_DATA) {
2176: efree(field);
2177: RETURN_NULL();
2178: }
2179: /* chop the trailing \0 by outputing only 4095 bytes */
2180: PHPWRITE(field,(rc == SQL_SUCCESS_WITH_INFO) ? 4095 : result->values[field_ind].vallen);
2181:
2182: if (rc == SQL_SUCCESS) { /* no more data avail */
2183: efree(field);
2184: RETURN_TRUE;
2185: }
2186: }
2187: RETURN_TRUE;
2188: }
2189: /* }}} */
2190:
2191: /* {{{ proto int odbc_result_all(resource result_id [, string format])
2192: Print result as HTML table */
2193: PHP_FUNCTION(odbc_result_all)
2194: {
2195: char *buf = NULL;
2196: odbc_result *result;
2197: RETCODE rc;
2198: zval *pv_res;
2199: char *pv_format = NULL;
2200: int i, pv_format_len = 0;
2201: SQLSMALLINT sql_c_type;
2202: #ifdef HAVE_SQL_EXTENDED_FETCH
2203: SQLULEN crow;
2204: SQLUSMALLINT RowStatus[1];
2205: #endif
2206:
2207: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s", &pv_res, &pv_format, &pv_format_len) == FAILURE) {
2208: return;
2209: }
2210:
2211: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2212:
2213: if (result->numcols == 0) {
2214: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
2215: RETURN_FALSE;
2216: }
2217: #ifdef HAVE_SQL_EXTENDED_FETCH
2218: if (result->fetch_abs)
2219: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus);
2220: else
2221: #endif
2222: rc = SQLFetch(result->stmt);
2223:
2224: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
2225: php_printf("<h2>No rows found</h2>\n");
2226: RETURN_LONG(0);
2227: }
2228:
2229: /* Start table tag */
2230: if (ZEND_NUM_ARGS() == 1) {
2231: php_printf("<table><tr>");
2232: } else {
2233: php_printf("<table %s ><tr>", pv_format);
2234: }
2235:
2236: for (i = 0; i < result->numcols; i++) {
2237: php_printf("<th>%s</th>", result->values[i].name);
2238: }
2239:
2240: php_printf("</tr>\n");
2241:
2242: while(rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO) {
2243: result->fetched++;
2244: php_printf("<tr>");
2245: for(i = 0; i < result->numcols; i++) {
2246: sql_c_type = SQL_C_CHAR;
2247: switch(result->values[i].coltype) {
2248: case SQL_BINARY:
2249: case SQL_VARBINARY:
2250: case SQL_LONGVARBINARY:
2251: if (result->binmode <= 0) {
2252: php_printf("<td>Not printable</td>");
2253: break;
2254: }
2255: if (result->binmode <= 1) sql_c_type = SQL_C_BINARY;
2256: case SQL_LONGVARCHAR:
2257: if (IS_SQL_LONG(result->values[i].coltype) &&
2258: result->longreadlen <= 0) {
2259: php_printf("<td>Not printable</td>");
2260: break;
2261: }
2262:
2263: if (buf == NULL) {
2264: buf = emalloc(result->longreadlen);
2265: }
2266:
2267: rc = SQLGetData(result->stmt, (SQLUSMALLINT)(i + 1),sql_c_type, buf, result->longreadlen, &result->values[i].vallen);
2268:
2269: php_printf("<td>");
2270:
2271: if (rc == SQL_ERROR) {
2272: odbc_sql_error(result->conn_ptr, result->stmt, "SQLGetData");
2273: php_printf("</td></tr></table>");
2274: efree(buf);
2275: RETURN_FALSE;
2276: }
2277: if (rc == SQL_SUCCESS_WITH_INFO) {
2278: PHPWRITE(buf, result->longreadlen);
2279: } else if (result->values[i].vallen == SQL_NULL_DATA) {
2280: php_printf("<td>NULL</td>");
2281: break;
2282: } else {
2283: PHPWRITE(buf, result->values[i].vallen);
2284: }
2285: php_printf("</td>");
2286: break;
2287: default:
2288: if (result->values[i].vallen == SQL_NULL_DATA) {
2289: php_printf("<td>NULL</td>");
2290: } else {
2291: php_printf("<td>%s</td>", result->values[i].value);
2292: }
2293: break;
2294: }
2295: }
2296: php_printf("</tr>\n");
2297:
2298: #ifdef HAVE_SQL_EXTENDED_FETCH
2299: if (result->fetch_abs)
2300: rc = SQLExtendedFetch(result->stmt,SQL_FETCH_NEXT,1,&crow,RowStatus);
2301: else
2302: #endif
2303: rc = SQLFetch(result->stmt);
2304: }
2305: php_printf("</table>\n");
2306: if (buf) efree(buf);
2307: RETURN_LONG(result->fetched);
2308: }
2309: /* }}} */
2310:
2311: /* {{{ proto bool odbc_free_result(resource result_id)
2312: Free resources associated with a result */
2313: PHP_FUNCTION(odbc_free_result)
2314: {
2315: zval *pv_res;
2316: odbc_result *result;
2317: int i;
2318:
2319: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
2320: return;
2321: }
2322:
2323: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2324: if (result->values) {
2325: for (i = 0; i < result->numcols; i++) {
2326: if (result->values[i].value) {
2327: efree(result->values[i].value);
2328: }
2329: }
2330: efree(result->values);
2331: result->values = NULL;
2332: }
2333:
2334: zend_list_delete(Z_LVAL_P(pv_res));
2335:
2336: RETURN_TRUE;
2337: }
2338: /* }}} */
2339:
2340: /* {{{ proto resource odbc_connect(string DSN, string user, string password [, int cursor_option])
2341: Connect to a datasource */
2342: PHP_FUNCTION(odbc_connect)
2343: {
2344: odbc_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
2345: }
2346: /* }}} */
2347:
2348: /* {{{ proto resource odbc_pconnect(string DSN, string user, string password [, int cursor_option])
2349: Establish a persistent connection to a datasource */
2350: PHP_FUNCTION(odbc_pconnect)
2351: {
2352: odbc_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
2353: }
2354: /* }}} */
2355:
2356: /* {{{ odbc_sqlconnect */
2357: int odbc_sqlconnect(odbc_connection **conn, char *db, char *uid, char *pwd, int cur_opt, int persistent TSRMLS_DC)
2358: {
2359: RETCODE rc;
2360:
2361: *conn = (odbc_connection *)pemalloc(sizeof(odbc_connection), persistent);
2362: (*conn)->persistent = persistent;
2363: SQLAllocEnv(&((*conn)->henv));
2364: SQLAllocConnect((*conn)->henv, &((*conn)->hdbc));
2365:
2366: #if defined(HAVE_SOLID) || defined(HAVE_SOLID_30)
2367: SQLSetConnectOption((*conn)->hdbc, SQL_TRANSLATE_OPTION,
2368: SQL_SOLID_XLATOPT_NOCNV);
2369: #endif
2370: #ifdef HAVE_ODBC_ROUTER
2371: {
2372: #define CONNSTRSIZE 2048
2373: char *lpszConnStr = emalloc(CONNSTRSIZE);
2374: if (lpszConnStr && db) {
2375: short cbszConnStr;
2376: if (strstr(db, ";")) {
2377: /* the caller has apparently passed a connection-string */
2378: if (strstr(db, "uid") || strstr(db, "UID")) {
2379: uid = NULL;
2380: }
2381: if (strstr(db, "pwd") || strstr(db, "PWD")) {
2382: pwd = NULL;
2383: }
2384: strlcpy( lpszConnStr, db, CONNSTRSIZE);
2385: }
2386: else {
2387: strcpy(lpszConnStr, "DSN=");
2388: strlcat(lpszConnStr, db, CONNSTRSIZE);
2389: }
2390: if (uid) {
2391: if (uid[0]) {
2392: strlcat(lpszConnStr, ";UID=", CONNSTRSIZE);
2393: strlcat(lpszConnStr, uid, CONNSTRSIZE);
2394: strlcat(lpszConnStr, ";", CONNSTRSIZE);
2395: }
2396: if (pwd) {
2397: if (pwd[0]) {
2398: strlcat(lpszConnStr, "PWD=", CONNSTRSIZE);
2399: strlcat(lpszConnStr, pwd, CONNSTRSIZE);
2400: strlcat(lpszConnStr, ";", CONNSTRSIZE);
2401: }
2402: }
2403: }
2404: rc = SQLDriverConnect((*conn)->hdbc, NULL, lpszConnStr, SQL_NTS, lpszConnStr, CONNSTRSIZE, &cbszConnStr, SQL_DRIVER_NOPROMPT);
2405: efree(lpszConnStr);
2406: }
2407: }
2408: #else
2409: #ifdef HAVE_OPENLINK
2410: {
2411: char dsnbuf[1024];
2412: short dsnbuflen;
2413:
2414: rc = SQLDriverConnect((*conn)->hdbc, NULL, db, SQL_NTS, dsnbuf, sizeof(dsnbuf) - 1, &dsnbuflen, SQL_DRIVER_NOPROMPT);
2415: }
2416: #else
2417: if (cur_opt != SQL_CUR_DEFAULT) {
2418: rc = SQLSetConnectOption((*conn)->hdbc, SQL_ODBC_CURSORS, cur_opt);
2419: if (rc != SQL_SUCCESS) { /* && rc != SQL_SUCCESS_WITH_INFO ? */
2420: odbc_sql_error(*conn, SQL_NULL_HSTMT, "SQLSetConnectOption");
2421: SQLFreeConnect((*conn)->hdbc);
2422: pefree(*conn, persistent);
2423: return FALSE;
2424: }
2425: }
2426: /* Possible fix for bug #10250
2427: * Needs testing on UnixODBC < 2.0.5 though. */
2428: #if defined(HAVE_EMPRESS) || defined(HAVE_UNIXODBC) || defined(PHP_WIN32) || defined (HAVE_IODBC)
2429: /* * Uncomment the line above, and comment line below to fully test
2430: * #ifdef HAVE_EMPRESS */
2431: {
2432: int direct = 0;
2433: char dsnbuf[1024];
2434: short dsnbuflen;
2435: char *ldb = 0;
2436: int ldb_len = 0;
2437:
2438: if (strstr((char*)db, ";")) {
2439: direct = 1;
2440: if (uid && !strstr ((char*)db, "uid") && !strstr((char*)db, "UID")) {
2441: spprintf(&ldb, 0, "%s;UID=%s;PWD=%s", db, uid, pwd);
2442: } else {
2443: ldb_len = strlen(db)+1;
2444: ldb = (char*) emalloc(ldb_len);
2445: memcpy(ldb, db, ldb_len);
2446: }
2447: }
2448:
2449: if (direct) {
2450: rc = SQLDriverConnect((*conn)->hdbc, NULL, ldb, strlen(ldb), dsnbuf, sizeof(dsnbuf) - 1, &dsnbuflen, SQL_DRIVER_NOPROMPT);
2451: } else {
2452: rc = SQLConnect((*conn)->hdbc, db, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS);
2453: }
2454:
2455: if (ldb) {
2456: efree(ldb);
2457: }
2458: }
2459: #else
2460: rc = SQLConnect((*conn)->hdbc, db, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS);
2461: #endif
2462: #endif
2463: #endif
2464: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
2465: odbc_sql_error(*conn, SQL_NULL_HSTMT, "SQLConnect");
2466: SQLFreeConnect((*conn)->hdbc);
2467: pefree((*conn), persistent);
2468: return FALSE;
2469: }
2470: /* (*conn)->open = 1;*/
2471: return TRUE;
2472: }
2473: /* }}} */
2474:
2475: /* Persistent connections: two list-types le_pconn, le_conn and a plist
2476: * where hashed connection info is stored together with index pointer to
2477: * the actual link of type le_pconn in the list. Only persistent
2478: * connections get hashed up. Normal connections use existing pconnections.
2479: * Maybe this has to change with regard to transactions on pconnections?
2480: * Possibly set autocommit to on on request shutdown.
2481: *
2482: * We do have to hash non-persistent connections, and reuse connections.
2483: * In the case where two connects were being made, without closing the first
2484: * connect, access violations were occuring. This is because some of the
2485: * "globals" in this module should actualy be per-connection variables. I
2486: * simply fixed things to get them working for now. Shane
2487: */
2488: /* {{{ odbc_do_connect */
2489: void odbc_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
2490: {
2491: char *db, *uid, *pwd;
2492: int db_len, uid_len, pwd_len;
2493: long pv_opt = SQL_CUR_DEFAULT;
2494: odbc_connection *db_conn;
2495: char *hashed_details;
2496: int hashed_len, cur_opt;
2497:
2498: /* Now an optional 4th parameter specifying the cursor type
2499: * defaulting to the cursors default
2500: */
2501: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|l", &db, &db_len, &uid, &uid_len, &pwd, &pwd_len, &pv_opt) == FAILURE) {
2502: return;
2503: }
2504:
2505: cur_opt = pv_opt;
2506:
2507: if (ZEND_NUM_ARGS() > 3) {
2508: /* Confirm the cur_opt range */
2509: if (! (cur_opt == SQL_CUR_USE_IF_NEEDED ||
2510: cur_opt == SQL_CUR_USE_ODBC ||
2511: cur_opt == SQL_CUR_USE_DRIVER ||
2512: cur_opt == SQL_CUR_DEFAULT) ) {
2513: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Cursor type (%d)", cur_opt);
2514: RETURN_FALSE;
2515: }
2516: }
2517:
2518: if (ODBCG(allow_persistent) <= 0) {
2519: persistent = 0;
2520: }
2521:
2522: hashed_len = spprintf(&hashed_details, 0, "%s_%s_%s_%s_%d", ODBC_TYPE, db, uid, pwd, cur_opt);
2523:
2524: /* FIXME the idea of checking to see if our connection is already persistent
2525: is good, but it adds a lot of overhead to non-persistent connections. We
2526: should look and see if we can fix that somehow */
2527: /* try to find if we already have this link in our persistent list,
2528: * no matter if it is to be persistent or not
2529: */
2530:
2531: try_and_get_another_connection:
2532:
2533: if (persistent) {
2534: zend_rsrc_list_entry *le;
2535:
2536: /* the link is not in the persistent list */
2537: if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_len + 1, (void **) &le) == FAILURE) {
2538: zend_rsrc_list_entry new_le;
2539:
2540: if (ODBCG(max_links) != -1 && ODBCG(num_links) >= ODBCG(max_links)) {
2541: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open links (%ld)", ODBCG(num_links));
2542: efree(hashed_details);
2543: RETURN_FALSE;
2544: }
2545: if (ODBCG(max_persistent) != -1 && ODBCG(num_persistent) >= ODBCG(max_persistent)) {
2546: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Too many open persistent links (%ld)", ODBCG(num_persistent));
2547: efree(hashed_details);
2548: RETURN_FALSE;
2549: }
2550:
2551: if (!odbc_sqlconnect(&db_conn, db, uid, pwd, cur_opt, 1 TSRMLS_CC)) {
2552: efree(hashed_details);
2553: RETURN_FALSE;
2554: }
2555:
2556: Z_TYPE(new_le) = le_pconn;
2557: new_le.ptr = db_conn;
2558: if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_len + 1, &new_le,
2559: sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
2560: free(db_conn);
2561: efree(hashed_details);
2562: RETURN_FALSE;
2563: }
2564: ODBCG(num_persistent)++;
2565: ODBCG(num_links)++;
2566: db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn);
2567: } else { /* found connection */
2568: if (Z_TYPE_P(le) != le_pconn) {
2569: RETURN_FALSE;
2570: }
2571: /*
2572: * check to see if the connection is still valid
2573: */
2574: db_conn = (odbc_connection *)le->ptr;
2575:
2576: /*
2577: * check to see if the connection is still in place (lurcher)
2578: */
2579: if(ODBCG(check_persistent)){
2580: RETCODE ret;
2581: UCHAR d_name[32];
2582: SQLSMALLINT len;
2583:
2584: ret = SQLGetInfo(db_conn->hdbc,
2585: SQL_DATA_SOURCE_READ_ONLY,
2586: d_name, sizeof(d_name), &len);
2587:
2588: if(ret != SQL_SUCCESS || len == 0) {
2589: zend_hash_del(&EG(persistent_list), hashed_details, hashed_len + 1);
2590: /* Commented out to fix a possible double closure error
2591: * when working with persistent connections as submitted by
2592: * bug #15758
2593: *
2594: * safe_odbc_disconnect(db_conn->hdbc);
2595: * SQLFreeConnect(db_conn->hdbc);
2596: */
2597: goto try_and_get_another_connection;
2598: }
2599: }
2600: }
2601: db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_pconn);
2602: } else { /* non persistent */
2603: zend_rsrc_list_entry *index_ptr, new_index_ptr;
2604:
2605: if (zend_hash_find(&EG(regular_list), hashed_details, hashed_len + 1, (void **) &index_ptr) == SUCCESS) {
2606: int type, conn_id;
2607: void *ptr;
2608:
2609: if (Z_TYPE_P(index_ptr) != le_index_ptr) {
2610: RETURN_FALSE;
2611: }
2612: conn_id = (int)index_ptr->ptr;
2613: ptr = zend_list_find(conn_id, &type); /* check if the connection is still there */
2614:
2615: if (ptr && (type == le_conn || type == le_pconn)) {
2616: zend_list_addref(conn_id);
2617: Z_LVAL_P(return_value) = conn_id;
2618: Z_TYPE_P(return_value) = IS_RESOURCE;
2619: efree(hashed_details);
2620: return;
2621: } else {
2622: zend_hash_del(&EG(regular_list), hashed_details, hashed_len + 1);
2623: }
2624: }
2625: if (ODBCG(max_links) != -1 && ODBCG(num_links) >= ODBCG(max_links)) {
2626: php_error_docref(NULL TSRMLS_CC, E_WARNING,"Too many open connections (%ld)",ODBCG(num_links));
2627: efree(hashed_details);
2628: RETURN_FALSE;
2629: }
2630:
2631: if (!odbc_sqlconnect(&db_conn, db, uid, pwd, cur_opt, 0 TSRMLS_CC)) {
2632: efree(hashed_details);
2633: RETURN_FALSE;
2634: }
2635: db_conn->id = ZEND_REGISTER_RESOURCE(return_value, db_conn, le_conn);
2636: new_index_ptr.ptr = (void *) Z_LVAL_P(return_value);
2637: Z_TYPE(new_index_ptr) = le_index_ptr;
2638:
2639: if (zend_hash_update(&EG(regular_list), hashed_details, hashed_len + 1, (void *) &new_index_ptr,
2640: sizeof(zend_rsrc_list_entry), NULL) == FAILURE) {
2641: efree(hashed_details);
2642: RETURN_FALSE;
2643: /* XXX Free Connection */
2644: }
2645: ODBCG(num_links)++;
2646: }
2647: efree(hashed_details);
2648: }
2649: /* }}} */
2650:
2651: /* {{{ proto void odbc_close(resource connection_id)
2652: Close an ODBC connection */
2653: PHP_FUNCTION(odbc_close)
2654: {
2655: zval *pv_conn;
2656: void *ptr;
2657: odbc_connection *conn;
2658: odbc_result *res;
2659: int nument;
2660: int i;
2661: int type;
2662: int is_pconn = 0;
2663: int found_resource_type = le_conn;
2664:
2665: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_conn) == FAILURE) {
2666: return;
2667: }
2668:
2669: conn = (odbc_connection *) zend_fetch_resource(&pv_conn TSRMLS_CC, -1, "ODBC-Link", &found_resource_type, 2, le_conn, le_pconn);
2670: if (found_resource_type==le_pconn) {
2671: is_pconn = 1;
2672: }
2673:
2674: nument = zend_hash_next_free_element(&EG(regular_list));
2675:
2676: for(i = 1; i < nument; i++){
2677: ptr = zend_list_find(i, &type);
2678: if(ptr && (type == le_result)){
2679: res = (odbc_result *)ptr;
2680: if(res->conn_ptr == conn){
2681: zend_list_delete(i);
2682: }
2683: }
2684: }
2685:
2686: zend_list_delete(Z_LVAL_P(pv_conn));
2687:
2688: if(is_pconn){
2689: zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) _close_pconn_with_id, (void *) &(Z_LVAL_P(pv_conn)) TSRMLS_CC);
2690: }
2691: }
2692: /* }}} */
2693:
2694: /* {{{ proto int odbc_num_rows(resource result_id)
2695: Get number of rows in a result */
2696: PHP_FUNCTION(odbc_num_rows)
2697: {
2698: odbc_result *result;
2699: SQLLEN rows;
2700: zval *pv_res;
2701:
2702: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
2703: return;
2704: }
2705: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2706: SQLRowCount(result->stmt, &rows);
2707: RETURN_LONG(rows);
2708: }
2709: /* }}} */
2710:
2711: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30)
2712: /* {{{ proto bool odbc_next_result(resource result_id)
2713: Checks if multiple results are avaiable */
2714: PHP_FUNCTION(odbc_next_result)
2715: {
2716: odbc_result *result;
2717: zval *pv_res;
2718: int rc, i;
2719:
2720: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
2721: return;
2722: }
2723: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2724:
2725: if (result->values) {
2726: for(i = 0; i < result->numcols; i++) {
2727: if (result->values[i].value) {
2728: efree(result->values[i].value);
2729: }
2730: }
2731: efree(result->values);
2732: result->values = NULL;
2733: }
2734:
2735: result->fetched = 0;
2736: rc = SQLMoreResults(result->stmt);
2737: if (rc == SQL_SUCCESS_WITH_INFO || rc == SQL_SUCCESS) {
2738: rc = SQLFreeStmt(result->stmt, SQL_UNBIND);
2739: SQLNumParams(result->stmt, &(result->numparams));
2740: SQLNumResultCols(result->stmt, &(result->numcols));
2741:
2742: if (result->numcols > 0) {
2743: if (!odbc_bindcols(result TSRMLS_CC)) {
2744: efree(result);
2745: RETVAL_FALSE;
2746: }
2747: } else {
2748: result->values = NULL;
2749: }
2750: RETURN_TRUE;
2751: } else if (rc == SQL_NO_DATA_FOUND) {
2752: RETURN_FALSE;
2753: } else {
2754: odbc_sql_error(result->conn_ptr, result->stmt, "SQLMoreResults");
2755: RETURN_FALSE;
2756: }
2757: }
2758: /* }}} */
2759: #endif
2760:
2761: /* {{{ proto int odbc_num_fields(resource result_id)
2762: Get number of columns in a result */
2763: PHP_FUNCTION(odbc_num_fields)
2764: {
2765: odbc_result *result;
2766: zval *pv_res;
2767:
2768: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &pv_res) == FAILURE) {
2769: return;
2770: }
2771: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2772: RETURN_LONG(result->numcols);
2773: }
2774: /* }}} */
2775:
2776: /* {{{ proto string odbc_field_name(resource result_id, int field_number)
2777: Get a column name */
2778: PHP_FUNCTION(odbc_field_name)
2779: {
2780: odbc_result *result;
2781: zval *pv_res;
2782: long pv_num;
2783:
2784: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) {
2785: return;
2786: }
2787:
2788: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2789:
2790: if (result->numcols == 0) {
2791: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
2792: RETURN_FALSE;
2793: }
2794:
2795: if (pv_num > result->numcols) {
2796: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields");
2797: RETURN_FALSE;
2798: }
2799:
2800: if (pv_num < 1) {
2801: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1");
2802: RETURN_FALSE;
2803: }
2804:
2805: RETURN_STRING(result->values[pv_num - 1].name, 1);
2806: }
2807: /* }}} */
2808:
2809: /* {{{ proto string odbc_field_type(resource result_id, int field_number)
2810: Get the datatype of a column */
2811: PHP_FUNCTION(odbc_field_type)
2812: {
2813: odbc_result *result;
2814: char tmp[32];
2815: SQLSMALLINT tmplen;
2816: zval *pv_res;
2817: long pv_num;
2818:
2819: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &pv_res, &pv_num) == FAILURE) {
2820: return;
2821: }
2822:
2823: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2824:
2825: if (result->numcols == 0) {
2826: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
2827: RETURN_FALSE;
2828: }
2829:
2830: if (pv_num > result->numcols) {
2831: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field index larger than number of fields");
2832: RETURN_FALSE;
2833: }
2834:
2835: if (pv_num < 1) {
2836: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field numbering starts at 1");
2837: RETURN_FALSE;
2838: }
2839:
2840: SQLColAttributes(result->stmt, (SQLUSMALLINT)pv_num, SQL_COLUMN_TYPE_NAME, tmp, 31, &tmplen, NULL);
2841: RETURN_STRING(tmp,1)
2842: }
2843: /* }}} */
2844:
2845: /* {{{ proto int odbc_field_len(resource result_id, int field_number)
2846: Get the length (precision) of a column */
2847: PHP_FUNCTION(odbc_field_len)
2848: {
2849: odbc_column_lengths(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
2850: }
2851: /* }}} */
2852:
2853: /* {{{ proto int odbc_field_scale(resource result_id, int field_number)
2854: Get the scale of a column */
2855: PHP_FUNCTION(odbc_field_scale)
2856: {
2857: odbc_column_lengths(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
2858: }
2859: /* }}} */
2860:
2861: /* {{{ proto int odbc_field_num(resource result_id, string field_name)
2862: Return column number */
2863: PHP_FUNCTION(odbc_field_num)
2864: {
2865: char *fname;
2866: int i, field_ind, fname_len;
2867: odbc_result *result;
2868: zval *pv_res;
2869:
2870: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs", &pv_res, &fname, &fname_len) == FAILURE) {
2871: return;
2872: }
2873:
2874: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_res, -1, "ODBC result", le_result);
2875:
2876: if (result->numcols == 0) {
2877: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No tuples available at this result index");
2878: RETURN_FALSE;
2879: }
2880:
2881: field_ind = -1;
2882: for(i = 0; i < result->numcols; i++) {
2883: if (strcasecmp(result->values[i].name, fname) == 0) {
2884: field_ind = i + 1;
2885: }
2886: }
2887:
2888: if (field_ind == -1) {
2889: RETURN_FALSE;
2890: }
2891: RETURN_LONG(field_ind);
2892: }
2893: /* }}} */
2894:
2895: /* {{{ proto mixed odbc_autocommit(resource connection_id [, int OnOff])
2896: Toggle autocommit mode or get status */
2897: /* There can be problems with pconnections!*/
2898: PHP_FUNCTION(odbc_autocommit)
2899: {
2900: odbc_connection *conn;
2901: RETCODE rc;
2902: zval *pv_conn;
2903: long pv_onoff = 0;
2904:
2905: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_conn, &pv_onoff) == FAILURE) {
2906: return;
2907: }
2908:
2909: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
2910:
2911: if (ZEND_NUM_ARGS() > 1) {
2912: rc = SQLSetConnectOption(conn->hdbc, SQL_AUTOCOMMIT, (pv_onoff) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
2913: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
2914: odbc_sql_error(conn, SQL_NULL_HSTMT, "Set autocommit");
2915: RETURN_FALSE;
2916: }
2917: RETVAL_TRUE;
2918: } else {
2919: SQLINTEGER status;
2920:
2921: rc = SQLGetConnectOption(conn->hdbc, SQL_AUTOCOMMIT, (PTR)&status);
2922: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
2923: odbc_sql_error(conn, SQL_NULL_HSTMT, "Get commit status");
2924: RETURN_FALSE;
2925: }
2926: RETVAL_LONG((long)status);
2927: }
2928: }
2929: /* }}} */
2930:
2931: /* {{{ proto bool odbc_commit(resource connection_id)
2932: Commit an ODBC transaction */
2933: PHP_FUNCTION(odbc_commit)
2934: {
2935: odbc_transact(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
2936: }
2937: /* }}} */
2938:
2939: /* {{{ proto bool odbc_rollback(resource connection_id)
2940: Rollback a transaction */
2941: PHP_FUNCTION(odbc_rollback)
2942: {
2943: odbc_transact(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
2944: }
2945: /* }}} */
2946:
2947: /* {{{ php_odbc_lasterror */
2948: static void php_odbc_lasterror(INTERNAL_FUNCTION_PARAMETERS, int mode)
2949: {
2950: odbc_connection *conn;
2951: zval *pv_handle;
2952: char *ptr;
2953: int len;
2954:
2955: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &pv_handle) == FAILURE) {
2956: return;
2957: }
2958:
2959: if (mode == 0) { /* last state */
2960: len = 6;
2961: } else { /* last error message */
2962: len = SQL_MAX_MESSAGE_LENGTH;
2963: }
2964:
2965: if (ZEND_NUM_ARGS() == 1) {
2966: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_handle, -1, "ODBC-Link", le_conn, le_pconn);
2967: ptr = ecalloc(len + 1, 1);
2968: if (mode == 0) {
2969: strlcpy(ptr, conn->laststate, len+1);
2970: } else {
2971: strlcpy(ptr, conn->lasterrormsg, len+1);
2972: }
2973: } else {
2974: ptr = ecalloc(len + 1, 1);
2975: if (mode == 0) {
2976: strlcpy(ptr, ODBCG(laststate), len+1);
2977: } else {
2978: strlcpy(ptr, ODBCG(lasterrormsg), len+1);
2979: }
2980: }
2981: RETVAL_STRING(ptr, 0);
2982: }
2983: /* }}} */
2984:
2985: /* {{{ proto string odbc_error([resource connection_id])
2986: Get the last error code */
2987: PHP_FUNCTION(odbc_error)
2988: {
2989: php_odbc_lasterror(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
2990: }
2991: /* }}} */
2992:
2993: /* {{{ proto string odbc_errormsg([resource connection_id])
2994: Get the last error message */
2995: PHP_FUNCTION(odbc_errormsg)
2996: {
2997: php_odbc_lasterror(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
2998: }
2999: /* }}} */
3000:
3001: /* {{{ proto bool odbc_setoption(resource conn_id|result_id, int which, int option, int value)
3002: Sets connection or statement options */
3003: /* This one has to be used carefully. We can't allow to set connection options for
3004: persistent connections. I think that SetStmtOption is of little use, since most
3005: of those can only be specified before preparing/executing statements.
3006: On the other hand, they can be made connection wide default through SetConnectOption
3007: - but will be overidden by calls to SetStmtOption() in odbc_prepare/odbc_do
3008: */
3009: PHP_FUNCTION(odbc_setoption)
3010: {
3011: odbc_connection *conn;
3012: odbc_result *result;
3013: RETCODE rc;
3014: zval *pv_handle;
3015: long pv_which, pv_opt, pv_val;
3016:
3017: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rlll", &pv_handle, &pv_which, &pv_opt, &pv_val) == FAILURE) {
3018: return;
3019: }
3020:
3021: switch (pv_which) {
3022: case 1: /* SQLSetConnectOption */
3023: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_handle, -1, "ODBC-Link", le_conn, le_pconn);
3024:
3025: if (conn->persistent) {
3026: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to set option for persistent connection");
3027: RETURN_FALSE;
3028: }
3029: rc = SQLSetConnectOption(conn->hdbc, (unsigned short) pv_opt, pv_val);
3030: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
3031: odbc_sql_error(conn, SQL_NULL_HSTMT, "SetConnectOption");
3032: RETURN_FALSE;
3033: }
3034: break;
3035: case 2: /* SQLSetStmtOption */
3036: ZEND_FETCH_RESOURCE(result, odbc_result *, &pv_handle, -1, "ODBC result", le_result);
3037:
3038: rc = SQLSetStmtOption(result->stmt, (unsigned short) pv_opt, pv_val);
3039:
3040: if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
3041: odbc_sql_error(result->conn_ptr, result->stmt, "SetStmtOption");
3042: RETURN_FALSE;
3043: }
3044: break;
3045: default:
3046: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option type");
3047: RETURN_FALSE;
3048: break;
3049: }
3050:
3051: RETURN_TRUE;
3052: }
3053: /* }}} */
3054:
3055: /*
3056: * metadata functions
3057: */
3058:
3059: /* {{{ proto resource odbc_tables(resource connection_id [, string qualifier [, string owner [, string name [, string table_types]]]])
3060: Call the SQLTables function */
3061: PHP_FUNCTION(odbc_tables)
3062: {
3063: zval *pv_conn;
3064: odbc_result *result = NULL;
3065: odbc_connection *conn;
3066: char *cat = NULL, *schema = NULL, *table = NULL, *type = NULL;
3067: int cat_len = 0, schema_len = 0, table_len = 0, type_len = 0;
3068: RETCODE rc;
3069:
3070: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len,
3071: &table, &table_len, &type, &type_len) == FAILURE) {
3072: return;
3073: }
3074:
3075: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3076:
3077: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3078:
3079: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3080: if (rc == SQL_INVALID_HANDLE) {
3081: efree(result);
3082: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3083: RETURN_FALSE;
3084: }
3085:
3086: if (rc == SQL_ERROR) {
3087: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3088: efree(result);
3089: RETURN_FALSE;
3090: }
3091:
3092: /* This hack is needed to access table information in Access databases (fmk) */
3093: if (table && table_len && schema && schema_len == 0) {
3094: schema = NULL;
3095: }
3096:
3097: rc = SQLTables(result->stmt,
3098: cat, SAFE_SQL_NTS(cat),
3099: schema, SAFE_SQL_NTS(schema),
3100: table, SAFE_SQL_NTS(table),
3101: type, SAFE_SQL_NTS(type));
3102:
3103: if (rc == SQL_ERROR) {
3104: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLTables");
3105: efree(result);
3106: RETURN_FALSE;
3107: }
3108:
3109: result->numparams = 0;
3110: SQLNumResultCols(result->stmt, &(result->numcols));
3111:
3112: if (result->numcols > 0) {
3113: if (!odbc_bindcols(result TSRMLS_CC)) {
3114: efree(result);
3115: RETURN_FALSE;
3116: }
3117: } else {
3118: result->values = NULL;
3119: }
3120: result->conn_ptr = conn;
3121: result->fetched = 0;
3122: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3123: }
3124: /* }}} */
3125:
3126: /* {{{ proto resource odbc_columns(resource connection_id [, string qualifier [, string owner [, string table_name [, string column_name]]]])
3127: Returns a result identifier that can be used to fetch a list of column names in specified tables */
3128: PHP_FUNCTION(odbc_columns)
3129: {
3130: zval *pv_conn;
3131: odbc_result *result = NULL;
3132: odbc_connection *conn;
3133: char *cat = NULL, *schema = NULL, *table = NULL, *column = NULL;
3134: int cat_len = 0, schema_len = 0, table_len = 0, column_len = 0;
3135: RETCODE rc;
3136:
3137: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len,
3138: &table, &table_len, &column, &column_len) == FAILURE) {
3139: return;
3140: }
3141:
3142: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3143:
3144: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3145:
3146: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3147: if (rc == SQL_INVALID_HANDLE) {
3148: efree(result);
3149: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3150: RETURN_FALSE;
3151: }
3152:
3153: if (rc == SQL_ERROR) {
3154: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3155: efree(result);
3156: RETURN_FALSE;
3157: }
3158:
3159: /*
3160: * Needed to make MS Access happy
3161: */
3162: if (table && table_len && schema && schema_len == 0) {
3163: schema = NULL;
3164: }
3165:
3166: rc = SQLColumns(result->stmt,
3167: cat, (SQLSMALLINT) cat_len,
3168: schema, (SQLSMALLINT) schema_len,
3169: table, (SQLSMALLINT) table_len,
3170: column, (SQLSMALLINT) column_len);
3171:
3172: if (rc == SQL_ERROR) {
3173: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLColumns");
3174: efree(result);
3175: RETURN_FALSE;
3176: }
3177:
3178: result->numparams = 0;
3179: SQLNumResultCols(result->stmt, &(result->numcols));
3180:
3181: if (result->numcols > 0) {
3182: if (!odbc_bindcols(result TSRMLS_CC)) {
3183: efree(result);
3184: RETURN_FALSE;
3185: }
3186: } else {
3187: result->values = NULL;
3188: }
3189: result->conn_ptr = conn;
3190: result->fetched = 0;
3191: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3192: }
3193: /* }}} */
3194:
3195: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP)
3196: /* {{{ proto resource odbc_columnprivileges(resource connection_id, string catalog, string schema, string table, string column)
3197: Returns a result identifier that can be used to fetch a list of columns and associated privileges for the specified table */
3198: PHP_FUNCTION(odbc_columnprivileges)
3199: {
3200: zval *pv_conn;
3201: odbc_result *result = NULL;
3202: odbc_connection *conn;
3203: char *cat = NULL, *schema, *table, *column;
3204: int cat_len = 0, schema_len, table_len, column_len;
3205: RETCODE rc;
3206:
3207: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len,
3208: &table, &table_len, &column, &column_len) == FAILURE) {
3209: return;
3210: }
3211:
3212: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3213:
3214: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3215:
3216: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3217: if (rc == SQL_INVALID_HANDLE) {
3218: efree(result);
3219: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3220: RETURN_FALSE;
3221: }
3222:
3223: if (rc == SQL_ERROR) {
3224: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3225: efree(result);
3226: RETURN_FALSE;
3227: }
3228:
3229: rc = SQLColumnPrivileges(result->stmt,
3230: cat, SAFE_SQL_NTS(cat),
3231: schema, SAFE_SQL_NTS(schema),
3232: table, SAFE_SQL_NTS(table),
3233: column, SAFE_SQL_NTS(column));
3234:
3235: if (rc == SQL_ERROR) {
3236: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLColumnPrivileges");
3237: efree(result);
3238: RETURN_FALSE;
3239: }
3240:
3241: result->numparams = 0;
3242: SQLNumResultCols(result->stmt, &(result->numcols));
3243:
3244: if (result->numcols > 0) {
3245: if (!odbc_bindcols(result TSRMLS_CC)) {
3246: efree(result);
3247: RETURN_FALSE;
3248: }
3249: } else {
3250: result->values = NULL;
3251: }
3252: result->conn_ptr = conn;
3253: result->fetched = 0;
3254: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3255: }
3256: /* }}} */
3257: #endif /* HAVE_DBMAKER || HAVE_SOLID*/
3258:
3259: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35)
3260: /* {{{ proto resource odbc_foreignkeys(resource connection_id, string pk_qualifier, string pk_owner, string pk_table, string fk_qualifier, string fk_owner, string fk_table)
3261: Returns a result identifier to either a list of foreign keys in the specified table or a list of foreign keys in other tables that refer to the primary key in the specified table */
3262: PHP_FUNCTION(odbc_foreignkeys)
3263: {
3264: zval *pv_conn;
3265: odbc_result *result = NULL;
3266: odbc_connection *conn;
3267: char *pcat = NULL, *pschema, *ptable, *fcat, *fschema, *ftable;
3268: int pcat_len = 0, pschema_len, ptable_len, fcat_len, fschema_len, ftable_len;
3269: RETCODE rc;
3270:
3271: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!sssss", &pv_conn, &pcat, &pcat_len, &pschema, &pschema_len,
3272: &ptable, &ptable_len, &fcat, &fcat_len, &fschema, &fschema_len, &ftable, &ftable_len) == FAILURE) {
3273: return;
3274: }
3275:
3276: #if defined(HAVE_DBMAKER) || defined(HAVE_IBMDB2)
3277: #define EMPTY_TO_NULL(xstr) \
3278: if ((int)strlen((xstr)) == 0) (xstr) = NULL
3279:
3280: EMPTY_TO_NULL(pcat);
3281: EMPTY_TO_NULL(pschema);
3282: EMPTY_TO_NULL(ptable);
3283: EMPTY_TO_NULL(fcat);
3284: EMPTY_TO_NULL(fschema);
3285: EMPTY_TO_NULL(ftable);
3286: #endif
3287:
3288: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3289:
3290: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3291:
3292: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3293: if (rc == SQL_INVALID_HANDLE) {
3294: efree(result);
3295: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3296: RETURN_FALSE;
3297: }
3298:
3299: if (rc == SQL_ERROR) {
3300: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3301: efree(result);
3302: RETURN_FALSE;
3303: }
3304:
3305: rc = SQLForeignKeys(result->stmt,
3306: pcat, SAFE_SQL_NTS(pcat),
3307: pschema, SAFE_SQL_NTS(pschema),
3308: ptable, SAFE_SQL_NTS(ptable),
3309: fcat, SAFE_SQL_NTS(fcat),
3310: fschema, SAFE_SQL_NTS(fschema),
3311: ftable, SAFE_SQL_NTS(ftable) );
3312:
3313: if (rc == SQL_ERROR) {
3314: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLForeignKeys");
3315: efree(result);
3316: RETURN_FALSE;
3317: }
3318:
3319: result->numparams = 0;
3320: SQLNumResultCols(result->stmt, &(result->numcols));
3321:
3322: if (result->numcols > 0) {
3323: if (!odbc_bindcols(result TSRMLS_CC)) {
3324: efree(result);
3325: RETURN_FALSE;
3326: }
3327: } else {
3328: result->values = NULL;
3329: }
3330: result->conn_ptr = conn;
3331: result->fetched = 0;
3332: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3333: }
3334: /* }}} */
3335: #endif /* HAVE_SOLID */
3336:
3337: /* {{{ proto resource odbc_gettypeinfo(resource connection_id [, int data_type])
3338: Returns a result identifier containing information about data types supported by the data source */
3339: PHP_FUNCTION(odbc_gettypeinfo)
3340: {
3341: zval *pv_conn;
3342: long pv_data_type = SQL_ALL_TYPES;
3343: odbc_result *result = NULL;
3344: odbc_connection *conn;
3345: RETCODE rc;
3346: SQLSMALLINT data_type;
3347:
3348: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &pv_conn, &pv_data_type) == FAILURE) {
3349: return;
3350: }
3351:
3352: data_type = (SQLSMALLINT) pv_data_type;
3353:
3354: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3355:
3356: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3357:
3358: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3359: if (rc == SQL_INVALID_HANDLE) {
3360: efree(result);
3361: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3362: RETURN_FALSE;
3363: }
3364:
3365: if (rc == SQL_ERROR) {
3366: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3367: efree(result);
3368: RETURN_FALSE;
3369: }
3370:
3371: rc = SQLGetTypeInfo(result->stmt, data_type );
3372:
3373: if (rc == SQL_ERROR) {
3374: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLGetTypeInfo");
3375: efree(result);
3376: RETURN_FALSE;
3377: }
3378:
3379: result->numparams = 0;
3380: SQLNumResultCols(result->stmt, &(result->numcols));
3381:
3382: if (result->numcols > 0) {
3383: if (!odbc_bindcols(result TSRMLS_CC)) {
3384: efree(result);
3385: RETURN_FALSE;
3386: }
3387: } else {
3388: result->values = NULL;
3389: }
3390: result->conn_ptr = conn;
3391: result->fetched = 0;
3392: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3393: }
3394: /* }}} */
3395:
3396: /* {{{ proto resource odbc_primarykeys(resource connection_id, string qualifier, string owner, string table)
3397: Returns a result identifier listing the column names that comprise the primary key for a table */
3398: PHP_FUNCTION(odbc_primarykeys)
3399: {
3400: zval *pv_conn;
3401: odbc_result *result = NULL;
3402: odbc_connection *conn;
3403: char *cat = NULL, *schema = NULL, *table = NULL;
3404: int cat_len = 0, schema_len, table_len;
3405: RETCODE rc;
3406:
3407: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!ss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &table, &table_len) == FAILURE) {
3408: return;
3409: }
3410:
3411: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3412:
3413: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3414:
3415: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3416: if (rc == SQL_INVALID_HANDLE) {
3417: efree(result);
3418: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3419: RETURN_FALSE;
3420: }
3421:
3422: if (rc == SQL_ERROR) {
3423: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3424: efree(result);
3425: RETURN_FALSE;
3426: }
3427:
3428: rc = SQLPrimaryKeys(result->stmt,
3429: cat, SAFE_SQL_NTS(cat),
3430: schema, SAFE_SQL_NTS(schema),
3431: table, SAFE_SQL_NTS(table) );
3432:
3433: if (rc == SQL_ERROR) {
3434: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLPrimaryKeys");
3435: efree(result);
3436: RETURN_FALSE;
3437: }
3438:
3439: result->numparams = 0;
3440: SQLNumResultCols(result->stmt, &(result->numcols));
3441:
3442: if (result->numcols > 0) {
3443: if (!odbc_bindcols(result TSRMLS_CC)) {
3444: efree(result);
3445: RETURN_FALSE;
3446: }
3447: } else {
3448: result->values = NULL;
3449: }
3450: result->conn_ptr = conn;
3451: result->fetched = 0;
3452: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3453: }
3454: /* }}} */
3455:
3456: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP)
3457: /* {{{ proto resource odbc_procedurecolumns(resource connection_id [, string qualifier, string owner, string proc, string column])
3458: Returns a result identifier containing the list of input and output parameters, as well as the columns that make up the result set for the specified procedures */
3459: PHP_FUNCTION(odbc_procedurecolumns)
3460: {
3461: zval *pv_conn;
3462: odbc_result *result = NULL;
3463: odbc_connection *conn;
3464: char *cat = NULL, *schema = NULL, *proc = NULL, *col = NULL;
3465: int cat_len = 0, schema_len = 0, proc_len = 0, col_len = 0;
3466: RETCODE rc;
3467:
3468: if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 5) {
3469: WRONG_PARAM_COUNT;
3470: }
3471:
3472: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!sss", &pv_conn, &cat, &cat_len, &schema, &schema_len,
3473: &proc, &proc_len, &col, &col_len) == FAILURE) {
3474: return;
3475: }
3476:
3477: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3478:
3479: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3480:
3481: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3482: if (rc == SQL_INVALID_HANDLE) {
3483: efree(result);
3484: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3485: RETURN_FALSE;
3486: }
3487:
3488: if (rc == SQL_ERROR) {
3489: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3490: efree(result);
3491: RETURN_FALSE;
3492: }
3493:
3494: rc = SQLProcedureColumns(result->stmt,
3495: cat, SAFE_SQL_NTS(cat),
3496: schema, SAFE_SQL_NTS(schema),
3497: proc, SAFE_SQL_NTS(proc),
3498: col, SAFE_SQL_NTS(col) );
3499:
3500: if (rc == SQL_ERROR) {
3501: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLProcedureColumns");
3502: efree(result);
3503: RETURN_FALSE;
3504: }
3505:
3506: result->numparams = 0;
3507: SQLNumResultCols(result->stmt, &(result->numcols));
3508:
3509: if (result->numcols > 0) {
3510: if (!odbc_bindcols(result TSRMLS_CC)) {
3511: efree(result);
3512: RETURN_FALSE;
3513: }
3514: } else {
3515: result->values = NULL;
3516: }
3517: result->conn_ptr = conn;
3518: result->fetched = 0;
3519: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3520: }
3521: /* }}} */
3522: #endif /* HAVE_SOLID */
3523:
3524: #if !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35)
3525: /* {{{ proto resource odbc_procedures(resource connection_id [, string qualifier, string owner, string name])
3526: Returns a result identifier containg the list of procedure names in a datasource */
3527: PHP_FUNCTION(odbc_procedures)
3528: {
3529: zval *pv_conn;
3530: odbc_result *result = NULL;
3531: odbc_connection *conn;
3532: char *cat = NULL, *schema = NULL, *proc = NULL;
3533: int cat_len = 0, schema_len = 0, proc_len = 0;
3534: RETCODE rc;
3535:
3536: if (ZEND_NUM_ARGS() != 1 && ZEND_NUM_ARGS() != 4) {
3537: WRONG_PARAM_COUNT;
3538: }
3539:
3540: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|s!ss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &proc, &proc_len) == FAILURE) {
3541: return;
3542: }
3543:
3544: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3545:
3546: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3547:
3548: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3549: if (rc == SQL_INVALID_HANDLE) {
3550: efree(result);
3551: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3552: RETURN_FALSE;
3553: }
3554:
3555: if (rc == SQL_ERROR) {
3556: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3557: efree(result);
3558: RETURN_FALSE;
3559: }
3560:
3561: rc = SQLProcedures(result->stmt,
3562: cat, SAFE_SQL_NTS(cat),
3563: schema, SAFE_SQL_NTS(schema),
3564: proc, SAFE_SQL_NTS(proc) );
3565:
3566: if (rc == SQL_ERROR) {
3567: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLProcedures");
3568: efree(result);
3569: RETURN_FALSE;
3570: }
3571:
3572: result->numparams = 0;
3573: SQLNumResultCols(result->stmt, &(result->numcols));
3574:
3575: if (result->numcols > 0) {
3576: if (!odbc_bindcols(result TSRMLS_CC)) {
3577: efree(result);
3578: RETURN_FALSE;
3579: }
3580: } else {
3581: result->values = NULL;
3582: }
3583: result->conn_ptr = conn;
3584: result->fetched = 0;
3585: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3586: }
3587: /* }}} */
3588: #endif /* HAVE_SOLID */
3589:
3590: /* {{{ proto resource odbc_specialcolumns(resource connection_id, int type, string qualifier, string owner, string table, int scope, int nullable)
3591: Returns a result identifier containing either the optimal set of columns that uniquely identifies a row in the table or columns that are automatically updated when any value in the row is updated by a transaction */
3592: PHP_FUNCTION(odbc_specialcolumns)
3593: {
3594: zval *pv_conn;
3595: long vtype, vscope, vnullable;
3596: odbc_result *result = NULL;
3597: odbc_connection *conn;
3598: char *cat = NULL, *schema = NULL, *name = NULL;
3599: int cat_len = 0, schema_len, name_len;
3600: SQLUSMALLINT type, scope, nullable;
3601: RETCODE rc;
3602:
3603: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rls!ssll", &pv_conn, &vtype, &cat, &cat_len, &schema, &schema_len,
3604: &name, &name_len, &vscope, &vnullable) == FAILURE) {
3605: return;
3606: }
3607:
3608: type = (SQLUSMALLINT) vtype;
3609: scope = (SQLUSMALLINT) vscope;
3610: nullable = (SQLUSMALLINT) vnullable;
3611:
3612: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3613:
3614: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3615:
3616: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3617: if (rc == SQL_INVALID_HANDLE) {
3618: efree(result);
3619: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3620: RETURN_FALSE;
3621: }
3622:
3623: if (rc == SQL_ERROR) {
3624: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3625: efree(result);
3626: RETURN_FALSE;
3627: }
3628:
3629: rc = SQLSpecialColumns(result->stmt,
3630: type,
3631: cat, SAFE_SQL_NTS(cat),
3632: schema, SAFE_SQL_NTS(schema),
3633: name, SAFE_SQL_NTS(name),
3634: scope,
3635: nullable);
3636:
3637: if (rc == SQL_ERROR) {
3638: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLSpecialColumns");
3639: efree(result);
3640: RETURN_FALSE;
3641: }
3642:
3643: result->numparams = 0;
3644: SQLNumResultCols(result->stmt, &(result->numcols));
3645:
3646: if (result->numcols > 0) {
3647: if (!odbc_bindcols(result TSRMLS_CC)) {
3648: efree(result);
3649: RETURN_FALSE;
3650: }
3651: } else {
3652: result->values = NULL;
3653: }
3654: result->conn_ptr = conn;
3655: result->fetched = 0;
3656: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3657: }
3658: /* }}} */
3659:
3660: /* {{{ proto resource odbc_statistics(resource connection_id, string qualifier, string owner, string name, int unique, int accuracy)
3661: Returns a result identifier that contains statistics about a single table and the indexes associated with the table */
3662: PHP_FUNCTION(odbc_statistics)
3663: {
3664: zval *pv_conn;
3665: long vunique, vreserved;
3666: odbc_result *result = NULL;
3667: odbc_connection *conn;
3668: char *cat = NULL, *schema, *name;
3669: int cat_len = 0, schema_len, name_len;
3670: SQLUSMALLINT unique, reserved;
3671: RETCODE rc;
3672:
3673: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!ssll", &pv_conn, &cat, &cat_len, &schema, &schema_len,
3674: &name, &name_len, &vunique, &vreserved) == FAILURE) {
3675: return;
3676: }
3677:
3678: unique = (SQLUSMALLINT) vunique;
3679: reserved = (SQLUSMALLINT) vreserved;
3680:
3681: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3682:
3683: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3684:
3685: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3686: if (rc == SQL_INVALID_HANDLE) {
3687: efree(result);
3688: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3689: RETURN_FALSE;
3690: }
3691:
3692: if (rc == SQL_ERROR) {
3693: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3694: efree(result);
3695: RETURN_FALSE;
3696: }
3697:
3698: rc = SQLStatistics(result->stmt,
3699: cat, SAFE_SQL_NTS(cat),
3700: schema, SAFE_SQL_NTS(schema),
3701: name, SAFE_SQL_NTS(name),
3702: unique,
3703: reserved);
3704:
3705: if (rc == SQL_ERROR) {
3706: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLStatistics");
3707: efree(result);
3708: RETURN_FALSE;
3709: }
3710:
3711: result->numparams = 0;
3712: SQLNumResultCols(result->stmt, &(result->numcols));
3713:
3714: if (result->numcols > 0) {
3715: if (!odbc_bindcols(result TSRMLS_CC)) {
3716: efree(result);
3717: RETURN_FALSE;
3718: }
3719: } else {
3720: result->values = NULL;
3721: }
3722: result->conn_ptr = conn;
3723: result->fetched = 0;
3724: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3725: }
3726: /* }}} */
3727:
3728: #if !defined(HAVE_DBMAKER) && !defined(HAVE_SOLID) && !defined(HAVE_SOLID_30) && !defined(HAVE_SOLID_35) && !defined(HAVE_BIRDSTEP)
3729: /* {{{ proto resource odbc_tableprivileges(resource connection_id, string qualifier, string owner, string name)
3730: Returns a result identifier containing a list of tables and the privileges associated with each table */
3731: PHP_FUNCTION(odbc_tableprivileges)
3732: {
3733: zval *pv_conn;
3734: odbc_result *result = NULL;
3735: odbc_connection *conn;
3736: char *cat = NULL, *schema = NULL, *table = NULL;
3737: int cat_len = 0, schema_len, table_len;
3738: RETCODE rc;
3739:
3740: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs!ss", &pv_conn, &cat, &cat_len, &schema, &schema_len, &table, &table_len) == FAILURE) {
3741: return;
3742: }
3743:
3744: ZEND_FETCH_RESOURCE2(conn, odbc_connection *, &pv_conn, -1, "ODBC-Link", le_conn, le_pconn);
3745:
3746: result = (odbc_result *)ecalloc(1, sizeof(odbc_result));
3747:
3748: rc = SQLAllocStmt(conn->hdbc, &(result->stmt));
3749: if (rc == SQL_INVALID_HANDLE) {
3750: efree(result);
3751: php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLAllocStmt error 'Invalid Handle'");
3752: RETURN_FALSE;
3753: }
3754:
3755: if (rc == SQL_ERROR) {
3756: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLAllocStmt");
3757: efree(result);
3758: RETURN_FALSE;
3759: }
3760:
3761: rc = SQLTablePrivileges(result->stmt,
3762: cat, SAFE_SQL_NTS(cat),
3763: schema, SAFE_SQL_NTS(schema),
3764: table, SAFE_SQL_NTS(table));
3765:
3766: if (rc == SQL_ERROR) {
3767: odbc_sql_error(conn, SQL_NULL_HSTMT, "SQLTablePrivileges");
3768: efree(result);
3769: RETURN_FALSE;
3770: }
3771:
3772: result->numparams = 0;
3773: SQLNumResultCols(result->stmt, &(result->numcols));
3774:
3775: if (result->numcols > 0) {
3776: if (!odbc_bindcols(result TSRMLS_CC)) {
3777: efree(result);
3778: RETURN_FALSE;
3779: }
3780: } else {
3781: result->values = NULL;
3782: }
3783: result->conn_ptr = conn;
3784: result->fetched = 0;
3785: ZEND_REGISTER_RESOURCE(return_value, result, le_result);
3786: }
3787: /* }}} */
3788: #endif /* HAVE_DBMAKER */
3789:
3790: #endif /* HAVE_UODBC */
3791:
3792: /*
3793: * Local variables:
3794: * tab-width: 4
3795: * c-basic-offset: 4
3796: * End:
3797: * vim600: sw=4 ts=4 fdm=marker
3798: * vim<600: sw=4 ts=4
3799: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_odbc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / odbc