1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2014 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: Scott MacVicar <scottmac@php.net> |
16: +----------------------------------------------------------------------+
17: */
18:
19: /* $Id: sqlite3.c,v 1.1.1.4 2014/06/15 20:03:56 misho Exp $ */
20:
21: #ifdef HAVE_CONFIG_H
22: #include "config.h"
23: #endif
24:
25: #include "php.h"
26: #include "php_ini.h"
27: #include "ext/standard/info.h"
28: #include "php_sqlite3.h"
29: #include "php_sqlite3_structs.h"
30: #include "main/SAPI.h"
31:
32: #include <sqlite3.h>
33:
34: #include "zend_exceptions.h"
35: #include "zend_interfaces.h"
36: #include "SAPI.h"
37:
38: ZEND_DECLARE_MODULE_GLOBALS(sqlite3)
39:
40: static PHP_GINIT_FUNCTION(sqlite3);
41: static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, const char *arg5, const char *arg6);
42: static void sqlite3_param_dtor(void *data);
43: static int php_sqlite3_compare_stmt_zval_free(php_sqlite3_free_list **free_list, zval *statement);
44:
45: /* {{{ Error Handler
46: */
47: static void php_sqlite3_error(php_sqlite3_db_object *db_obj, char *format, ...)
48: {
49: va_list arg;
50: char *message;
51: TSRMLS_FETCH();
52:
53: va_start(arg, format);
54: vspprintf(&message, 0, format, arg);
55: va_end(arg);
56:
57: if (db_obj->exception) {
58: zend_throw_exception(zend_exception_get_default(TSRMLS_C), message, 0 TSRMLS_CC);
59: } else {
60: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
61: }
62:
63: if (message) {
64: efree(message);
65: }
66: }
67: /* }}} */
68:
69: #define SQLITE3_CHECK_INITIALIZED(db_obj, member, class_name) \
70: if (!(member)) { \
71: php_sqlite3_error(db_obj, "The " #class_name " object has not been correctly initialised"); \
72: RETURN_FALSE; \
73: }
74:
75: /* {{{ PHP_INI
76: */
77: PHP_INI_BEGIN()
78: STD_PHP_INI_ENTRY("sqlite3.extension_dir", NULL, PHP_INI_SYSTEM, OnUpdateString, extension_dir, zend_sqlite3_globals, sqlite3_globals)
79: PHP_INI_END()
80: /* }}} */
81:
82: /* Handlers */
83: static zend_object_handlers sqlite3_object_handlers;
84: static zend_object_handlers sqlite3_stmt_object_handlers;
85: static zend_object_handlers sqlite3_result_object_handlers;
86:
87: /* Class entries */
88: zend_class_entry *php_sqlite3_sc_entry;
89: zend_class_entry *php_sqlite3_stmt_entry;
90: zend_class_entry *php_sqlite3_result_entry;
91:
92: /* {{{ proto void SQLite3::open(String filename [, int Flags [, string Encryption Key]])
93: Opens a SQLite 3 Database, if the build includes encryption then it will attempt to use the key. */
94: PHP_METHOD(sqlite3, open)
95: {
96: php_sqlite3_db_object *db_obj;
97: zval *object = getThis();
98: char *filename, *encryption_key, *fullpath;
99: int filename_len, encryption_key_len = 0;
100: long flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
101: zend_error_handling error_handling;
102:
103: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
104: zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
105:
106: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|ls", &filename, &filename_len, &flags, &encryption_key, &encryption_key_len)) {
107: zend_restore_error_handling(&error_handling TSRMLS_CC);
108: return;
109: }
110:
111: zend_restore_error_handling(&error_handling TSRMLS_CC);
112:
113: if (db_obj->initialised) {
114: zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Already initialised DB Object", 0 TSRMLS_CC);
115: }
116:
117: if (strlen(filename) != filename_len) {
118: return;
119: }
120: if (memcmp(filename, ":memory:", sizeof(":memory:")) != 0) {
121: if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) {
122: zend_throw_exception(zend_exception_get_default(TSRMLS_C), "Unable to expand filepath", 0 TSRMLS_CC);
123: return;
124: }
125:
126: #if PHP_API_VERSION < 20100412
127: if (PG(safe_mode) && (!php_checkuid(fullpath, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
128: zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "safe_mode prohibits opening %s", fullpath);
129: efree(fullpath);
130: return;
131: }
132: #endif
133:
134: if (php_check_open_basedir(fullpath TSRMLS_CC)) {
135: zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "open_basedir prohibits opening %s", fullpath);
136: efree(fullpath);
137: return;
138: }
139: } else {
140: fullpath = estrdup(filename);
141: }
142:
143: #if SQLITE_VERSION_NUMBER >= 3005000
144: if (sqlite3_open_v2(fullpath, &(db_obj->db), flags, NULL) != SQLITE_OK) {
145: #else
146: if (sqlite3_open(fullpath, &(db_obj->db)) != SQLITE_OK) {
147: #endif
148: zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
149: if (fullpath) {
150: efree(fullpath);
151: }
152: return;
153: }
154:
155: #if SQLITE_HAS_CODEC
156: if (encryption_key_len > 0) {
157: if (sqlite3_key(db_obj->db, encryption_key, encryption_key_len) != SQLITE_OK) {
158: zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Unable to open database: %s", sqlite3_errmsg(db_obj->db));
159: return;
160: }
161: }
162: #endif
163:
164: db_obj->initialised = 1;
165:
166: #if PHP_API_VERSION < 20100412
167: if (PG(safe_mode) || (PG(open_basedir) && *PG(open_basedir))) {
168: #else
169: if (PG(open_basedir) && *PG(open_basedir)) {
170: #endif
171: sqlite3_set_authorizer(db_obj->db, php_sqlite3_authorizer, NULL);
172: }
173:
174: if (fullpath) {
175: efree(fullpath);
176: }
177: }
178: /* }}} */
179:
180: /* {{{ proto bool SQLite3::close()
181: Close a SQLite 3 Database. */
182: PHP_METHOD(sqlite3, close)
183: {
184: php_sqlite3_db_object *db_obj;
185: zval *object = getThis();
186: int errcode;
187: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
188:
189: if (zend_parse_parameters_none() == FAILURE) {
190: return;
191: }
192:
193: if (db_obj->initialised) {
194: zend_llist_clean(&(db_obj->free_list));
195: errcode = sqlite3_close(db_obj->db);
196: if (errcode != SQLITE_OK) {
197: php_sqlite3_error(db_obj, "Unable to close database: %d, %s", errcode, sqlite3_errmsg(db_obj->db));
198: RETURN_FALSE;
199: }
200: db_obj->initialised = 0;
201: }
202:
203: RETURN_TRUE;
204: }
205: /* }}} */
206:
207: /* {{{ proto bool SQLite3::exec(String Query)
208: Executes a result-less query against a given database. */
209: PHP_METHOD(sqlite3, exec)
210: {
211: php_sqlite3_db_object *db_obj;
212: zval *object = getThis();
213: char *sql, *errtext = NULL;
214: int sql_len;
215: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
216:
217: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
218:
219: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
220: return;
221: }
222:
223: if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
224: php_sqlite3_error(db_obj, "%s", errtext);
225: sqlite3_free(errtext);
226: RETURN_FALSE;
227: }
228:
229: RETURN_TRUE;
230: }
231: /* }}} */
232:
233: /* {{{ proto Array SQLite3::version()
234: Returns the SQLite3 Library version as a string constant and as a number. */
235: PHP_METHOD(sqlite3, version)
236: {
237: if (zend_parse_parameters_none() == FAILURE) {
238: return;
239: }
240:
241: array_init(return_value);
242:
243: add_assoc_string(return_value, "versionString", (char*)sqlite3_libversion(), 1);
244: add_assoc_long(return_value, "versionNumber", sqlite3_libversion_number());
245:
246: return;
247: }
248: /* }}} */
249:
250: /* {{{ proto int SQLite3::lastInsertRowID()
251: Returns the rowid of the most recent INSERT into the database from the database connection. */
252: PHP_METHOD(sqlite3, lastInsertRowID)
253: {
254: php_sqlite3_db_object *db_obj;
255: zval *object = getThis();
256: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
257:
258: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
259:
260: if (zend_parse_parameters_none() == FAILURE) {
261: return;
262: }
263:
264: RETURN_LONG(sqlite3_last_insert_rowid(db_obj->db));
265: }
266: /* }}} */
267:
268: /* {{{ proto int SQLite3::lastErrorCode()
269: Returns the numeric result code of the most recent failed sqlite API call for the database connection. */
270: PHP_METHOD(sqlite3, lastErrorCode)
271: {
272: php_sqlite3_db_object *db_obj;
273: zval *object = getThis();
274: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
275:
276: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
277:
278: if (zend_parse_parameters_none() == FAILURE) {
279: return;
280: }
281:
282: RETURN_LONG(sqlite3_errcode(db_obj->db));
283: }
284: /* }}} */
285:
286: /* {{{ proto string SQLite3::lastErrorMsg()
287: Returns english text describing the most recent failed sqlite API call for the database connection. */
288: PHP_METHOD(sqlite3, lastErrorMsg)
289: {
290: php_sqlite3_db_object *db_obj;
291: zval *object = getThis();
292: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
293:
294: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
295:
296: if (zend_parse_parameters_none() == FAILURE) {
297: return;
298: }
299:
300: RETVAL_STRING((char *)sqlite3_errmsg(db_obj->db), 1);
301: }
302: /* }}} */
303:
304: /* {{{ proto bool SQLite3::busyTimeout(int msecs)
305: Sets a busy handler that will sleep until database is not locked or timeout is reached. Passing a value less than or equal to zero turns off all busy handlers. */
306: PHP_METHOD(sqlite3, busyTimeout)
307: {
308: php_sqlite3_db_object *db_obj;
309: zval *object = getThis();
310: long ms;
311: int return_code;
312: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
313:
314: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
315:
316: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ms)) {
317: return;
318: }
319:
320: return_code = sqlite3_busy_timeout(db_obj->db, ms);
321: if (return_code != SQLITE_OK) {
322: php_sqlite3_error(db_obj, "Unable to set busy timeout: %d, %s", return_code, sqlite3_errmsg(db_obj->db));
323: RETURN_FALSE;
324: }
325:
326: RETURN_TRUE;
327: }
328: /* }}} */
329:
330:
331: #ifndef SQLITE_OMIT_LOAD_EXTENSION
332: /* {{{ proto bool SQLite3::loadExtension(String Shared Library)
333: Attempts to load an SQLite extension library. */
334: PHP_METHOD(sqlite3, loadExtension)
335: {
336: php_sqlite3_db_object *db_obj;
337: zval *object = getThis();
338: char *extension, *lib_path, *extension_dir, *errtext = NULL;
339: char fullpath[MAXPATHLEN];
340: int extension_len, extension_dir_len;
341: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
342:
343: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
344:
345: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension, &extension_len)) {
346: return;
347: }
348:
349: #ifdef ZTS
350: if ((strncmp(sapi_module.name, "cgi", 3) != 0) &&
351: (strcmp(sapi_module.name, "cli") != 0) &&
352: (strncmp(sapi_module.name, "embed", 5) != 0)
353: ) { php_sqlite3_error(db_obj, "Not supported in multithreaded Web servers");
354: RETURN_FALSE;
355: }
356: #endif
357:
358: if (!SQLITE3G(extension_dir)) {
359: php_sqlite3_error(db_obj, "SQLite Extension are disabled");
360: RETURN_FALSE;
361: }
362:
363: if (extension_len == 0) {
364: php_sqlite3_error(db_obj, "Empty string as an extension");
365: RETURN_FALSE;
366: }
367:
368: extension_dir = SQLITE3G(extension_dir);
369: extension_dir_len = strlen(SQLITE3G(extension_dir));
370:
371: if (IS_SLASH(extension_dir[extension_dir_len-1])) {
372: spprintf(&lib_path, 0, "%s%s", extension_dir, extension);
373: } else {
374: spprintf(&lib_path, 0, "%s%c%s", extension_dir, DEFAULT_SLASH, extension);
375: }
376:
377: if (!VCWD_REALPATH(lib_path, fullpath)) {
378: php_sqlite3_error(db_obj, "Unable to load extension at '%s'", lib_path);
379: efree(lib_path);
380: RETURN_FALSE;
381: }
382:
383: efree(lib_path);
384:
385: if (strncmp(fullpath, extension_dir, extension_dir_len) != 0) {
386: php_sqlite3_error(db_obj, "Unable to open extensions outside the defined directory");
387: RETURN_FALSE;
388: }
389:
390: /* Extension loading should only be enabled for when we attempt to load */
391: sqlite3_enable_load_extension(db_obj->db, 1);
392: if (sqlite3_load_extension(db_obj->db, fullpath, 0, &errtext) != SQLITE_OK) {
393: php_sqlite3_error(db_obj, "%s", errtext);
394: sqlite3_free(errtext);
395: sqlite3_enable_load_extension(db_obj->db, 0);
396: RETURN_FALSE;
397: }
398: sqlite3_enable_load_extension(db_obj->db, 0);
399:
400: RETURN_TRUE;
401: }
402: /* }}} */
403: #endif
404:
405: /* {{{ proto int SQLite3::changes()
406: Returns the number of database rows that were changed (or inserted or deleted) by the most recent SQL statement. */
407: PHP_METHOD(sqlite3, changes)
408: {
409: php_sqlite3_db_object *db_obj;
410: zval *object = getThis();
411: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
412:
413: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
414:
415: if (zend_parse_parameters_none() == FAILURE) {
416: return;
417: }
418:
419: RETURN_LONG(sqlite3_changes(db_obj->db));
420: }
421: /* }}} */
422:
423: /* {{{ proto String SQLite3::escapeString(String value)
424: Returns a string that has been properly escaped. */
425: PHP_METHOD(sqlite3, escapeString)
426: {
427: char *sql, *ret;
428: int sql_len;
429:
430: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
431: return;
432: }
433:
434: if (sql_len) {
435: ret = sqlite3_mprintf("%q", sql);
436: if (ret) {
437: RETVAL_STRING(ret, 1);
438: sqlite3_free(ret);
439: }
440: } else {
441: RETURN_EMPTY_STRING();
442: }
443: }
444: /* }}} */
445:
446: /* {{{ proto SQLite3Stmt SQLite3::prepare(String Query)
447: Returns a prepared SQL statement for execution. */
448: PHP_METHOD(sqlite3, prepare)
449: {
450: php_sqlite3_db_object *db_obj;
451: php_sqlite3_stmt *stmt_obj;
452: zval *object = getThis();
453: char *sql;
454: int sql_len, errcode;
455: php_sqlite3_free_list *free_item;
456:
457: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
458:
459: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
460:
461: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
462: return;
463: }
464:
465: if (!sql_len) {
466: RETURN_FALSE;
467: }
468:
469: object_init_ex(return_value, php_sqlite3_stmt_entry);
470: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(return_value TSRMLS_CC);
471: stmt_obj->db_obj = db_obj;
472: stmt_obj->db_obj_zval = getThis();
473:
474: Z_ADDREF_P(object);
475:
476: errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
477: if (errcode != SQLITE_OK) {
478: php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", errcode, sqlite3_errmsg(db_obj->db));
479: zval_dtor(return_value);
480: RETURN_FALSE;
481: }
482:
483: stmt_obj->initialised = 1;
484:
485: free_item = emalloc(sizeof(php_sqlite3_free_list));
486: free_item->stmt_obj = stmt_obj;
487: free_item->stmt_obj_zval = return_value;
488:
489: zend_llist_add_element(&(db_obj->free_list), &free_item);
490: }
491: /* }}} */
492:
493: /* {{{ proto SQLite3Result SQLite3::query(String Query)
494: Returns true or false, for queries that return data it will return a SQLite3Result object. */
495: PHP_METHOD(sqlite3, query)
496: {
497: php_sqlite3_db_object *db_obj;
498: php_sqlite3_result *result;
499: php_sqlite3_stmt *stmt_obj;
500: zval *object = getThis();
501: zval *stmt = NULL;
502: char *sql, *errtext = NULL;
503: int sql_len, return_code;
504: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
505:
506: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
507:
508: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &sql, &sql_len)) {
509: return;
510: }
511:
512: if (!sql_len) {
513: RETURN_FALSE;
514: }
515:
516: /* If there was no return value then just execute the query */
517: if (!return_value_used) {
518: if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
519: php_sqlite3_error(db_obj, "%s", errtext);
520: sqlite3_free(errtext);
521: }
522: return;
523: }
524:
525: MAKE_STD_ZVAL(stmt);
526:
527: object_init_ex(stmt, php_sqlite3_stmt_entry);
528: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(stmt TSRMLS_CC);
529: stmt_obj->db_obj = db_obj;
530: stmt_obj->db_obj_zval = getThis();
531:
532: Z_ADDREF_P(object);
533:
534: return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
535: if (return_code != SQLITE_OK) {
536: php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", return_code, sqlite3_errmsg(db_obj->db));
537: zval_ptr_dtor(&stmt);
538: RETURN_FALSE;
539: }
540:
541: stmt_obj->initialised = 1;
542:
543: object_init_ex(return_value, php_sqlite3_result_entry);
544: result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
545: result->db_obj = db_obj;
546: result->stmt_obj = stmt_obj;
547: result->stmt_obj_zval = stmt;
548:
549: return_code = sqlite3_step(result->stmt_obj->stmt);
550:
551: switch (return_code) {
552: case SQLITE_ROW: /* Valid Row */
553: case SQLITE_DONE: /* Valid but no results */
554: {
555: php_sqlite3_free_list *free_item;
556: free_item = emalloc(sizeof(php_sqlite3_free_list));
557: free_item->stmt_obj = stmt_obj;
558: free_item->stmt_obj_zval = stmt;
559: zend_llist_add_element(&(db_obj->free_list), &free_item);
560: sqlite3_reset(result->stmt_obj->stmt);
561: break;
562: }
563: default:
564: php_sqlite3_error(db_obj, "Unable to execute statement: %s", sqlite3_errmsg(db_obj->db));
565: sqlite3_finalize(stmt_obj->stmt);
566: stmt_obj->initialised = 0;
567: zval_dtor(return_value);
568: RETURN_FALSE;
569: }
570: }
571: /* }}} */
572:
573: static zval* sqlite_value_to_zval(sqlite3_stmt *stmt, int column) /* {{{ */
574: {
575: zval *data;
576: MAKE_STD_ZVAL(data);
577: switch (sqlite3_column_type(stmt, column)) {
578: case SQLITE_INTEGER:
579: if ((sqlite3_column_int64(stmt, column)) >= INT_MAX || sqlite3_column_int64(stmt, column) <= INT_MIN) {
580: ZVAL_STRINGL(data, (char *)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column), 1);
581: } else {
582: ZVAL_LONG(data, sqlite3_column_int64(stmt, column));
583: }
584: break;
585:
586: case SQLITE_FLOAT:
587: ZVAL_DOUBLE(data, sqlite3_column_double(stmt, column));
588: break;
589:
590: case SQLITE_NULL:
591: ZVAL_NULL(data);
592: break;
593:
594: case SQLITE3_TEXT:
595: ZVAL_STRING(data, (char*)sqlite3_column_text(stmt, column), 1);
596: break;
597:
598: case SQLITE_BLOB:
599: default:
600: ZVAL_STRINGL(data, (char*)sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column), 1);
601: }
602: return data;
603: }
604: /* }}} */
605:
606: /* {{{ proto SQLite3Result SQLite3::querySingle(String Query [, bool entire_row = false])
607: Returns a string of the first column, or an array of the entire row. */
608: PHP_METHOD(sqlite3, querySingle)
609: {
610: php_sqlite3_db_object *db_obj;
611: zval *object = getThis();
612: char *sql, *errtext = NULL;
613: int sql_len, return_code;
614: zend_bool entire_row = 0;
615: sqlite3_stmt *stmt;
616: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
617:
618: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
619:
620: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &sql, &sql_len, &entire_row)) {
621: return;
622: }
623:
624: if (!sql_len) {
625: RETURN_FALSE;
626: }
627:
628: /* If there was no return value then just execute the query */
629: if (!return_value_used) {
630: if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
631: php_sqlite3_error(db_obj, "%s", errtext);
632: sqlite3_free(errtext);
633: }
634: return;
635: }
636:
637: return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &stmt, NULL);
638: if (return_code != SQLITE_OK) {
639: php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", return_code, sqlite3_errmsg(db_obj->db));
640: RETURN_FALSE;
641: }
642:
643: return_code = sqlite3_step(stmt);
644:
645: switch (return_code) {
646: case SQLITE_ROW: /* Valid Row */
647: {
648: if (!entire_row) {
649: zval *data;
650: data = sqlite_value_to_zval(stmt, 0);
651: *return_value = *data;
652: zval_copy_ctor(return_value);
653: zval_dtor(data);
654: FREE_ZVAL(data);
655: } else {
656: int i = 0;
657: array_init(return_value);
658: for (i = 0; i < sqlite3_data_count(stmt); i++) {
659: zval *data;
660: data = sqlite_value_to_zval(stmt, i);
661: add_assoc_zval(return_value, (char*)sqlite3_column_name(stmt, i), data);
662: }
663: }
664: break;
665: }
666: case SQLITE_DONE: /* Valid but no results */
667: {
668: if (!entire_row) {
669: RETVAL_NULL();
670: } else {
671: array_init(return_value);
672: }
673: break;
674: }
675: default:
676: php_sqlite3_error(db_obj, "Unable to execute statement: %s", sqlite3_errmsg(db_obj->db));
677: RETVAL_FALSE;
678: }
679: sqlite3_finalize(stmt);
680: }
681: /* }}} */
682:
683: static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, sqlite3_value **argv, sqlite3_context *context, int is_agg TSRMLS_DC) /* {{{ */
684: {
685: zval ***zargs = NULL;
686: zval *retval = NULL;
687: int i;
688: int ret;
689: int fake_argc;
690: php_sqlite3_agg_context *agg_context = NULL;
691:
692: if (is_agg) {
693: is_agg = 2;
694: }
695:
696: fake_argc = argc + is_agg;
697:
698: fc->fci.size = sizeof(fc->fci);
699: fc->fci.function_table = EG(function_table);
700: fc->fci.function_name = cb;
701: fc->fci.symbol_table = NULL;
702: fc->fci.object_ptr = NULL;
703: fc->fci.retval_ptr_ptr = &retval;
704: fc->fci.param_count = fake_argc;
705:
706: /* build up the params */
707:
708: if (fake_argc) {
709: zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0);
710: }
711:
712: if (is_agg) {
713: /* summon the aggregation context */
714: agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
715:
716: if (!agg_context->zval_context) {
717: MAKE_STD_ZVAL(agg_context->zval_context);
718: ZVAL_NULL(agg_context->zval_context);
719: }
720: zargs[0] = &agg_context->zval_context;
721:
722: zargs[1] = emalloc(sizeof(zval*));
723: MAKE_STD_ZVAL(*zargs[1]);
724: ZVAL_LONG(*zargs[1], agg_context->row_count);
725: }
726:
727: for (i = 0; i < argc; i++) {
728: zargs[i + is_agg] = emalloc(sizeof(zval *));
729: MAKE_STD_ZVAL(*zargs[i + is_agg]);
730:
731: switch (sqlite3_value_type(argv[i])) {
732: case SQLITE_INTEGER:
733: #if LONG_MAX > 2147483647
734: ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int64(argv[i]));
735: #else
736: ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
737: #endif
738: break;
739:
740: case SQLITE_FLOAT:
741: ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i]));
742: break;
743:
744: case SQLITE_NULL:
745: ZVAL_NULL(*zargs[i + is_agg]);
746: break;
747:
748: case SQLITE_BLOB:
749: case SQLITE3_TEXT:
750: default:
751: ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]), 1);
752: break;
753: }
754: }
755:
756: fc->fci.params = zargs;
757:
758: if ((ret = zend_call_function(&fc->fci, &fc->fcc TSRMLS_CC)) == FAILURE) {
759: php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
760: }
761:
762: /* clean up the params */
763: if (fake_argc) {
764: for (i = is_agg; i < argc + is_agg; i++) {
765: zval_ptr_dtor(zargs[i]);
766: efree(zargs[i]);
767: }
768: if (is_agg) {
769: zval_ptr_dtor(zargs[1]);
770: efree(zargs[1]);
771: }
772: efree(zargs);
773: }
774:
775: if (!is_agg || !argv) {
776: /* only set the sqlite return value if we are a scalar function,
777: * or if we are finalizing an aggregate */
778: if (retval) {
779: switch (Z_TYPE_P(retval)) {
780: case IS_LONG:
781: #if LONG_MAX > 2147483647
782: sqlite3_result_int64(context, Z_LVAL_P(retval));
783: #else
784: sqlite3_result_int(context, Z_LVAL_P(retval));
785: #endif
786: break;
787:
788: case IS_NULL:
789: sqlite3_result_null(context);
790: break;
791:
792: case IS_DOUBLE:
793: sqlite3_result_double(context, Z_DVAL_P(retval));
794: break;
795:
796: default:
797: convert_to_string_ex(&retval);
798: sqlite3_result_text(context, Z_STRVAL_P(retval), Z_STRLEN_P(retval), SQLITE_TRANSIENT);
799: break;
800: }
801: } else {
802: sqlite3_result_error(context, "failed to invoke callback", 0);
803: }
804:
805: if (agg_context && agg_context->zval_context) {
806: zval_ptr_dtor(&agg_context->zval_context);
807: }
808: } else {
809: /* we're stepping in an aggregate; the return value goes into
810: * the context */
811: if (agg_context && agg_context->zval_context) {
812: zval_ptr_dtor(&agg_context->zval_context);
813: }
814: if (retval) {
815: agg_context->zval_context = retval;
816: retval = NULL;
817: } else {
818: agg_context->zval_context = NULL;
819: }
820: }
821:
822: if (retval) {
823: zval_ptr_dtor(&retval);
824: }
825: return ret;
826: }
827: /* }}}*/
828:
829: static void php_sqlite3_callback_func(sqlite3_context *context, int argc, sqlite3_value **argv) /* {{{ */
830: {
831: php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
832: TSRMLS_FETCH();
833:
834: sqlite3_do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
835: }
836: /* }}}*/
837:
838: static void php_sqlite3_callback_step(sqlite3_context *context, int argc, sqlite3_value **argv) /* {{{ */
839: {
840: php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
841: php_sqlite3_agg_context *agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
842:
843: TSRMLS_FETCH();
844: agg_context->row_count++;
845:
846: sqlite3_do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
847: }
848: /* }}} */
849:
850: static void php_sqlite3_callback_final(sqlite3_context *context) /* {{{ */
851: {
852: php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
853: php_sqlite3_agg_context *agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
854:
855: TSRMLS_FETCH();
856: agg_context->row_count = 0;
857:
858: sqlite3_do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
859: }
860: /* }}} */
861:
862: static int php_sqlite3_callback_compare(void *coll, int a_len, const void *a, int b_len, const void* b) /* {{{ */
863: {
864: php_sqlite3_collation *collation = (php_sqlite3_collation*)coll;
865: zval ***zargs = NULL;
866: zval *retval = NULL;
867: int ret;
868:
869: TSRMLS_FETCH();
870:
871: collation->fci.fci.size = (sizeof(collation->fci.fci));
872: collation->fci.fci.function_table = EG(function_table);
873: collation->fci.fci.function_name = collation->cmp_func;
874: collation->fci.fci.symbol_table = NULL;
875: collation->fci.fci.object_ptr = NULL;
876: collation->fci.fci.retval_ptr_ptr = &retval;
877: collation->fci.fci.param_count = 2;
878:
879: zargs = (zval***)safe_emalloc(2, sizeof(zval**), 0);
880: zargs[0] = emalloc(sizeof(zval*));
881: zargs[1] = emalloc(sizeof(zval*));
882:
883: MAKE_STD_ZVAL(*zargs[0]);
884: ZVAL_STRINGL(*zargs[0], a, a_len, 1);
885:
886: MAKE_STD_ZVAL(*zargs[1]);
887: ZVAL_STRINGL(*zargs[1], b, b_len, 1);
888:
889: collation->fci.fci.params = zargs;
890:
891: if ((ret = zend_call_function(&collation->fci.fci, &collation->fci.fcc TSRMLS_CC)) == FAILURE) {
892: php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback");
893: }
894:
895: zval_ptr_dtor(zargs[0]);
896: zval_ptr_dtor(zargs[1]);
897: efree(zargs[0]);
898: efree(zargs[1]);
899: efree(zargs);
900:
901: //retval ought to contain a ZVAL_LONG by now
902: // (the result of a comparison, i.e. most likely -1, 0, or 1)
903: //I suppose we could accept any scalar return type, though.
904: if (Z_TYPE_P(retval) != IS_LONG){
905: php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback (invalid return type). Collation behaviour is undefined.");
906: }else{
907: ret = Z_LVAL_P(retval);
908: }
909:
910: zval_ptr_dtor(&retval);
911:
912: return ret;
913: }
914: /* }}} */
915:
916: /* {{{ proto bool SQLite3::createFunction(string name, mixed callback [, int argcount])
917: Allows registration of a PHP function as a SQLite UDF that can be called within SQL statements. */
918: PHP_METHOD(sqlite3, createFunction)
919: {
920: php_sqlite3_db_object *db_obj;
921: zval *object = getThis();
922: php_sqlite3_func *func;
923: char *sql_func, *callback_name;
924: int sql_func_len;
925: zval *callback_func;
926: long sql_func_num_args = -1;
927: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
928:
929: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
930:
931: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &sql_func, &sql_func_len, &callback_func, &sql_func_num_args) == FAILURE) {
932: return;
933: }
934:
935: if (!sql_func_len) {
936: RETURN_FALSE;
937: }
938:
939: if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
940: php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
941: efree(callback_name);
942: RETURN_FALSE;
943: }
944: efree(callback_name);
945:
946: func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
947:
948: if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, php_sqlite3_callback_func, NULL, NULL) == SQLITE_OK) {
949: func->func_name = estrdup(sql_func);
950:
951: MAKE_STD_ZVAL(func->func);
952: MAKE_COPY_ZVAL(&callback_func, func->func);
953:
954: func->argc = sql_func_num_args;
955: func->next = db_obj->funcs;
956: db_obj->funcs = func;
957:
958: RETURN_TRUE;
959: }
960: efree(func);
961:
962: RETURN_FALSE;
963: }
964: /* }}} */
965:
966: /* {{{ proto bool SQLite3::createAggregate(string name, mixed step, mixed final [, int argcount])
967: Allows registration of a PHP function for use as an aggregate. */
968: PHP_METHOD(sqlite3, createAggregate)
969: {
970: php_sqlite3_db_object *db_obj;
971: zval *object = getThis();
972: php_sqlite3_func *func;
973: char *sql_func, *callback_name;
974: int sql_func_len;
975: zval *step_callback, *fini_callback;
976: long sql_func_num_args = -1;
977: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
978:
979: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
980:
981: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", &sql_func, &sql_func_len, &step_callback, &fini_callback, &sql_func_num_args) == FAILURE) {
982: return;
983: }
984:
985: if (!sql_func_len) {
986: RETURN_FALSE;
987: }
988:
989: if (!zend_is_callable(step_callback, 0, &callback_name TSRMLS_CC)) {
990: php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
991: efree(callback_name);
992: RETURN_FALSE;
993: }
994: efree(callback_name);
995:
996: if (!zend_is_callable(fini_callback, 0, &callback_name TSRMLS_CC)) {
997: php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
998: efree(callback_name);
999: RETURN_FALSE;
1000: }
1001: efree(callback_name);
1002:
1003: func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
1004:
1005: if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, NULL, php_sqlite3_callback_step, php_sqlite3_callback_final) == SQLITE_OK) {
1006: func->func_name = estrdup(sql_func);
1007:
1008: MAKE_STD_ZVAL(func->step);
1009: MAKE_COPY_ZVAL(&step_callback, func->step);
1010:
1011: MAKE_STD_ZVAL(func->fini);
1012: MAKE_COPY_ZVAL(&fini_callback, func->fini);
1013:
1014: func->argc = sql_func_num_args;
1015: func->next = db_obj->funcs;
1016: db_obj->funcs = func;
1017:
1018: RETURN_TRUE;
1019: }
1020: efree(func);
1021:
1022: RETURN_FALSE;
1023: }
1024: /* }}} */
1025:
1026: /* {{{ proto bool SQLite3::createCollation(string name, mixed callback)
1027: Registers a PHP function as a comparator that can be used with the SQL COLLATE operator. Callback must accept two strings and return an integer (as strcmp()). */
1028: PHP_METHOD(sqlite3, createCollation)
1029: {
1030: php_sqlite3_db_object *db_obj;
1031: zval *object = getThis();
1032: php_sqlite3_collation *collation;
1033: char *collation_name, *callback_name;
1034: int collation_name_len;
1035: zval *callback_func;
1036: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
1037:
1038: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
1039:
1040: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &collation_name, &collation_name_len, &callback_func) == FAILURE) {
1041: RETURN_FALSE;
1042: }
1043:
1044: if (!collation_name_len) {
1045: RETURN_FALSE;
1046: }
1047:
1048: if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
1049: php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
1050: efree(callback_name);
1051: RETURN_FALSE;
1052: }
1053: efree(callback_name);
1054:
1055: collation = (php_sqlite3_collation *)ecalloc(1, sizeof(*collation));
1056: if (sqlite3_create_collation(db_obj->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_callback_compare) == SQLITE_OK) {
1057: collation->collation_name = estrdup(collation_name);
1058:
1059: MAKE_STD_ZVAL(collation->cmp_func);
1060: MAKE_COPY_ZVAL(&callback_func, collation->cmp_func);
1061:
1062: collation->next = db_obj->collations;
1063: db_obj->collations = collation;
1064:
1065: RETURN_TRUE;
1066: }
1067: efree(collation);
1068:
1069: RETURN_FALSE;
1070: }
1071: /* }}} */
1072:
1073: typedef struct {
1074: sqlite3_blob *blob;
1075: size_t position;
1076: size_t size;
1077: } php_stream_sqlite3_data;
1078:
1079: static size_t php_sqlite3_stream_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
1080: {
1081: /* php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract; */
1082:
1083: return 0;
1084: }
1085:
1086: static size_t php_sqlite3_stream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
1087: {
1088: php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
1089:
1090: if (sqlite3_stream->position + count >= sqlite3_stream->size) {
1091: count = sqlite3_stream->size - sqlite3_stream->position;
1092: stream->eof = 1;
1093: }
1094: if (count) {
1095: if (sqlite3_blob_read(sqlite3_stream->blob, buf, count, sqlite3_stream->position) != SQLITE_OK) {
1096: return 0;
1097: }
1098: sqlite3_stream->position += count;
1099: }
1100: return count;
1101: }
1102:
1103: static int php_sqlite3_stream_close(php_stream *stream, int close_handle TSRMLS_DC)
1104: {
1105: php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
1106:
1107: if (sqlite3_blob_close(sqlite3_stream->blob) != SQLITE_OK) {
1108: /* Error occurred, but it still closed */
1109: }
1110:
1111: efree(sqlite3_stream);
1112:
1113: return 0;
1114: }
1115:
1116: static int php_sqlite3_stream_flush(php_stream *stream TSRMLS_DC)
1117: {
1118: /* do nothing */
1119: return 0;
1120: }
1121:
1122: /* {{{ */
1123: static int php_sqlite3_stream_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
1124: {
1125: php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
1126:
1127: switch(whence) {
1128: case SEEK_CUR:
1129: if (offset < 0) {
1130: if (sqlite3_stream->position < (size_t)(-offset)) {
1131: sqlite3_stream->position = 0;
1132: *newoffs = -1;
1133: return -1;
1134: } else {
1135: sqlite3_stream->position = sqlite3_stream->position + offset;
1136: *newoffs = sqlite3_stream->position;
1137: stream->eof = 0;
1138: return 0;
1139: }
1140: } else {
1141: if (sqlite3_stream->position + (size_t)(offset) > sqlite3_stream->size) {
1142: sqlite3_stream->position = sqlite3_stream->size;
1143: *newoffs = -1;
1144: return -1;
1145: } else {
1146: sqlite3_stream->position = sqlite3_stream->position + offset;
1147: *newoffs = sqlite3_stream->position;
1148: stream->eof = 0;
1149: return 0;
1150: }
1151: }
1152: case SEEK_SET:
1153: if (sqlite3_stream->size < (size_t)(offset)) {
1154: sqlite3_stream->position = sqlite3_stream->size;
1155: *newoffs = -1;
1156: return -1;
1157: } else {
1158: sqlite3_stream->position = offset;
1159: *newoffs = sqlite3_stream->position;
1160: stream->eof = 0;
1161: return 0;
1162: }
1163: case SEEK_END:
1164: if (offset > 0) {
1165: sqlite3_stream->position = sqlite3_stream->size;
1166: *newoffs = -1;
1167: return -1;
1168: } else if (sqlite3_stream->size < (size_t)(-offset)) {
1169: sqlite3_stream->position = 0;
1170: *newoffs = -1;
1171: return -1;
1172: } else {
1173: sqlite3_stream->position = sqlite3_stream->size + offset;
1174: *newoffs = sqlite3_stream->position;
1175: stream->eof = 0;
1176: return 0;
1177: }
1178: default:
1179: *newoffs = sqlite3_stream->position;
1180: return -1;
1181: }
1182: }
1183: /* }}} */
1184:
1185:
1186: static int php_sqlite3_stream_cast(php_stream *stream, int castas, void **ret TSRMLS_DC)
1187: {
1188: return FAILURE;
1189: }
1190:
1191: static int php_sqlite3_stream_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
1192: {
1193: php_stream_sqlite3_data *sqlite3_stream = (php_stream_sqlite3_data *) stream->abstract;
1194: ssb->sb.st_size = sqlite3_stream->size;
1195: return 0;
1196: }
1197:
1198: static php_stream_ops php_stream_sqlite3_ops = {
1199: php_sqlite3_stream_write,
1200: php_sqlite3_stream_read,
1201: php_sqlite3_stream_close,
1202: php_sqlite3_stream_flush,
1203: "SQLite3",
1204: php_sqlite3_stream_seek,
1205: php_sqlite3_stream_cast,
1206: php_sqlite3_stream_stat
1207: };
1208:
1209: /* {{{ proto resource SQLite3::openBlob(string table, string column, int rowid [, string dbname])
1210: Open a blob as a stream which we can read / write to. */
1211: PHP_METHOD(sqlite3, openBlob)
1212: {
1213: php_sqlite3_db_object *db_obj;
1214: zval *object = getThis();
1215: char *table, *column, *dbname = "main";
1216: int table_len, column_len, dbname_len;
1217: long rowid, flags = 0;
1218: sqlite3_blob *blob = NULL;
1219: php_stream_sqlite3_data *sqlite3_stream;
1220: php_stream *stream;
1221:
1222: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
1223:
1224: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
1225:
1226: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ssl|s", &table, &table_len, &column, &column_len, &rowid, &dbname, &dbname_len) == FAILURE) {
1227: return;
1228: }
1229:
1230: if (sqlite3_blob_open(db_obj->db, dbname, table, column, rowid, flags, &blob) != SQLITE_OK) {
1231: php_sqlite3_error(db_obj, "Unable to open blob: %s", sqlite3_errmsg(db_obj->db));
1232: RETURN_FALSE;
1233: }
1234:
1235: sqlite3_stream = emalloc(sizeof(php_stream_sqlite3_data));
1236: sqlite3_stream->blob = blob;
1237: sqlite3_stream->position = 0;
1238: sqlite3_stream->size = sqlite3_blob_bytes(blob);
1239:
1240: stream = php_stream_alloc(&php_stream_sqlite3_ops, sqlite3_stream, 0, "rb");
1241:
1242: if (stream) {
1243: php_stream_to_zval(stream, return_value);
1244: } else {
1245: RETURN_FALSE;
1246: }
1247: }
1248: /* }}} */
1249:
1250: /* {{{ proto bool SQLite3::enableExceptions([bool enableExceptions = false])
1251: Enables an exception error mode. */
1252: PHP_METHOD(sqlite3, enableExceptions)
1253: {
1254: php_sqlite3_db_object *db_obj;
1255: zval *object = getThis();
1256: zend_bool enableExceptions = 0;
1257:
1258: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
1259:
1260: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enableExceptions) == FAILURE) {
1261: return;
1262: }
1263:
1264: RETVAL_BOOL(db_obj->exception);
1265:
1266: db_obj->exception = enableExceptions;
1267: }
1268: /* }}} */
1269:
1270: /* {{{ proto int SQLite3Stmt::paramCount()
1271: Returns the number of parameters within the prepared statement. */
1272: PHP_METHOD(sqlite3stmt, paramCount)
1273: {
1274: php_sqlite3_stmt *stmt_obj;
1275: zval *object = getThis();
1276: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1277:
1278: if (zend_parse_parameters_none() == FAILURE) {
1279: return;
1280: }
1281:
1282: RETURN_LONG(sqlite3_bind_parameter_count(stmt_obj->stmt));
1283: }
1284: /* }}} */
1285:
1286: /* {{{ proto bool SQLite3Stmt::close()
1287: Closes the prepared statement. */
1288: PHP_METHOD(sqlite3stmt, close)
1289: {
1290: php_sqlite3_stmt *stmt_obj;
1291: zval *object = getThis();
1292: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1293:
1294: if (zend_parse_parameters_none() == FAILURE) {
1295: return;
1296: }
1297:
1298: zend_llist_del_element(&(stmt_obj->db_obj->free_list), object, (int (*)(void *, void *)) php_sqlite3_compare_stmt_zval_free);
1299:
1300: RETURN_TRUE;
1301: }
1302: /* }}} */
1303:
1304: /* {{{ proto bool SQLite3Stmt::reset()
1305: Reset the prepared statement to the state before it was executed, bindings still remain. */
1306: PHP_METHOD(sqlite3stmt, reset)
1307: {
1308: php_sqlite3_stmt *stmt_obj;
1309: zval *object = getThis();
1310: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1311:
1312: if (zend_parse_parameters_none() == FAILURE) {
1313: return;
1314: }
1315:
1316: if (sqlite3_reset(stmt_obj->stmt) != SQLITE_OK) {
1317: php_sqlite3_error(stmt_obj->db_obj, "Unable to reset statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt)));
1318: RETURN_FALSE;
1319: }
1320: RETURN_TRUE;
1321: }
1322: /* }}} */
1323:
1324: /* {{{ proto bool SQLite3Stmt::clear()
1325: Clear all current bound parameters. */
1326: PHP_METHOD(sqlite3stmt, clear)
1327: {
1328: php_sqlite3_stmt *stmt_obj;
1329: zval *object = getThis();
1330: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1331:
1332: if (zend_parse_parameters_none() == FAILURE) {
1333: return;
1334: }
1335:
1336: if (sqlite3_clear_bindings(stmt_obj->stmt) != SQLITE_OK) {
1337: php_sqlite3_error(stmt_obj->db_obj, "Unable to clear statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt)));
1338: RETURN_FALSE;
1339: }
1340:
1341: RETURN_TRUE;
1342: }
1343: /* }}} */
1344:
1345: /* {{{ proto bool SQLite3Stmt::readOnly()
1346: Returns true if a statement is definitely read only */
1347: PHP_METHOD(sqlite3stmt, readOnly)
1348: {
1349: php_sqlite3_stmt *stmt_obj;
1350: zval *object = getThis();
1351: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1352:
1353: if (zend_parse_parameters_none() == FAILURE) {
1354: return;
1355: }
1356:
1357: #if SQLITE_VERSION_NUMBER >= 3007004
1358: if (sqlite3_stmt_readonly(stmt_obj->stmt)) {
1359: RETURN_TRUE;
1360: }
1361: #endif
1362: RETURN_FALSE;
1363: }
1364: /* }}} */
1365:
1366: static int register_bound_parameter_to_sqlite(struct php_sqlite3_bound_param *param, php_sqlite3_stmt *stmt TSRMLS_DC) /* {{{ */
1367: {
1368: HashTable *hash;
1369: hash = stmt->bound_params;
1370:
1371: if (!hash) {
1372: ALLOC_HASHTABLE(hash);
1373: zend_hash_init(hash, 13, NULL, sqlite3_param_dtor, 0);
1374: stmt->bound_params = hash;
1375: }
1376:
1377: /* We need a : prefix to resolve a name to a parameter number */
1378: if (param->name) {
1379: if (param->name[0] != ':') {
1380: /* pre-increment for character + 1 for null */
1381: char *temp = emalloc(++param->name_len + 1);
1382: temp[0] = ':';
1383: memmove(temp+1, param->name, param->name_len);
1384: param->name = temp;
1385: } else {
1386: param->name = estrndup(param->name, param->name_len);
1387: }
1388: /* do lookup*/
1389: param->param_number = sqlite3_bind_parameter_index(stmt->stmt, param->name);
1390: }
1391:
1392: if (param->param_number < 1) {
1393: efree(param->name);
1394: return 0;
1395: }
1396:
1397: if (param->param_number >= 1) {
1398: zend_hash_index_del(hash, param->param_number);
1399: }
1400:
1401: if (param->name) {
1402: zend_hash_update(hash, param->name, param->name_len, param, sizeof(*param), NULL);
1403: } else {
1404: zend_hash_index_update(hash, param->param_number, param, sizeof(*param), NULL);
1405: }
1406:
1407: return 1;
1408: }
1409: /* }}} */
1410:
1411: /* {{{ proto bool SQLite3Stmt::bindParam(int parameter_number, mixed parameter [, int type])
1412: Bind Parameter to a stmt variable. */
1413: PHP_METHOD(sqlite3stmt, bindParam)
1414: {
1415: php_sqlite3_stmt *stmt_obj;
1416: zval *object = getThis();
1417: struct php_sqlite3_bound_param param = {0};
1418: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1419:
1420: param.param_number = -1;
1421: param.type = SQLITE3_TEXT;
1422:
1423: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", ¶m.param_number, ¶m.parameter, ¶m.type) == FAILURE) {
1424: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", ¶m.name, ¶m.name_len, ¶m.parameter, ¶m.type) == FAILURE) {
1425: return;
1426: }
1427: }
1428:
1429: Z_ADDREF_P(param.parameter);
1430:
1431: if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) {
1432: if (param.parameter) {
1433: zval_ptr_dtor(&(param.parameter));
1434: param.parameter = NULL;
1435: }
1436: RETURN_FALSE;
1437: }
1438: RETURN_TRUE;
1439: }
1440: /* }}} */
1441:
1442: /* {{{ proto bool SQLite3Stmt::bindValue(int parameter_number, mixed parameter [, int type])
1443: Bind Value of a parameter to a stmt variable. */
1444: PHP_METHOD(sqlite3stmt, bindValue)
1445: {
1446: php_sqlite3_stmt *stmt_obj;
1447: zval *object = getThis();
1448: struct php_sqlite3_bound_param param = {0};
1449: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1450:
1451: param.param_number = -1;
1452: param.type = SQLITE3_TEXT;
1453:
1454: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", ¶m.param_number, ¶m.parameter, ¶m.type) == FAILURE) {
1455: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|l", ¶m.name, ¶m.name_len, ¶m.parameter, ¶m.type) == FAILURE) {
1456: return;
1457: }
1458: }
1459:
1460: Z_ADDREF_P(param.parameter);
1461:
1462: if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) {
1463: if (param.parameter) {
1464: zval_ptr_dtor(&(param.parameter));
1465: param.parameter = NULL;
1466: }
1467: RETURN_FALSE;
1468: }
1469: RETURN_TRUE;
1470: }
1471: /* }}} */
1472:
1473: /* {{{ proto SQLite3Result SQLite3Stmt::execute()
1474: Executes a prepared statement and returns a result set object. */
1475: PHP_METHOD(sqlite3stmt, execute)
1476: {
1477: php_sqlite3_stmt *stmt_obj;
1478: php_sqlite3_result *result;
1479: zval *object = getThis();
1480: int return_code = 0;
1481: struct php_sqlite3_bound_param *param;
1482:
1483: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1484:
1485: if (zend_parse_parameters_none() == FAILURE) {
1486: return;
1487: }
1488:
1489: SQLITE3_CHECK_INITIALIZED(stmt_obj->db_obj, stmt_obj->initialised, SQLite3)
1490:
1491: if (stmt_obj->bound_params) {
1492: zend_hash_internal_pointer_reset(stmt_obj->bound_params);
1493: while (zend_hash_get_current_data(stmt_obj->bound_params, (void **)¶m) == SUCCESS) {
1494: /* If the ZVAL is null then it should be bound as that */
1495: if (Z_TYPE_P(param->parameter) == IS_NULL) {
1496: sqlite3_bind_null(stmt_obj->stmt, param->param_number);
1497: zend_hash_move_forward(stmt_obj->bound_params);
1498: continue;
1499: }
1500:
1501: switch (param->type) {
1502: case SQLITE_INTEGER:
1503: convert_to_long(param->parameter);
1504: #if LONG_MAX > 2147483647
1505: sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
1506: #else
1507: sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
1508: #endif
1509: break;
1510:
1511: case SQLITE_FLOAT:
1512: /* convert_to_double(param->parameter);*/
1513: sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(param->parameter));
1514: break;
1515:
1516: case SQLITE_BLOB:
1517: {
1518: php_stream *stream = NULL;
1519: int blength;
1520: char *buffer = NULL;
1521: if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
1522: php_stream_from_zval_no_verify(stream, ¶m->parameter);
1523: if (stream == NULL) {
1524: php_sqlite3_error(stmt_obj->db_obj, "Unable to read stream for parameter %ld", param->param_number);
1525: RETURN_FALSE;
1526: }
1527: blength = php_stream_copy_to_mem(stream, (void *)&buffer, PHP_STREAM_COPY_ALL, 0);
1528: } else {
1529: convert_to_string(param->parameter);
1530: blength = Z_STRLEN_P(param->parameter);
1531: buffer = Z_STRVAL_P(param->parameter);
1532: }
1533:
1534: sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer, blength, SQLITE_TRANSIENT);
1535:
1536: if (stream) {
1537: pefree(buffer, 0);
1538: }
1539: break;
1540: }
1541:
1542: case SQLITE3_TEXT:
1543: convert_to_string(param->parameter);
1544: sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(param->parameter), Z_STRLEN_P(param->parameter), SQLITE_STATIC);
1545: break;
1546:
1547: case SQLITE_NULL:
1548: sqlite3_bind_null(stmt_obj->stmt, param->param_number);
1549: break;
1550:
1551: default:
1552: php_sqlite3_error(stmt_obj->db_obj, "Unknown parameter type: %ld for parameter %ld", param->type, param->param_number);
1553: RETURN_FALSE;
1554: }
1555: zend_hash_move_forward(stmt_obj->bound_params);
1556: }
1557: }
1558:
1559: return_code = sqlite3_step(stmt_obj->stmt);
1560:
1561: switch (return_code) {
1562: case SQLITE_ROW: /* Valid Row */
1563: case SQLITE_DONE: /* Valid but no results */
1564: {
1565: sqlite3_reset(stmt_obj->stmt);
1566: object_init_ex(return_value, php_sqlite3_result_entry);
1567: result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
1568:
1569: Z_ADDREF_P(object);
1570:
1571: result->is_prepared_statement = 1;
1572: result->db_obj = stmt_obj->db_obj;
1573: result->stmt_obj = stmt_obj;
1574: result->stmt_obj_zval = getThis();
1575:
1576: break;
1577: }
1578: case SQLITE_ERROR:
1579: sqlite3_reset(stmt_obj->stmt);
1580:
1581: default:
1582: php_sqlite3_error(stmt_obj->db_obj, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt)));
1583: zval_dtor(return_value);
1584: RETURN_FALSE;
1585: }
1586:
1587: return;
1588: }
1589: /* }}} */
1590:
1591: /* {{{ proto int SQLite3Stmt::__construct(SQLite3 dbobject, String Statement)
1592: __constructor for SQLite3Stmt. */
1593: PHP_METHOD(sqlite3stmt, __construct)
1594: {
1595: php_sqlite3_stmt *stmt_obj;
1596: php_sqlite3_db_object *db_obj;
1597: zval *object = getThis();
1598: zval *db_zval;
1599: char *sql;
1600: int sql_len, errcode;
1601: zend_error_handling error_handling;
1602: php_sqlite3_free_list *free_item;
1603:
1604: stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
1605: zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
1606:
1607: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &db_zval, php_sqlite3_sc_entry, &sql, &sql_len) == FAILURE) {
1608: zend_restore_error_handling(&error_handling TSRMLS_CC);
1609: return;
1610: }
1611:
1612: db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(db_zval TSRMLS_CC);
1613:
1614: SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
1615:
1616: zend_restore_error_handling(&error_handling TSRMLS_CC);
1617:
1618: if (!sql_len) {
1619: RETURN_FALSE;
1620: }
1621:
1622: stmt_obj->db_obj = db_obj;
1623: stmt_obj->db_obj_zval = db_zval;
1624:
1625: Z_ADDREF_P(db_zval);
1626:
1627: errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
1628: if (errcode != SQLITE_OK) {
1629: php_sqlite3_error(db_obj, "Unable to prepare statement: %d, %s", errcode, sqlite3_errmsg(db_obj->db));
1630: zval_dtor(return_value);
1631: RETURN_FALSE;
1632: }
1633: stmt_obj->initialised = 1;
1634:
1635: free_item = emalloc(sizeof(php_sqlite3_free_list));
1636: free_item->stmt_obj = stmt_obj;
1637: free_item->stmt_obj_zval = getThis();
1638:
1639: zend_llist_add_element(&(db_obj->free_list), &free_item);
1640: }
1641: /* }}} */
1642:
1643: /* {{{ proto int SQLite3Result::numColumns()
1644: Number of columns in the result set. */
1645: PHP_METHOD(sqlite3result, numColumns)
1646: {
1647: php_sqlite3_result *result_obj;
1648: zval *object = getThis();
1649: result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
1650:
1651: SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
1652:
1653: if (zend_parse_parameters_none() == FAILURE) {
1654: return;
1655: }
1656:
1657: RETURN_LONG(sqlite3_column_count(result_obj->stmt_obj->stmt));
1658: }
1659: /* }}} */
1660:
1661: /* {{{ proto string SQLite3Result::columnName(int column)
1662: Returns the name of the nth column. */
1663: PHP_METHOD(sqlite3result, columnName)
1664: {
1665: php_sqlite3_result *result_obj;
1666: zval *object = getThis();
1667: long column = 0;
1668: char *column_name;
1669: result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
1670:
1671: SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
1672:
1673: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) {
1674: return;
1675: }
1676: column_name = (char*) sqlite3_column_name(result_obj->stmt_obj->stmt, column);
1677:
1678: if (column_name == NULL) {
1679: RETURN_FALSE;
1680: }
1681:
1682: RETVAL_STRING(column_name, 1);
1683: }
1684: /* }}} */
1685:
1686: /* {{{ proto int SQLite3Result::columnType(int column)
1687: Returns the type of the nth column. */
1688: PHP_METHOD(sqlite3result, columnType)
1689: {
1690: php_sqlite3_result *result_obj;
1691: zval *object = getThis();
1692: long column = 0;
1693: result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
1694:
1695: SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
1696:
1697: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) {
1698: return;
1699: }
1700:
1701: if (result_obj->complete) {
1702: RETURN_FALSE;
1703: }
1704:
1705: RETURN_LONG(sqlite3_column_type(result_obj->stmt_obj->stmt, column));
1706: }
1707: /* }}} */
1708:
1709: /* {{{ proto array SQLite3Result::fetchArray([int mode])
1710: Fetch a result row as both an associative or numerically indexed array or both. */
1711: PHP_METHOD(sqlite3result, fetchArray)
1712: {
1713: php_sqlite3_result *result_obj;
1714: zval *object = getThis();
1715: int i, ret;
1716: long mode = PHP_SQLITE3_BOTH;
1717: result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
1718:
1719: SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
1720:
1721: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mode) == FAILURE) {
1722: return;
1723: }
1724:
1725: ret = sqlite3_step(result_obj->stmt_obj->stmt);
1726: switch (ret) {
1727: case SQLITE_ROW:
1728: /* If there was no return value then just skip fetching */
1729: if (!return_value_used) {
1730: return;
1731: }
1732:
1733: array_init(return_value);
1734:
1735: for (i = 0; i < sqlite3_data_count(result_obj->stmt_obj->stmt); i++) {
1736: zval *data;
1737:
1738: data = sqlite_value_to_zval(result_obj->stmt_obj->stmt, i);
1739:
1740: if (mode & PHP_SQLITE3_NUM) {
1741: add_index_zval(return_value, i, data);
1742: }
1743:
1744: if (mode & PHP_SQLITE3_ASSOC) {
1745: if (mode & PHP_SQLITE3_NUM) {
1746: Z_ADDREF_P(data);
1747: }
1748: add_assoc_zval(return_value, (char*)sqlite3_column_name(result_obj->stmt_obj->stmt, i), data);
1749: }
1750: }
1751: break;
1752:
1753: case SQLITE_DONE:
1754: result_obj->complete = 1;
1755: RETURN_FALSE;
1756: break;
1757:
1758: default:
1759: php_sqlite3_error(result_obj->db_obj, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(result_obj->stmt_obj->stmt)));
1760: }
1761: }
1762: /* }}} */
1763:
1764: /* {{{ proto bool SQLite3Result::reset()
1765: Resets the result set back to the first row. */
1766: PHP_METHOD(sqlite3result, reset)
1767: {
1768: php_sqlite3_result *result_obj;
1769: zval *object = getThis();
1770: result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
1771:
1772: SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
1773:
1774: if (zend_parse_parameters_none() == FAILURE) {
1775: return;
1776: }
1777:
1778: if (sqlite3_reset(result_obj->stmt_obj->stmt) != SQLITE_OK) {
1779: RETURN_FALSE;
1780: }
1781:
1782: result_obj->complete = 0;
1783:
1784: RETURN_TRUE;
1785: }
1786: /* }}} */
1787:
1788: /* {{{ proto bool SQLite3Result::finalize()
1789: Closes the result set. */
1790: PHP_METHOD(sqlite3result, finalize)
1791: {
1792: php_sqlite3_result *result_obj;
1793: zval *object = getThis();
1794: result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
1795:
1796: SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
1797:
1798: if (zend_parse_parameters_none() == FAILURE) {
1799: return;
1800: }
1801:
1802: /* We need to finalize an internal statement */
1803: if (result_obj->is_prepared_statement == 0) {
1804: zend_llist_del_element(&(result_obj->db_obj->free_list), result_obj->stmt_obj_zval,
1805: (int (*)(void *, void *)) php_sqlite3_compare_stmt_zval_free);
1806: } else {
1807: sqlite3_reset(result_obj->stmt_obj->stmt);
1808: }
1809:
1810: RETURN_TRUE;
1811: }
1812: /* }}} */
1813:
1814: /* {{{ proto int SQLite3Result::__construct()
1815: __constructor for SQLite3Result. */
1816: PHP_METHOD(sqlite3result, __construct)
1817: {
1818: zend_throw_exception(zend_exception_get_default(TSRMLS_C), "SQLite3Result cannot be directly instantiated", 0 TSRMLS_CC);
1819: }
1820: /* }}} */
1821:
1822: /* {{{ arginfo */
1823: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_open, 0)
1824: ZEND_ARG_INFO(0, filename)
1825: ZEND_ARG_INFO(0, flags)
1826: ZEND_ARG_INFO(0, encryption_key)
1827: ZEND_END_ARG_INFO()
1828:
1829: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_busytimeout, 0)
1830: ZEND_ARG_INFO(0, ms)
1831: ZEND_END_ARG_INFO()
1832:
1833: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1834: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_loadextension, 0)
1835: ZEND_ARG_INFO(0, shared_library)
1836: ZEND_END_ARG_INFO()
1837: #endif
1838:
1839: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_escapestring, 0, 0, 1)
1840: ZEND_ARG_INFO(0, value)
1841: ZEND_END_ARG_INFO()
1842:
1843: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_query, 0, 0, 1)
1844: ZEND_ARG_INFO(0, query)
1845: ZEND_END_ARG_INFO()
1846:
1847: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_querysingle, 0, 0, 1)
1848: ZEND_ARG_INFO(0, query)
1849: ZEND_ARG_INFO(0, entire_row)
1850: ZEND_END_ARG_INFO()
1851:
1852: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createfunction, 0, 0, 2)
1853: ZEND_ARG_INFO(0, name)
1854: ZEND_ARG_INFO(0, callback)
1855: ZEND_ARG_INFO(0, argument_count)
1856: ZEND_END_ARG_INFO()
1857:
1858: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createaggregate, 0, 0, 3)
1859: ZEND_ARG_INFO(0, name)
1860: ZEND_ARG_INFO(0, step_callback)
1861: ZEND_ARG_INFO(0, final_callback)
1862: ZEND_ARG_INFO(0, argument_count)
1863: ZEND_END_ARG_INFO()
1864:
1865: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createcollation, 0, 0, 2)
1866: ZEND_ARG_INFO(0, name)
1867: ZEND_ARG_INFO(0, callback)
1868: ZEND_END_ARG_INFO()
1869:
1870: ZEND_BEGIN_ARG_INFO_EX(argingo_sqlite3_openblob, 0, 0, 3)
1871: ZEND_ARG_INFO(0, table)
1872: ZEND_ARG_INFO(0, column)
1873: ZEND_ARG_INFO(0, rowid)
1874: ZEND_ARG_INFO(0, dbname)
1875: ZEND_END_ARG_INFO()
1876:
1877: ZEND_BEGIN_ARG_INFO_EX(argingo_sqlite3_enableexceptions, 0, 0, 1)
1878: ZEND_ARG_INFO(0, enableExceptions)
1879: ZEND_END_ARG_INFO()
1880:
1881: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3stmt_bindparam, 0, 0, 2)
1882: ZEND_ARG_INFO(0, param_number)
1883: ZEND_ARG_INFO(1, param)
1884: ZEND_ARG_INFO(0, type)
1885: ZEND_END_ARG_INFO()
1886:
1887: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3stmt_bindvalue, 0, 0, 2)
1888: ZEND_ARG_INFO(0, param_number)
1889: ZEND_ARG_INFO(0, param)
1890: ZEND_ARG_INFO(0, type)
1891: ZEND_END_ARG_INFO()
1892:
1893: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3stmt_construct, 1)
1894: ZEND_ARG_INFO(0, sqlite3)
1895: ZEND_END_ARG_INFO()
1896:
1897: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3result_columnname, 0, 0, 1)
1898: ZEND_ARG_INFO(0, column_number)
1899: ZEND_END_ARG_INFO()
1900:
1901: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3result_columntype, 0, 0, 1)
1902: ZEND_ARG_INFO(0, column_number)
1903: ZEND_END_ARG_INFO()
1904:
1905: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3result_fetcharray, 0, 0, 1)
1906: ZEND_ARG_INFO(0, mode)
1907: ZEND_END_ARG_INFO()
1908:
1909: ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_void, 0)
1910: ZEND_END_ARG_INFO()
1911: /* }}} */
1912:
1913: /* {{{ php_sqlite3_class_methods */
1914: static zend_function_entry php_sqlite3_class_methods[] = {
1915: PHP_ME(sqlite3, open, arginfo_sqlite3_open, ZEND_ACC_PUBLIC)
1916: PHP_ME(sqlite3, close, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1917: PHP_ME(sqlite3, exec, arginfo_sqlite3_query, ZEND_ACC_PUBLIC)
1918: PHP_ME(sqlite3, version, arginfo_sqlite3_void, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
1919: PHP_ME(sqlite3, lastInsertRowID, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1920: PHP_ME(sqlite3, lastErrorCode, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1921: PHP_ME(sqlite3, lastErrorMsg, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1922: PHP_ME(sqlite3, busyTimeout, arginfo_sqlite3_busytimeout, ZEND_ACC_PUBLIC)
1923: #ifndef SQLITE_OMIT_LOAD_EXTENSION
1924: PHP_ME(sqlite3, loadExtension, arginfo_sqlite3_loadextension, ZEND_ACC_PUBLIC)
1925: #endif
1926: PHP_ME(sqlite3, changes, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1927: PHP_ME(sqlite3, escapeString, arginfo_sqlite3_escapestring, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
1928: PHP_ME(sqlite3, prepare, arginfo_sqlite3_query, ZEND_ACC_PUBLIC)
1929: PHP_ME(sqlite3, query, arginfo_sqlite3_query, ZEND_ACC_PUBLIC)
1930: PHP_ME(sqlite3, querySingle, arginfo_sqlite3_querysingle, ZEND_ACC_PUBLIC)
1931: PHP_ME(sqlite3, createFunction, arginfo_sqlite3_createfunction, ZEND_ACC_PUBLIC)
1932: PHP_ME(sqlite3, createAggregate, arginfo_sqlite3_createaggregate, ZEND_ACC_PUBLIC)
1933: PHP_ME(sqlite3, createCollation, arginfo_sqlite3_createcollation, ZEND_ACC_PUBLIC)
1934: PHP_ME(sqlite3, openBlob, argingo_sqlite3_openblob, ZEND_ACC_PUBLIC)
1935: PHP_ME(sqlite3, enableExceptions, argingo_sqlite3_enableexceptions, ZEND_ACC_PUBLIC)
1936: /* Aliases */
1937: PHP_MALIAS(sqlite3, __construct, open, arginfo_sqlite3_open, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
1938: PHP_FE_END
1939: };
1940: /* }}} */
1941:
1942: /* {{{ php_sqlite3_stmt_class_methods */
1943: static zend_function_entry php_sqlite3_stmt_class_methods[] = {
1944: PHP_ME(sqlite3stmt, paramCount, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1945: PHP_ME(sqlite3stmt, close, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1946: PHP_ME(sqlite3stmt, reset, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1947: PHP_ME(sqlite3stmt, clear, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1948: PHP_ME(sqlite3stmt, execute, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1949: PHP_ME(sqlite3stmt, bindParam, arginfo_sqlite3stmt_bindparam, ZEND_ACC_PUBLIC)
1950: PHP_ME(sqlite3stmt, bindValue, arginfo_sqlite3stmt_bindvalue, ZEND_ACC_PUBLIC)
1951: PHP_ME(sqlite3stmt, readOnly, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1952: PHP_ME(sqlite3stmt, __construct, arginfo_sqlite3stmt_construct, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
1953: PHP_FE_END
1954: };
1955: /* }}} */
1956:
1957: /* {{{ php_sqlite3_result_class_methods */
1958: static zend_function_entry php_sqlite3_result_class_methods[] = {
1959: PHP_ME(sqlite3result, numColumns, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1960: PHP_ME(sqlite3result, columnName, arginfo_sqlite3result_columnname, ZEND_ACC_PUBLIC)
1961: PHP_ME(sqlite3result, columnType, arginfo_sqlite3result_columntype, ZEND_ACC_PUBLIC)
1962: PHP_ME(sqlite3result, fetchArray, arginfo_sqlite3result_fetcharray, ZEND_ACC_PUBLIC)
1963: PHP_ME(sqlite3result, reset, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1964: PHP_ME(sqlite3result, finalize, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
1965: PHP_ME(sqlite3result, __construct, arginfo_sqlite3_void, ZEND_ACC_PRIVATE|ZEND_ACC_CTOR)
1966: PHP_FE_END
1967: };
1968: /* }}} */
1969:
1970: /* {{{ Authorization Callback
1971: */
1972: static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, const char *arg5, const char *arg6)
1973: {
1974: switch (access_type) {
1975: case SQLITE_ATTACH:
1976: {
1977: if (memcmp(arg3, ":memory:", sizeof(":memory:")) && *arg3) {
1978: TSRMLS_FETCH();
1979:
1980: #if PHP_API_VERSION < 20100412
1981: if (PG(safe_mode) && (!php_checkuid(arg3, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
1982: return SQLITE_DENY;
1983: }
1984: #endif
1985:
1986: if (php_check_open_basedir(arg3 TSRMLS_CC)) {
1987: return SQLITE_DENY;
1988: }
1989: }
1990: return SQLITE_OK;
1991: }
1992:
1993: default:
1994: /* access allowed */
1995: return SQLITE_OK;
1996: }
1997: }
1998: /* }}} */
1999:
2000: /* {{{ php_sqlite3_free_list_dtor
2001: */
2002: static void php_sqlite3_free_list_dtor(void **item)
2003: {
2004: php_sqlite3_free_list *free_item = (php_sqlite3_free_list *)*item;
2005:
2006: if (free_item->stmt_obj && free_item->stmt_obj->initialised) {
2007: sqlite3_finalize(free_item->stmt_obj->stmt);
2008: free_item->stmt_obj->initialised = 0;
2009: }
2010: efree(*item);
2011: }
2012: /* }}} */
2013:
2014: static int php_sqlite3_compare_stmt_zval_free( php_sqlite3_free_list **free_list, zval *statement ) /* {{{ */
2015: {
2016: return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj_zval);
2017: }
2018: /* }}} */
2019:
2020: static int php_sqlite3_compare_stmt_free( php_sqlite3_free_list **free_list, sqlite3_stmt *statement ) /* {{{ */
2021: {
2022: return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj->stmt);
2023: }
2024: /* }}} */
2025:
2026: static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) /* {{{ */
2027: {
2028: php_sqlite3_db_object *intern = (php_sqlite3_db_object *)object;
2029: php_sqlite3_func *func;
2030: php_sqlite3_collation *collation;
2031:
2032: if (!intern) {
2033: return;
2034: }
2035:
2036: while (intern->funcs) {
2037: func = intern->funcs;
2038: intern->funcs = func->next;
2039: if (intern->initialised && intern->db) {
2040: sqlite3_create_function(intern->db, func->func_name, func->argc, SQLITE_UTF8, func, NULL, NULL, NULL);
2041: }
2042:
2043: efree((char*)func->func_name);
2044:
2045: if (func->func) {
2046: zval_ptr_dtor(&func->func);
2047: }
2048: if (func->step) {
2049: zval_ptr_dtor(&func->step);
2050: }
2051: if (func->fini) {
2052: zval_ptr_dtor(&func->fini);
2053: }
2054: efree(func);
2055: }
2056:
2057: while (intern->collations){
2058: collation = intern->collations;
2059: intern->collations = collation->next;
2060: if (intern->initialised && intern->db){
2061: sqlite3_create_collation(intern->db, collation->collation_name, SQLITE_UTF8, NULL, NULL);
2062: }
2063: efree((char*)collation->collation_name);
2064: if (collation->cmp_func){
2065: zval_ptr_dtor(&collation->cmp_func);
2066: }
2067: efree(collation);
2068: }
2069:
2070: if (intern->initialised && intern->db) {
2071: sqlite3_close(intern->db);
2072: intern->initialised = 0;
2073: }
2074:
2075: zend_object_std_dtor(&intern->zo TSRMLS_CC);
2076: efree(intern);
2077: }
2078: /* }}} */
2079:
2080: static void php_sqlite3_stmt_object_free_storage(void *object TSRMLS_DC) /* {{{ */
2081: {
2082: php_sqlite3_stmt *intern = (php_sqlite3_stmt *)object;
2083:
2084: if (!intern) {
2085: return;
2086: }
2087:
2088: if (intern->bound_params) {
2089: zend_hash_destroy(intern->bound_params);
2090: FREE_HASHTABLE(intern->bound_params);
2091: intern->bound_params = NULL;
2092: }
2093:
2094: if (intern->initialised) {
2095: zend_llist_del_element(&(intern->db_obj->free_list), intern->stmt,
2096: (int (*)(void *, void *)) php_sqlite3_compare_stmt_free);
2097: }
2098:
2099: if (intern->db_obj_zval) {
2100: zval_ptr_dtor(&intern->db_obj_zval);
2101: }
2102:
2103: zend_object_std_dtor(&intern->zo TSRMLS_CC);
2104: efree(intern);
2105: }
2106: /* }}} */
2107:
2108: static void php_sqlite3_result_object_free_storage(void *object TSRMLS_DC) /* {{{ */
2109: {
2110: php_sqlite3_result *intern = (php_sqlite3_result *)object;
2111:
2112: if (!intern) {
2113: return;
2114: }
2115:
2116: if (intern->stmt_obj_zval) {
2117: if (intern->stmt_obj->initialised) {
2118: sqlite3_reset(intern->stmt_obj->stmt);
2119: }
2120:
2121: if (intern->is_prepared_statement == 0) {
2122: zval_dtor(intern->stmt_obj_zval);
2123: FREE_ZVAL(intern->stmt_obj_zval);
2124: } else {
2125: zval_ptr_dtor(&intern->stmt_obj_zval);
2126: }
2127: }
2128:
2129: zend_object_std_dtor(&intern->zo TSRMLS_CC);
2130: efree(intern);
2131: }
2132: /* }}} */
2133:
2134: static zend_object_value php_sqlite3_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
2135: {
2136: zend_object_value retval;
2137: php_sqlite3_db_object *intern;
2138:
2139: /* Allocate memory for it */
2140: intern = emalloc(sizeof(php_sqlite3_db_object));
2141: memset(intern, 0, sizeof(php_sqlite3_db_object));
2142: intern->exception = 0;
2143:
2144: /* Need to keep track of things to free */
2145: zend_llist_init(&(intern->free_list), sizeof(php_sqlite3_free_list *), (llist_dtor_func_t)php_sqlite3_free_list_dtor, 0);
2146:
2147: zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
2148: object_properties_init(&intern->zo, class_type);
2149:
2150: retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_object_free_storage, NULL TSRMLS_CC);
2151: retval.handlers = (zend_object_handlers *) &sqlite3_object_handlers;
2152:
2153: return retval;
2154: }
2155: /* }}} */
2156:
2157: static zend_object_value php_sqlite3_stmt_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
2158: {
2159: zend_object_value retval;
2160: php_sqlite3_stmt *intern;
2161:
2162: /* Allocate memory for it */
2163: intern = emalloc(sizeof(php_sqlite3_stmt));
2164: memset(intern, 0, sizeof(php_sqlite3_stmt));
2165:
2166: intern->db_obj_zval = NULL;
2167:
2168: zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
2169: object_properties_init(&intern->zo, class_type);
2170:
2171: retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_stmt_object_free_storage, NULL TSRMLS_CC);
2172: retval.handlers = (zend_object_handlers *) &sqlite3_stmt_object_handlers;
2173:
2174: return retval;
2175: }
2176: /* }}} */
2177:
2178: static zend_object_value php_sqlite3_result_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
2179: {
2180: zend_object_value retval;
2181: php_sqlite3_result *intern;
2182:
2183: /* Allocate memory for it */
2184: intern = emalloc(sizeof(php_sqlite3_result));
2185: memset(intern, 0, sizeof(php_sqlite3_result));
2186:
2187: intern->complete = 0;
2188: intern->is_prepared_statement = 0;
2189: intern->stmt_obj_zval = NULL;
2190:
2191: zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
2192: object_properties_init(&intern->zo, class_type);
2193:
2194: retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_result_object_free_storage, NULL TSRMLS_CC);
2195: retval.handlers = (zend_object_handlers *) &sqlite3_result_object_handlers;
2196:
2197: return retval;
2198: }
2199: /* }}} */
2200:
2201: static void sqlite3_param_dtor(void *data) /* {{{ */
2202: {
2203: struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)data;
2204:
2205: if (param->name) {
2206: efree(param->name);
2207: }
2208:
2209: if (param->parameter) {
2210: zval_ptr_dtor(&(param->parameter));
2211: param->parameter = NULL;
2212: }
2213: }
2214: /* }}} */
2215:
2216: /* {{{ PHP_MINIT_FUNCTION
2217: */
2218: PHP_MINIT_FUNCTION(sqlite3)
2219: {
2220: zend_class_entry ce;
2221:
2222: #if defined(ZTS)
2223: /* Refuse to load if this wasn't a threasafe library loaded */
2224: if (!sqlite3_threadsafe()) {
2225: php_error_docref(NULL TSRMLS_CC, E_WARNING, "A thread safe version of SQLite is required when using a thread safe version of PHP.");
2226: return FAILURE;
2227: }
2228: #endif
2229:
2230: memcpy(&sqlite3_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2231: memcpy(&sqlite3_stmt_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2232: memcpy(&sqlite3_result_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
2233:
2234: /* Register SQLite 3 Class */
2235: INIT_CLASS_ENTRY(ce, "SQLite3", php_sqlite3_class_methods);
2236: ce.create_object = php_sqlite3_object_new;
2237: sqlite3_object_handlers.clone_obj = NULL;
2238: php_sqlite3_sc_entry = zend_register_internal_class(&ce TSRMLS_CC);
2239:
2240: /* Register SQLite 3 Prepared Statement Class */
2241: INIT_CLASS_ENTRY(ce, "SQLite3Stmt", php_sqlite3_stmt_class_methods);
2242: ce.create_object = php_sqlite3_stmt_object_new;
2243: sqlite3_stmt_object_handlers.clone_obj = NULL;
2244: php_sqlite3_stmt_entry = zend_register_internal_class(&ce TSRMLS_CC);
2245:
2246: /* Register SQLite 3 Result Class */
2247: INIT_CLASS_ENTRY(ce, "SQLite3Result", php_sqlite3_result_class_methods);
2248: ce.create_object = php_sqlite3_result_object_new;
2249: sqlite3_result_object_handlers.clone_obj = NULL;
2250: php_sqlite3_result_entry = zend_register_internal_class(&ce TSRMLS_CC);
2251:
2252: REGISTER_INI_ENTRIES();
2253:
2254: REGISTER_LONG_CONSTANT("SQLITE3_ASSOC", PHP_SQLITE3_ASSOC, CONST_CS | CONST_PERSISTENT);
2255: REGISTER_LONG_CONSTANT("SQLITE3_NUM", PHP_SQLITE3_NUM, CONST_CS | CONST_PERSISTENT);
2256: REGISTER_LONG_CONSTANT("SQLITE3_BOTH", PHP_SQLITE3_BOTH, CONST_CS | CONST_PERSISTENT);
2257:
2258: REGISTER_LONG_CONSTANT("SQLITE3_INTEGER", SQLITE_INTEGER, CONST_CS | CONST_PERSISTENT);
2259: REGISTER_LONG_CONSTANT("SQLITE3_FLOAT", SQLITE_FLOAT, CONST_CS | CONST_PERSISTENT);
2260: REGISTER_LONG_CONSTANT("SQLITE3_TEXT", SQLITE3_TEXT, CONST_CS | CONST_PERSISTENT);
2261: REGISTER_LONG_CONSTANT("SQLITE3_BLOB", SQLITE_BLOB, CONST_CS | CONST_PERSISTENT);
2262: REGISTER_LONG_CONSTANT("SQLITE3_NULL", SQLITE_NULL, CONST_CS | CONST_PERSISTENT);
2263:
2264: REGISTER_LONG_CONSTANT("SQLITE3_OPEN_READONLY", SQLITE_OPEN_READONLY, CONST_CS | CONST_PERSISTENT);
2265: REGISTER_LONG_CONSTANT("SQLITE3_OPEN_READWRITE", SQLITE_OPEN_READWRITE, CONST_CS | CONST_PERSISTENT);
2266: REGISTER_LONG_CONSTANT("SQLITE3_OPEN_CREATE", SQLITE_OPEN_CREATE, CONST_CS | CONST_PERSISTENT);
2267:
2268: return SUCCESS;
2269: }
2270: /* }}} */
2271:
2272: /* {{{ PHP_MSHUTDOWN_FUNCTION
2273: */
2274: PHP_MSHUTDOWN_FUNCTION(sqlite3)
2275: {
2276: UNREGISTER_INI_ENTRIES();
2277:
2278: return SUCCESS;
2279: }
2280: /* }}} */
2281:
2282: /* {{{ PHP_MINFO_FUNCTION
2283: */
2284: PHP_MINFO_FUNCTION(sqlite3)
2285: {
2286: php_info_print_table_start();
2287: php_info_print_table_header(2, "SQLite3 support", "enabled");
2288: php_info_print_table_row(2, "SQLite3 module version", PHP_SQLITE3_VERSION);
2289: php_info_print_table_row(2, "SQLite Library", sqlite3_libversion());
2290: php_info_print_table_end();
2291:
2292: DISPLAY_INI_ENTRIES();
2293: }
2294: /* }}} */
2295:
2296: /* {{{ PHP_GINIT_FUNCTION
2297: */
2298: static PHP_GINIT_FUNCTION(sqlite3)
2299: {
2300: memset(sqlite3_globals, 0, sizeof(*sqlite3_globals));
2301: }
2302: /* }}} */
2303:
2304: /* {{{ sqlite3_module_entry
2305: */
2306: zend_module_entry sqlite3_module_entry = {
2307: STANDARD_MODULE_HEADER,
2308: "sqlite3",
2309: NULL,
2310: PHP_MINIT(sqlite3),
2311: PHP_MSHUTDOWN(sqlite3),
2312: NULL,
2313: NULL,
2314: PHP_MINFO(sqlite3),
2315: PHP_SQLITE3_VERSION,
2316: PHP_MODULE_GLOBALS(sqlite3),
2317: PHP_GINIT(sqlite3),
2318: NULL,
2319: NULL,
2320: STANDARD_MODULE_PROPERTIES_EX
2321: };
2322: /* }}} */
2323:
2324: #ifdef COMPILE_DL_SQLITE3
2325: ZEND_GET_MODULE(sqlite3)
2326: #endif
2327:
2328: /*
2329: * Local variables:
2330: * tab-width: 4
2331: * c-basic-offset: 4
2332: * End:
2333: * vim600: sw=4 ts=4 fdm=marker
2334: * vim<600: sw=4 ts=4
2335: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sqlite3.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 / sqlite3