Annotation of embedaddon/php/ext/sqlite/sqlite.c, revision 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: Wez Furlong <wez@thebrainroom.com> |
! 16: | Tal Peer <tal@php.net> |
! 17: | Marcus Boerger <helly@php.net> |
! 18: +----------------------------------------------------------------------+
! 19:
! 20: $Id: sqlite.c 321634 2012-01-01 13:15:04Z felipe $
! 21: */
! 22:
! 23: #ifdef HAVE_CONFIG_H
! 24: #include "config.h"
! 25: #endif
! 26:
! 27: #define PHP_SQLITE_MODULE_VERSION "2.0-dev"
! 28:
! 29: #include "php.h"
! 30: #include "php_ini.h"
! 31: #include "ext/standard/info.h"
! 32: #if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
! 33: #include "ext/session/php_session.h"
! 34: #endif
! 35: #include "php_sqlite.h"
! 36:
! 37: #if HAVE_TIME_H
! 38: # include <time.h>
! 39: #endif
! 40: #if HAVE_UNISTD_H
! 41: #include <unistd.h>
! 42: #endif
! 43:
! 44: #include <sqlite.h>
! 45:
! 46: #include "zend_exceptions.h"
! 47: #include "zend_interfaces.h"
! 48:
! 49: #if defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
! 50: extern PHPAPI zend_class_entry *spl_ce_RuntimeException;
! 51: extern PHPAPI zend_class_entry *spl_ce_Countable;
! 52: #endif
! 53:
! 54: #if PHP_SQLITE2_HAVE_PDO
! 55: # include "pdo/php_pdo.h"
! 56: # include "pdo/php_pdo_driver.h"
! 57: extern pdo_driver_t pdo_sqlite2_driver;
! 58: #endif
! 59:
! 60: #ifndef safe_emalloc
! 61: # define safe_emalloc(a,b,c) emalloc((a)*(b)+(c))
! 62: #endif
! 63:
! 64: ZEND_DECLARE_MODULE_GLOBALS(sqlite)
! 65: static PHP_GINIT_FUNCTION(sqlite);
! 66:
! 67: #if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
! 68: extern ps_module ps_mod_sqlite;
! 69: #define ps_sqlite_ptr &ps_mod_sqlite
! 70: #endif
! 71:
! 72: extern int sqlite_encode_binary(const unsigned char *in, int n, unsigned char *out);
! 73: extern int sqlite_decode_binary(const unsigned char *in, unsigned char *out);
! 74:
! 75: #define php_sqlite_encode_binary(in, n, out) sqlite_encode_binary((const unsigned char *)in, n, (unsigned char *)out)
! 76: #define php_sqlite_decode_binary(in, out) in && *in ? sqlite_decode_binary((const unsigned char *)in, (unsigned char *)out) : 0
! 77:
! 78: static int sqlite_count_elements(zval *object, long *count TSRMLS_DC);
! 79:
! 80: static int le_sqlite_db, le_sqlite_result, le_sqlite_pdb;
! 81:
! 82: static inline void php_sqlite_strtoupper(char *s)
! 83: {
! 84: while (*s!='\0') {
! 85: *s = toupper(*s);
! 86: s++;
! 87: }
! 88: }
! 89:
! 90: static inline void php_sqlite_strtolower(char *s)
! 91: {
! 92: while (*s!='\0') {
! 93: *s = tolower(*s);
! 94: s++;
! 95: }
! 96: }
! 97:
! 98: /* {{{ PHP_INI
! 99: */
! 100: PHP_INI_BEGIN()
! 101: STD_PHP_INI_ENTRY_EX("sqlite.assoc_case", "0", PHP_INI_ALL, OnUpdateLong, assoc_case, zend_sqlite_globals, sqlite_globals, display_link_numbers)
! 102: PHP_INI_END()
! 103: /* }}} */
! 104:
! 105: #define DB_FROM_ZVAL(db, zv) ZEND_FETCH_RESOURCE2(db, struct php_sqlite_db *, zv, -1, "sqlite database", le_sqlite_db, le_sqlite_pdb)
! 106:
! 107: #define DB_FROM_OBJECT(db, object) \
! 108: { \
! 109: sqlite_object *obj = (sqlite_object*) zend_object_store_get_object(object TSRMLS_CC); \
! 110: db = obj->u.db; \
! 111: if (!db) { \
! 112: php_error_docref(NULL TSRMLS_CC, E_WARNING, "The database wasn't opened"); \
! 113: RETURN_NULL(); \
! 114: } \
! 115: }
! 116:
! 117: #define RES_FROM_OBJECT_RESTORE_ERH(res, object, error_handling) \
! 118: { \
! 119: sqlite_object *obj = (sqlite_object*) zend_object_store_get_object(object TSRMLS_CC); \
! 120: res = obj->u.res; \
! 121: if (!res) { \
! 122: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No result set available"); \
! 123: if (error_handling) \
! 124: zend_restore_error_handling(error_handling TSRMLS_CC); \
! 125: RETURN_NULL(); \
! 126: } \
! 127: }
! 128:
! 129: #define RES_FROM_OBJECT(res, object) RES_FROM_OBJECT_RESTORE_ERH(res, object, NULL)
! 130:
! 131: #define PHP_SQLITE_EMPTY_QUERY \
! 132: if (!sql_len || !*sql) { \
! 133: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot execute empty query."); \
! 134: RETURN_FALSE; \
! 135: }
! 136:
! 137: struct php_sqlite_result {
! 138: struct php_sqlite_db *db;
! 139: sqlite_vm *vm;
! 140: int buffered;
! 141: int ncolumns;
! 142: int nrows;
! 143: int curr_row;
! 144: char **col_names;
! 145: int alloc_rows;
! 146: int mode;
! 147: char **table;
! 148: };
! 149:
! 150: struct php_sqlite_db {
! 151: sqlite *db;
! 152: int last_err_code;
! 153: zend_bool is_persistent;
! 154: long rsrc_id;
! 155:
! 156: HashTable callbacks;
! 157: };
! 158:
! 159: struct php_sqlite_agg_functions {
! 160: struct php_sqlite_db *db;
! 161: int is_valid;
! 162: zval *step;
! 163: zval *fini;
! 164: };
! 165:
! 166: static void php_sqlite_fetch_array(struct php_sqlite_result *res, int mode, zend_bool decode_binary, int move_next, zval *return_value TSRMLS_DC);
! 167: static int php_sqlite_fetch(struct php_sqlite_result *rres TSRMLS_DC);
! 168:
! 169: enum { PHPSQLITE_ASSOC = 1, PHPSQLITE_NUM = 2, PHPSQLITE_BOTH = PHPSQLITE_ASSOC|PHPSQLITE_NUM };
! 170:
! 171: /* {{{ arginfo */
! 172: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_popen, 0, 0, 1)
! 173: ZEND_ARG_INFO(0, filename)
! 174: ZEND_ARG_INFO(0, mode)
! 175: ZEND_ARG_INFO(1, error_message)
! 176: ZEND_END_ARG_INFO()
! 177:
! 178: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_open, 0, 0, 1)
! 179: ZEND_ARG_INFO(0, filename)
! 180: ZEND_ARG_INFO(0, mode)
! 181: ZEND_ARG_INFO(1, error_message)
! 182: ZEND_END_ARG_INFO()
! 183:
! 184: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_factory, 0, 0, 1)
! 185: ZEND_ARG_INFO(0, filename)
! 186: ZEND_ARG_INFO(0, mode)
! 187: ZEND_ARG_INFO(1, error_message)
! 188: ZEND_END_ARG_INFO()
! 189:
! 190: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_busy_timeout, 0, 0, 2)
! 191: ZEND_ARG_INFO(0, db)
! 192: ZEND_ARG_INFO(0, ms)
! 193: ZEND_END_ARG_INFO()
! 194:
! 195: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_busy_timeout, 0, 0, 1)
! 196: ZEND_ARG_INFO(0, ms)
! 197: ZEND_END_ARG_INFO()
! 198:
! 199: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_close, 0, 0, 1)
! 200: ZEND_ARG_INFO(0, db)
! 201: ZEND_END_ARG_INFO()
! 202:
! 203: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_unbuffered_query, 0, 0, 2)
! 204: ZEND_ARG_INFO(0, query)
! 205: ZEND_ARG_INFO(0, db)
! 206: ZEND_ARG_INFO(0, result_type)
! 207: ZEND_ARG_INFO(1, error_message)
! 208: ZEND_END_ARG_INFO()
! 209:
! 210: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_unbuffered_query, 0, 0, 1)
! 211: ZEND_ARG_INFO(0, query)
! 212: ZEND_ARG_INFO(0, result_type)
! 213: ZEND_ARG_INFO(1, error_message)
! 214: ZEND_END_ARG_INFO()
! 215:
! 216: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_fetch_column_types, 0, 0, 2)
! 217: ZEND_ARG_INFO(0, table_name)
! 218: ZEND_ARG_INFO(0, db)
! 219: ZEND_ARG_INFO(0, result_type)
! 220: ZEND_END_ARG_INFO()
! 221:
! 222: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_fetch_column_types, 0, 0, 1)
! 223: ZEND_ARG_INFO(0, table_name)
! 224: ZEND_ARG_INFO(0, result_type)
! 225: ZEND_END_ARG_INFO()
! 226:
! 227: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_query, 0, 0, 2)
! 228: ZEND_ARG_INFO(0, query)
! 229: ZEND_ARG_INFO(0, db)
! 230: ZEND_ARG_INFO(0, result_type)
! 231: ZEND_ARG_INFO(1, error_message)
! 232: ZEND_END_ARG_INFO()
! 233:
! 234: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_query, 0, 0, 1)
! 235: ZEND_ARG_INFO(0, query)
! 236: ZEND_ARG_INFO(0, result_type)
! 237: ZEND_ARG_INFO(1, error_message)
! 238: ZEND_END_ARG_INFO()
! 239:
! 240: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_exec, 0, 0, 2)
! 241: ZEND_ARG_INFO(0, query)
! 242: ZEND_ARG_INFO(0, db)
! 243: ZEND_ARG_INFO(1, error_message)
! 244: ZEND_END_ARG_INFO()
! 245:
! 246: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_exec, 0, 0, 1)
! 247: ZEND_ARG_INFO(0, query)
! 248: ZEND_ARG_INFO(1, error_message)
! 249: ZEND_END_ARG_INFO()
! 250:
! 251: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_fetch_all, 0, 0, 1)
! 252: ZEND_ARG_INFO(0, result)
! 253: ZEND_ARG_INFO(0, result_type)
! 254: ZEND_ARG_INFO(0, decode_binary)
! 255: ZEND_END_ARG_INFO()
! 256:
! 257: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_fetch_all, 0, 0, 0)
! 258: ZEND_ARG_INFO(0, result_type)
! 259: ZEND_ARG_INFO(0, decode_binary)
! 260: ZEND_END_ARG_INFO()
! 261:
! 262: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_fetch_array, 0, 0, 1)
! 263: ZEND_ARG_INFO(0, result)
! 264: ZEND_ARG_INFO(0, result_type)
! 265: ZEND_ARG_INFO(0, decode_binary)
! 266: ZEND_END_ARG_INFO()
! 267:
! 268: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_fetch_array, 0, 0, 0)
! 269: ZEND_ARG_INFO(0, result_type)
! 270: ZEND_ARG_INFO(0, decode_binary)
! 271: ZEND_END_ARG_INFO()
! 272:
! 273: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_fetch_object, 0, 0, 1)
! 274: ZEND_ARG_INFO(0, result)
! 275: ZEND_ARG_INFO(0, class_name)
! 276: ZEND_ARG_INFO(0, ctor_params)
! 277: ZEND_ARG_INFO(0, decode_binary)
! 278: ZEND_END_ARG_INFO()
! 279:
! 280: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_fetch_object, 0, 0, 0)
! 281: ZEND_ARG_INFO(0, class_name)
! 282: ZEND_ARG_INFO(0, ctor_params)
! 283: ZEND_ARG_INFO(0, decode_binary)
! 284: ZEND_END_ARG_INFO()
! 285:
! 286: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_array_query, 0, 0, 2)
! 287: ZEND_ARG_INFO(0, db)
! 288: ZEND_ARG_INFO(0, query)
! 289: ZEND_ARG_INFO(0, result_type)
! 290: ZEND_ARG_INFO(0, decode_binary)
! 291: ZEND_END_ARG_INFO()
! 292:
! 293: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_array_query, 0, 0, 1)
! 294: ZEND_ARG_INFO(0, query)
! 295: ZEND_ARG_INFO(0, result_type)
! 296: ZEND_ARG_INFO(0, decode_binary)
! 297: ZEND_END_ARG_INFO()
! 298:
! 299: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_single_query, 0, 0, 2)
! 300: ZEND_ARG_INFO(0, db)
! 301: ZEND_ARG_INFO(0, query)
! 302: ZEND_ARG_INFO(0, first_row_only)
! 303: ZEND_ARG_INFO(0, decode_binary)
! 304: ZEND_END_ARG_INFO()
! 305:
! 306: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_single_query, 0, 0, 1)
! 307: ZEND_ARG_INFO(0, query)
! 308: ZEND_ARG_INFO(0, first_row_only)
! 309: ZEND_ARG_INFO(0, decode_binary)
! 310: ZEND_END_ARG_INFO()
! 311:
! 312: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_fetch_single, 0, 0, 1)
! 313: ZEND_ARG_INFO(0, result)
! 314: ZEND_ARG_INFO(0, decode_binary)
! 315: ZEND_END_ARG_INFO()
! 316:
! 317: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_fetch_single, 0, 0, 0)
! 318: ZEND_ARG_INFO(0, decode_binary)
! 319: ZEND_END_ARG_INFO()
! 320:
! 321: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_current, 0, 0, 1)
! 322: ZEND_ARG_INFO(0, result)
! 323: ZEND_ARG_INFO(0, result_type)
! 324: ZEND_ARG_INFO(0, decode_binary)
! 325: ZEND_END_ARG_INFO()
! 326:
! 327: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_current, 0, 0, 0)
! 328: ZEND_ARG_INFO(0, result_type)
! 329: ZEND_ARG_INFO(0, decode_binary)
! 330: ZEND_END_ARG_INFO()
! 331:
! 332: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_column, 0, 0, 2)
! 333: ZEND_ARG_INFO(0, result)
! 334: ZEND_ARG_INFO(0, index_or_name)
! 335: ZEND_ARG_INFO(0, decode_binary)
! 336: ZEND_END_ARG_INFO()
! 337:
! 338: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_column, 0, 0, 1)
! 339: ZEND_ARG_INFO(0, index_or_name)
! 340: ZEND_ARG_INFO(0, decode_binary)
! 341: ZEND_END_ARG_INFO()
! 342:
! 343: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_libversion, 0)
! 344: ZEND_END_ARG_INFO()
! 345:
! 346: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_libencoding, 0)
! 347: ZEND_END_ARG_INFO()
! 348:
! 349: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_changes, 0, 0, 1)
! 350: ZEND_ARG_INFO(0, db)
! 351: ZEND_END_ARG_INFO()
! 352:
! 353: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_changes, 0)
! 354: ZEND_END_ARG_INFO()
! 355:
! 356: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_last_insert_rowid, 0, 0, 1)
! 357: ZEND_ARG_INFO(0, db)
! 358: ZEND_END_ARG_INFO()
! 359:
! 360: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_last_insert_rowid, 0)
! 361: ZEND_END_ARG_INFO()
! 362:
! 363: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_num_rows, 0, 0, 1)
! 364: ZEND_ARG_INFO(0, result)
! 365: ZEND_END_ARG_INFO()
! 366:
! 367: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_num_rows, 0)
! 368: ZEND_END_ARG_INFO()
! 369:
! 370: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_valid, 0, 0, 1)
! 371: ZEND_ARG_INFO(0, result)
! 372: ZEND_END_ARG_INFO()
! 373:
! 374: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_valid, 0)
! 375: ZEND_END_ARG_INFO()
! 376:
! 377: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_has_prev, 0, 0, 1)
! 378: ZEND_ARG_INFO(0, result)
! 379: ZEND_END_ARG_INFO()
! 380:
! 381: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_has_prev, 0)
! 382: ZEND_END_ARG_INFO()
! 383:
! 384: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_num_fields, 0, 0, 1)
! 385: ZEND_ARG_INFO(0, result)
! 386: ZEND_END_ARG_INFO()
! 387:
! 388: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_num_fields, 0)
! 389: ZEND_END_ARG_INFO()
! 390:
! 391: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_field_name, 0, 0, 2)
! 392: ZEND_ARG_INFO(0, result)
! 393: ZEND_ARG_INFO(0, field_index)
! 394: ZEND_END_ARG_INFO()
! 395:
! 396: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_field_name, 0, 0, 1)
! 397: ZEND_ARG_INFO(0, field_index)
! 398: ZEND_END_ARG_INFO()
! 399:
! 400: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_seek, 0, 0, 2)
! 401: ZEND_ARG_INFO(0, result)
! 402: ZEND_ARG_INFO(0, row)
! 403: ZEND_END_ARG_INFO()
! 404:
! 405: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_seek, 0, 0, 1)
! 406: ZEND_ARG_INFO(0, row)
! 407: ZEND_END_ARG_INFO()
! 408:
! 409: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_rewind, 0, 0, 1)
! 410: ZEND_ARG_INFO(0, result)
! 411: ZEND_END_ARG_INFO()
! 412:
! 413: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_rewind, 0)
! 414: ZEND_END_ARG_INFO()
! 415:
! 416: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_next, 0, 0, 1)
! 417: ZEND_ARG_INFO(0, result)
! 418: ZEND_END_ARG_INFO()
! 419:
! 420: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_next, 0)
! 421: ZEND_END_ARG_INFO()
! 422:
! 423: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_key, 0, 0, 1)
! 424: ZEND_ARG_INFO(0, result)
! 425: ZEND_END_ARG_INFO()
! 426:
! 427: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_key, 0)
! 428: ZEND_END_ARG_INFO()
! 429:
! 430: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_prev, 0, 0, 1)
! 431: ZEND_ARG_INFO(0, result)
! 432: ZEND_END_ARG_INFO()
! 433:
! 434: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_prev, 0)
! 435: ZEND_END_ARG_INFO()
! 436:
! 437: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_escape_string, 0, 0, 1)
! 438: ZEND_ARG_INFO(0, item)
! 439: ZEND_END_ARG_INFO()
! 440:
! 441: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_last_error, 0, 0, 1)
! 442: ZEND_ARG_INFO(0, db)
! 443: ZEND_END_ARG_INFO()
! 444:
! 445: ZEND_BEGIN_ARG_INFO(arginfo_sqlite_method_last_error, 0)
! 446: ZEND_END_ARG_INFO()
! 447:
! 448: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_error_string, 0, 0, 1)
! 449: ZEND_ARG_INFO(0, error_code)
! 450: ZEND_END_ARG_INFO()
! 451:
! 452: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_create_aggregate, 0, 0, 4)
! 453: ZEND_ARG_INFO(0, db)
! 454: ZEND_ARG_INFO(0, funcname)
! 455: ZEND_ARG_INFO(0, step_func)
! 456: ZEND_ARG_INFO(0, finalize_func)
! 457: ZEND_ARG_INFO(0, num_args)
! 458: ZEND_END_ARG_INFO()
! 459:
! 460: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_create_aggregate, 0, 0, 3)
! 461: ZEND_ARG_INFO(0, funcname)
! 462: ZEND_ARG_INFO(0, step_func)
! 463: ZEND_ARG_INFO(0, finalize_func)
! 464: ZEND_ARG_INFO(0, num_args)
! 465: ZEND_END_ARG_INFO()
! 466:
! 467: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_create_function, 0, 0, 3)
! 468: ZEND_ARG_INFO(0, db)
! 469: ZEND_ARG_INFO(0, funcname)
! 470: ZEND_ARG_INFO(0, callback)
! 471: ZEND_ARG_INFO(0, num_args)
! 472: ZEND_END_ARG_INFO()
! 473:
! 474: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_method_create_function, 0, 0, 2)
! 475: ZEND_ARG_INFO(0, funcname)
! 476: ZEND_ARG_INFO(0, callback)
! 477: ZEND_ARG_INFO(0, num_args)
! 478: ZEND_END_ARG_INFO()
! 479:
! 480: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_udf_encode_binary, 0, 0, 1)
! 481: ZEND_ARG_INFO(0, data)
! 482: ZEND_END_ARG_INFO()
! 483:
! 484: ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite_udf_decode_binary, 0, 0, 1)
! 485: ZEND_ARG_INFO(0, data)
! 486: ZEND_END_ARG_INFO()
! 487: /* }}} */
! 488:
! 489: const zend_function_entry sqlite_functions[] = {
! 490: PHP_FE(sqlite_open, arginfo_sqlite_open)
! 491: PHP_FE(sqlite_popen, arginfo_sqlite_popen)
! 492: PHP_FE(sqlite_close, arginfo_sqlite_close)
! 493: PHP_FE(sqlite_query, arginfo_sqlite_query)
! 494: PHP_FE(sqlite_exec, arginfo_sqlite_exec)
! 495: PHP_FE(sqlite_array_query, arginfo_sqlite_array_query)
! 496: PHP_FE(sqlite_single_query, arginfo_sqlite_single_query)
! 497: PHP_FE(sqlite_fetch_array, arginfo_sqlite_fetch_array)
! 498: PHP_FE(sqlite_fetch_object, arginfo_sqlite_fetch_object)
! 499: PHP_FE(sqlite_fetch_single, arginfo_sqlite_fetch_single)
! 500: PHP_FALIAS(sqlite_fetch_string, sqlite_fetch_single, arginfo_sqlite_fetch_single)
! 501: PHP_FE(sqlite_fetch_all, arginfo_sqlite_fetch_all)
! 502: PHP_FE(sqlite_current, arginfo_sqlite_current)
! 503: PHP_FE(sqlite_column, arginfo_sqlite_column)
! 504: PHP_FE(sqlite_libversion, arginfo_sqlite_libversion)
! 505: PHP_FE(sqlite_libencoding, arginfo_sqlite_libencoding)
! 506: PHP_FE(sqlite_changes, arginfo_sqlite_changes)
! 507: PHP_FE(sqlite_last_insert_rowid, arginfo_sqlite_last_insert_rowid)
! 508: PHP_FE(sqlite_num_rows, arginfo_sqlite_num_rows)
! 509: PHP_FE(sqlite_num_fields, arginfo_sqlite_num_fields)
! 510: PHP_FE(sqlite_field_name, arginfo_sqlite_field_name)
! 511: PHP_FE(sqlite_seek, arginfo_sqlite_seek)
! 512: PHP_FE(sqlite_rewind, arginfo_sqlite_rewind)
! 513: PHP_FE(sqlite_next, arginfo_sqlite_next)
! 514: PHP_FE(sqlite_prev, arginfo_sqlite_prev)
! 515: PHP_FE(sqlite_valid, arginfo_sqlite_valid)
! 516: PHP_FALIAS(sqlite_has_more, sqlite_valid, arginfo_sqlite_valid)
! 517: PHP_FE(sqlite_has_prev, arginfo_sqlite_has_prev)
! 518: PHP_FE(sqlite_escape_string, arginfo_sqlite_escape_string)
! 519: PHP_FE(sqlite_busy_timeout, arginfo_sqlite_busy_timeout)
! 520: PHP_FE(sqlite_last_error, arginfo_sqlite_last_error)
! 521: PHP_FE(sqlite_error_string, arginfo_sqlite_error_string)
! 522: PHP_FE(sqlite_unbuffered_query, arginfo_sqlite_unbuffered_query)
! 523: PHP_FE(sqlite_create_aggregate, arginfo_sqlite_create_aggregate)
! 524: PHP_FE(sqlite_create_function, arginfo_sqlite_create_function)
! 525: PHP_FE(sqlite_factory, arginfo_sqlite_factory)
! 526: PHP_FE(sqlite_udf_encode_binary, arginfo_sqlite_udf_encode_binary)
! 527: PHP_FE(sqlite_udf_decode_binary, arginfo_sqlite_udf_decode_binary)
! 528: PHP_FE(sqlite_fetch_column_types, arginfo_sqlite_fetch_column_types)
! 529: {NULL, NULL, NULL}
! 530: };
! 531:
! 532: const zend_function_entry sqlite_funcs_db[] = {
! 533: PHP_ME_MAPPING(__construct, sqlite_open, arginfo_sqlite_open, 0)
! 534: /* PHP_ME_MAPPING(close, sqlite_close, NULL, 0)*/
! 535: PHP_ME_MAPPING(query, sqlite_query, arginfo_sqlite_method_query, 0)
! 536: PHP_ME_MAPPING(queryExec, sqlite_exec, arginfo_sqlite_method_exec, 0)
! 537: PHP_ME_MAPPING(arrayQuery, sqlite_array_query, arginfo_sqlite_method_array_query, 0)
! 538: PHP_ME_MAPPING(singleQuery, sqlite_single_query, arginfo_sqlite_method_single_query, 0)
! 539: PHP_ME_MAPPING(unbufferedQuery, sqlite_unbuffered_query, arginfo_sqlite_method_unbuffered_query, 0)
! 540: PHP_ME_MAPPING(lastInsertRowid, sqlite_last_insert_rowid, arginfo_sqlite_method_last_insert_rowid, 0)
! 541: PHP_ME_MAPPING(changes, sqlite_changes, arginfo_sqlite_method_changes, 0)
! 542: PHP_ME_MAPPING(createAggregate, sqlite_create_aggregate, arginfo_sqlite_method_create_aggregate, 0)
! 543: PHP_ME_MAPPING(createFunction, sqlite_create_function, arginfo_sqlite_method_create_function, 0)
! 544: PHP_ME_MAPPING(busyTimeout, sqlite_busy_timeout, arginfo_sqlite_method_busy_timeout, 0)
! 545: PHP_ME_MAPPING(lastError, sqlite_last_error, arginfo_sqlite_method_last_error, 0)
! 546: PHP_ME_MAPPING(fetchColumnTypes, sqlite_fetch_column_types, arginfo_sqlite_method_fetch_column_types, 0)
! 547: /* PHP_ME_MAPPING(error_string, sqlite_error_string, NULL, 0) static */
! 548: /* PHP_ME_MAPPING(escape_string, sqlite_escape_string, NULL, 0) static */
! 549: {NULL, NULL, NULL}
! 550: };
! 551:
! 552: const zend_function_entry sqlite_funcs_query[] = {
! 553: PHP_ME_MAPPING(fetch, sqlite_fetch_array, arginfo_sqlite_method_fetch_array, 0)
! 554: PHP_ME_MAPPING(fetchObject, sqlite_fetch_object, arginfo_sqlite_method_fetch_object, 0)
! 555: PHP_ME_MAPPING(fetchSingle, sqlite_fetch_single, arginfo_sqlite_method_fetch_single, 0)
! 556: PHP_ME_MAPPING(fetchAll, sqlite_fetch_all, arginfo_sqlite_method_fetch_all, 0)
! 557: PHP_ME_MAPPING(column, sqlite_column, arginfo_sqlite_method_column, 0)
! 558: PHP_ME_MAPPING(numFields, sqlite_num_fields, arginfo_sqlite_method_num_fields, 0)
! 559: PHP_ME_MAPPING(fieldName, sqlite_field_name, arginfo_sqlite_method_field_name, 0)
! 560: /* iterator */
! 561: PHP_ME_MAPPING(current, sqlite_current, arginfo_sqlite_method_current, 0)
! 562: PHP_ME_MAPPING(key, sqlite_key, arginfo_sqlite_method_key, 0)
! 563: PHP_ME_MAPPING(next, sqlite_next, arginfo_sqlite_method_next, 0)
! 564: PHP_ME_MAPPING(valid, sqlite_valid, arginfo_sqlite_method_valid, 0)
! 565: PHP_ME_MAPPING(rewind, sqlite_rewind, arginfo_sqlite_method_rewind, 0)
! 566: /* countable */
! 567: PHP_ME_MAPPING(count, sqlite_num_rows, arginfo_sqlite_method_num_rows, 0)
! 568: /* additional */
! 569: PHP_ME_MAPPING(prev, sqlite_prev, arginfo_sqlite_method_prev, 0)
! 570: PHP_ME_MAPPING(hasPrev, sqlite_has_prev, arginfo_sqlite_method_has_prev, 0)
! 571: PHP_ME_MAPPING(numRows, sqlite_num_rows, arginfo_sqlite_method_num_rows, 0)
! 572: PHP_ME_MAPPING(seek, sqlite_seek, arginfo_sqlite_method_seek, 0)
! 573: {NULL, NULL, NULL}
! 574: };
! 575:
! 576: const zend_function_entry sqlite_funcs_ub_query[] = {
! 577: PHP_ME_MAPPING(fetch, sqlite_fetch_array, arginfo_sqlite_method_fetch_array, 0)
! 578: PHP_ME_MAPPING(fetchObject, sqlite_fetch_object, arginfo_sqlite_method_fetch_object, 0)
! 579: PHP_ME_MAPPING(fetchSingle, sqlite_fetch_single, arginfo_sqlite_method_fetch_single, 0)
! 580: PHP_ME_MAPPING(fetchAll, sqlite_fetch_all, arginfo_sqlite_method_fetch_all, 0)
! 581: PHP_ME_MAPPING(column, sqlite_column, arginfo_sqlite_method_column, 0)
! 582: PHP_ME_MAPPING(numFields, sqlite_num_fields, arginfo_sqlite_method_num_fields, 0)
! 583: PHP_ME_MAPPING(fieldName, sqlite_field_name, arginfo_sqlite_method_field_name, 0)
! 584: /* iterator */
! 585: PHP_ME_MAPPING(current, sqlite_current, arginfo_sqlite_method_current, 0)
! 586: PHP_ME_MAPPING(next, sqlite_next, arginfo_sqlite_method_next, 0)
! 587: PHP_ME_MAPPING(valid, sqlite_valid, arginfo_sqlite_method_valid, 0)
! 588: {NULL, NULL, NULL}
! 589: };
! 590:
! 591: const zend_function_entry sqlite_funcs_exception[] = {
! 592: {NULL, NULL, NULL}
! 593: };
! 594:
! 595: /* Dependancies */
! 596: static const zend_module_dep sqlite_deps[] = {
! 597: #if defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
! 598: ZEND_MOD_REQUIRED("spl")
! 599: #endif
! 600: #if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
! 601: ZEND_MOD_REQUIRED("session")
! 602: #endif
! 603: #ifdef PHP_SQLITE2_HAVE_PDO
! 604: ZEND_MOD_REQUIRED("pdo")
! 605: #endif
! 606: {NULL, NULL, NULL}
! 607: };
! 608:
! 609: zend_module_entry sqlite_module_entry = {
! 610: #if ZEND_MODULE_API_NO >= 20050922
! 611: STANDARD_MODULE_HEADER_EX, NULL,
! 612: sqlite_deps,
! 613: #elif ZEND_MODULE_API_NO >= 20010901
! 614: STANDARD_MODULE_HEADER,
! 615: #endif
! 616: "SQLite",
! 617: sqlite_functions,
! 618: PHP_MINIT(sqlite),
! 619: PHP_MSHUTDOWN(sqlite),
! 620: NULL,
! 621: PHP_RSHUTDOWN(sqlite),
! 622: PHP_MINFO(sqlite),
! 623: #if ZEND_MODULE_API_NO >= 20010901
! 624: PHP_SQLITE_MODULE_VERSION,
! 625: #endif
! 626: #if ZEND_MODULE_API_NO >= 20060613
! 627: PHP_MODULE_GLOBALS(sqlite),
! 628: PHP_GINIT(sqlite),
! 629: NULL,
! 630: NULL,
! 631: STANDARD_MODULE_PROPERTIES_EX
! 632: #else
! 633: STANDARD_MODULE_PROPERTIES
! 634: #endif
! 635: };
! 636:
! 637:
! 638: #ifdef COMPILE_DL_SQLITE
! 639: ZEND_GET_MODULE(sqlite)
! 640: #endif
! 641:
! 642: static int php_sqlite_callback_invalidator(struct php_sqlite_agg_functions *funcs TSRMLS_DC)
! 643: {
! 644: if (!funcs->is_valid) {
! 645: return 0;
! 646: }
! 647:
! 648: if (funcs->step) {
! 649: zval_ptr_dtor(&funcs->step);
! 650: funcs->step = NULL;
! 651: }
! 652:
! 653: if (funcs->fini) {
! 654: zval_ptr_dtor(&funcs->fini);
! 655: funcs->fini = NULL;
! 656: }
! 657:
! 658: funcs->is_valid = 0;
! 659:
! 660: return 0;
! 661: }
! 662:
! 663:
! 664: static void php_sqlite_callback_dtor(void *pDest)
! 665: {
! 666: struct php_sqlite_agg_functions *funcs = (struct php_sqlite_agg_functions*)pDest;
! 667:
! 668: if (funcs->is_valid) {
! 669: TSRMLS_FETCH();
! 670:
! 671: php_sqlite_callback_invalidator(funcs TSRMLS_CC);
! 672: }
! 673: }
! 674:
! 675: static ZEND_RSRC_DTOR_FUNC(php_sqlite_db_dtor)
! 676: {
! 677: if (rsrc->ptr) {
! 678: struct php_sqlite_db *db = (struct php_sqlite_db*)rsrc->ptr;
! 679:
! 680: sqlite_close(db->db);
! 681:
! 682: zend_hash_destroy(&db->callbacks);
! 683:
! 684: pefree(db, db->is_persistent);
! 685:
! 686: rsrc->ptr = NULL;
! 687: }
! 688: }
! 689:
! 690: static void real_result_dtor(struct php_sqlite_result *res TSRMLS_DC)
! 691: {
! 692: int i, j, base;
! 693:
! 694: if (res->vm) {
! 695: sqlite_finalize(res->vm, NULL);
! 696: }
! 697:
! 698: if (res->table) {
! 699: if (!res->buffered && res->nrows) {
! 700: res->nrows = 1; /* only one row is stored */
! 701: }
! 702: for (i = 0; i < res->nrows; i++) {
! 703: base = i * res->ncolumns;
! 704: for (j = 0; j < res->ncolumns; j++) {
! 705: if (res->table[base + j] != NULL) {
! 706: efree(res->table[base + j]);
! 707: }
! 708: }
! 709: }
! 710: efree(res->table);
! 711: }
! 712: if (res->col_names) {
! 713: for (j = 0; j < res->ncolumns; j++) {
! 714: efree(res->col_names[j]);
! 715: }
! 716: efree(res->col_names);
! 717: }
! 718:
! 719: if (res->db) {
! 720: zend_list_delete(res->db->rsrc_id);
! 721: }
! 722: efree(res);
! 723: }
! 724:
! 725: static int _clean_unfinished_results(zend_rsrc_list_entry *le, void *db TSRMLS_DC)
! 726: {
! 727: if (Z_TYPE_P(le) == le_sqlite_result) {
! 728: struct php_sqlite_result *res = (struct php_sqlite_result *)le->ptr;
! 729: if (res->db->rsrc_id == ((struct php_sqlite_db*)db)->rsrc_id) {
! 730: return ZEND_HASH_APPLY_REMOVE;
! 731: }
! 732: }
! 733: return ZEND_HASH_APPLY_KEEP;
! 734: }
! 735:
! 736: static ZEND_RSRC_DTOR_FUNC(php_sqlite_result_dtor)
! 737: {
! 738: struct php_sqlite_result *res = (struct php_sqlite_result *)rsrc->ptr;
! 739: real_result_dtor(res TSRMLS_CC);
! 740: }
! 741:
! 742: static int php_sqlite_forget_persistent_id_numbers(zend_rsrc_list_entry *rsrc TSRMLS_DC)
! 743: {
! 744: struct php_sqlite_db *db = (struct php_sqlite_db*)rsrc->ptr;
! 745:
! 746: if (Z_TYPE_P(rsrc) != le_sqlite_pdb) {
! 747: return 0;
! 748: }
! 749:
! 750: /* prevent bad mojo if someone tries to use a previously registered function in the next request */
! 751: zend_hash_apply(&db->callbacks, (apply_func_t)php_sqlite_callback_invalidator TSRMLS_CC);
! 752:
! 753: db->rsrc_id = FAILURE;
! 754:
! 755: /* don't leave pending commits hanging around */
! 756: sqlite_exec(db->db, "ROLLBACK", NULL, NULL, NULL);
! 757:
! 758: return 0;
! 759: }
! 760:
! 761: PHP_RSHUTDOWN_FUNCTION(sqlite)
! 762: {
! 763: zend_hash_apply(&EG(persistent_list), (apply_func_t)php_sqlite_forget_persistent_id_numbers TSRMLS_CC);
! 764: return SUCCESS;
! 765: }
! 766:
! 767: /* {{{ PHP Function interface */
! 768: static void php_sqlite_generic_function_callback(sqlite_func *func, int argc, const char **argv)
! 769: {
! 770: zval *retval = NULL;
! 771: zval ***zargs = NULL;
! 772: zval funcname;
! 773: int i, res;
! 774: char *callable = NULL, *errbuf=NULL;
! 775: TSRMLS_FETCH();
! 776:
! 777: /* sanity check the args */
! 778: if (argc == 0) {
! 779: sqlite_set_result_error(func, "not enough parameters", -1);
! 780: return;
! 781: }
! 782:
! 783: ZVAL_STRING(&funcname, (char*)argv[0], 1);
! 784:
! 785: if (!zend_make_callable(&funcname, &callable TSRMLS_CC)) {
! 786: spprintf(&errbuf, 0, "function `%s' is not a function name", callable);
! 787: sqlite_set_result_error(func, errbuf, -1);
! 788: efree(errbuf);
! 789: efree(callable);
! 790: zval_dtor(&funcname);
! 791: return;
! 792: }
! 793:
! 794: if (argc > 1) {
! 795: zargs = (zval ***)safe_emalloc((argc - 1), sizeof(zval **), 0);
! 796:
! 797: for (i = 0; i < argc-1; i++) {
! 798: zargs[i] = emalloc(sizeof(zval *));
! 799: MAKE_STD_ZVAL(*zargs[i]);
! 800: ZVAL_STRING(*zargs[i], (char*)argv[i+1], 1);
! 801: }
! 802: }
! 803:
! 804: res = call_user_function_ex(EG(function_table),
! 805: NULL,
! 806: &funcname,
! 807: &retval,
! 808: argc-1,
! 809: zargs,
! 810: 0, NULL TSRMLS_CC);
! 811:
! 812: zval_dtor(&funcname);
! 813:
! 814: if (res == SUCCESS) {
! 815: if (retval == NULL) {
! 816: sqlite_set_result_string(func, NULL, 0);
! 817: } else {
! 818: switch (Z_TYPE_P(retval)) {
! 819: case IS_STRING:
! 820: sqlite_set_result_string(func, Z_STRVAL_P(retval), Z_STRLEN_P(retval));
! 821: break;
! 822: case IS_LONG:
! 823: case IS_BOOL:
! 824: sqlite_set_result_int(func, Z_LVAL_P(retval));
! 825: break;
! 826: case IS_DOUBLE:
! 827: sqlite_set_result_double(func, Z_DVAL_P(retval));
! 828: break;
! 829: case IS_NULL:
! 830: default:
! 831: sqlite_set_result_string(func, NULL, 0);
! 832: }
! 833: }
! 834: } else {
! 835: char *errbuf;
! 836: spprintf(&errbuf, 0, "call_user_function_ex failed for function %s()", callable);
! 837: sqlite_set_result_error(func, errbuf, -1);
! 838: efree(errbuf);
! 839: }
! 840:
! 841: efree(callable);
! 842:
! 843: if (retval) {
! 844: zval_ptr_dtor(&retval);
! 845: }
! 846:
! 847: if (zargs) {
! 848: for (i = 0; i < argc-1; i++) {
! 849: zval_ptr_dtor(zargs[i]);
! 850: efree(zargs[i]);
! 851: }
! 852: efree(zargs);
! 853: }
! 854: }
! 855: /* }}} */
! 856:
! 857: /* {{{ callback for sqlite_create_function */
! 858: static void php_sqlite_function_callback(sqlite_func *func, int argc, const char **argv)
! 859: {
! 860: zval *retval = NULL;
! 861: zval ***zargs = NULL;
! 862: int i, res;
! 863: struct php_sqlite_agg_functions *funcs = sqlite_user_data(func);
! 864: TSRMLS_FETCH();
! 865:
! 866: if (!funcs->is_valid) {
! 867: sqlite_set_result_error(func, "this function has not been correctly defined for this request", -1);
! 868: return;
! 869: }
! 870:
! 871: if (argc > 0) {
! 872: zargs = (zval ***)safe_emalloc(argc, sizeof(zval **), 0);
! 873:
! 874: for (i = 0; i < argc; i++) {
! 875: zargs[i] = emalloc(sizeof(zval *));
! 876: MAKE_STD_ZVAL(*zargs[i]);
! 877:
! 878: if (argv[i] == NULL) {
! 879: ZVAL_NULL(*zargs[i]);
! 880: } else {
! 881: ZVAL_STRING(*zargs[i], (char*)argv[i], 1);
! 882: }
! 883: }
! 884: }
! 885:
! 886: res = call_user_function_ex(EG(function_table),
! 887: NULL,
! 888: funcs->step,
! 889: &retval,
! 890: argc,
! 891: zargs,
! 892: 0, NULL TSRMLS_CC);
! 893:
! 894: if (res == SUCCESS) {
! 895: if (retval == NULL) {
! 896: sqlite_set_result_string(func, NULL, 0);
! 897: } else {
! 898: switch (Z_TYPE_P(retval)) {
! 899: case IS_STRING:
! 900: /* TODO: for binary results, need to encode the string */
! 901: sqlite_set_result_string(func, Z_STRVAL_P(retval), Z_STRLEN_P(retval));
! 902: break;
! 903: case IS_LONG:
! 904: case IS_BOOL:
! 905: sqlite_set_result_int(func, Z_LVAL_P(retval));
! 906: break;
! 907: case IS_DOUBLE:
! 908: sqlite_set_result_double(func, Z_DVAL_P(retval));
! 909: break;
! 910: case IS_NULL:
! 911: default:
! 912: sqlite_set_result_string(func, NULL, 0);
! 913: }
! 914: }
! 915: } else {
! 916: sqlite_set_result_error(func, "call_user_function_ex failed", -1);
! 917: }
! 918:
! 919: if (retval) {
! 920: zval_ptr_dtor(&retval);
! 921: }
! 922:
! 923: if (zargs) {
! 924: for (i = 0; i < argc; i++) {
! 925: zval_ptr_dtor(zargs[i]);
! 926: efree(zargs[i]);
! 927: }
! 928: efree(zargs);
! 929: }
! 930: }
! 931: /* }}} */
! 932:
! 933: /* {{{ callback for sqlite_create_aggregate: step function */
! 934: static void php_sqlite_agg_step_function_callback(sqlite_func *func, int argc, const char **argv)
! 935: {
! 936: zval *retval = NULL;
! 937: zval ***zargs;
! 938: zval **context_p;
! 939: int i, res, zargc;
! 940: struct php_sqlite_agg_functions *funcs = sqlite_user_data(func);
! 941: TSRMLS_FETCH();
! 942:
! 943: if (!funcs->is_valid) {
! 944: sqlite_set_result_error(func, "this function has not been correctly defined for this request", -1);
! 945: return;
! 946: }
! 947:
! 948: /* sanity check the args */
! 949: if (argc < 1) {
! 950: return;
! 951: }
! 952:
! 953: zargc = argc + 1;
! 954: zargs = (zval ***)safe_emalloc(zargc, sizeof(zval **), 0);
! 955:
! 956: /* first arg is always the context zval */
! 957: context_p = (zval **)sqlite_aggregate_context(func, sizeof(*context_p));
! 958:
! 959: if (*context_p == NULL) {
! 960: MAKE_STD_ZVAL(*context_p);
! 961: Z_SET_ISREF_PP(context_p);
! 962: Z_TYPE_PP(context_p) = IS_NULL;
! 963: }
! 964:
! 965: zargs[0] = context_p;
! 966:
! 967: /* copy the other args */
! 968: for (i = 0; i < argc; i++) {
! 969: zargs[i+1] = emalloc(sizeof(zval *));
! 970: MAKE_STD_ZVAL(*zargs[i+1]);
! 971: if (argv[i] == NULL) {
! 972: ZVAL_NULL(*zargs[i+1]);
! 973: } else {
! 974: ZVAL_STRING(*zargs[i+1], (char*)argv[i], 1);
! 975: }
! 976: }
! 977:
! 978: res = call_user_function_ex(EG(function_table),
! 979: NULL,
! 980: funcs->step,
! 981: &retval,
! 982: zargc,
! 983: zargs,
! 984: 0, NULL TSRMLS_CC);
! 985:
! 986: if (res != SUCCESS) {
! 987: php_error_docref(NULL TSRMLS_CC, E_WARNING, "call_user_function_ex failed");
! 988: }
! 989:
! 990: if (retval) {
! 991: zval_ptr_dtor(&retval);
! 992: }
! 993:
! 994: if (zargs) {
! 995: for (i = 1; i < zargc; i++) {
! 996: zval_ptr_dtor(zargs[i]);
! 997: efree(zargs[i]);
! 998: }
! 999: efree(zargs);
! 1000: }
! 1001: }
! 1002: /* }}} */
! 1003:
! 1004: /* {{{ callback for sqlite_create_aggregate: finalize function */
! 1005: static void php_sqlite_agg_fini_function_callback(sqlite_func *func)
! 1006: {
! 1007: zval *retval = NULL;
! 1008: int res;
! 1009: struct php_sqlite_agg_functions *funcs = sqlite_user_data(func);
! 1010: zval **context_p;
! 1011: TSRMLS_FETCH();
! 1012:
! 1013: if (!funcs->is_valid) {
! 1014: sqlite_set_result_error(func, "this function has not been correctly defined for this request", -1);
! 1015: return;
! 1016: }
! 1017:
! 1018: context_p = (zval **)sqlite_aggregate_context(func, sizeof(*context_p));
! 1019:
! 1020: res = call_user_function_ex(EG(function_table),
! 1021: NULL,
! 1022: funcs->fini,
! 1023: &retval,
! 1024: 1,
! 1025: &context_p,
! 1026: 0, NULL TSRMLS_CC);
! 1027:
! 1028: if (res == SUCCESS) {
! 1029: if (retval == NULL) {
! 1030: sqlite_set_result_string(func, NULL, 0);
! 1031: } else {
! 1032: switch (Z_TYPE_P(retval)) {
! 1033: case IS_STRING:
! 1034: /* TODO: for binary results, need to encode the string */
! 1035: sqlite_set_result_string(func, Z_STRVAL_P(retval), Z_STRLEN_P(retval));
! 1036: break;
! 1037: case IS_LONG:
! 1038: case IS_BOOL:
! 1039: sqlite_set_result_int(func, Z_LVAL_P(retval));
! 1040: break;
! 1041: case IS_DOUBLE:
! 1042: sqlite_set_result_double(func, Z_DVAL_P(retval));
! 1043: break;
! 1044: case IS_NULL:
! 1045: default:
! 1046: sqlite_set_result_string(func, NULL, 0);
! 1047: }
! 1048: }
! 1049: } else {
! 1050: sqlite_set_result_error(func, "call_user_function_ex failed", -1);
! 1051: }
! 1052:
! 1053: if (retval) {
! 1054: zval_ptr_dtor(&retval);
! 1055: }
! 1056:
! 1057: zval_ptr_dtor(context_p);
! 1058: }
! 1059: /* }}} */
! 1060:
! 1061: /* {{{ Authorization Callback */
! 1062: static int php_sqlite_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4,
! 1063: const char *arg5, const char *arg6)
! 1064: {
! 1065: switch (access_type) {
! 1066: case SQLITE_COPY:
! 1067: if (strncmp(arg4, ":memory:", sizeof(":memory:") - 1)) {
! 1068: TSRMLS_FETCH();
! 1069: if (PG(safe_mode) && (!php_checkuid(arg4, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
! 1070: return SQLITE_DENY;
! 1071: }
! 1072:
! 1073: if (php_check_open_basedir(arg4 TSRMLS_CC)) {
! 1074: return SQLITE_DENY;
! 1075: }
! 1076: }
! 1077: return SQLITE_OK;
! 1078: #ifdef SQLITE_ATTACH
! 1079: case SQLITE_ATTACH:
! 1080: if (strncmp(arg3, ":memory:", sizeof(":memory:") - 1)) {
! 1081: TSRMLS_FETCH();
! 1082: if (PG(safe_mode) && (!php_checkuid(arg3, NULL, CHECKUID_CHECK_FILE_AND_DIR))) {
! 1083: return SQLITE_DENY;
! 1084: }
! 1085:
! 1086: if (php_check_open_basedir(arg3 TSRMLS_CC)) {
! 1087: return SQLITE_DENY;
! 1088: }
! 1089: }
! 1090: return SQLITE_OK;
! 1091: #endif
! 1092:
! 1093: default:
! 1094: /* access allowed */
! 1095: return SQLITE_OK;
! 1096: }
! 1097: }
! 1098: /* }}} */
! 1099:
! 1100: /* {{{ OO init/structure stuff */
! 1101: #define REGISTER_SQLITE_CLASS(name, c_name, parent) \
! 1102: { \
! 1103: zend_class_entry ce; \
! 1104: INIT_CLASS_ENTRY(ce, "SQLite" # name, sqlite_funcs_ ## c_name); \
! 1105: ce.create_object = sqlite_object_new_ ## c_name; \
! 1106: sqlite_ce_ ## c_name = zend_register_internal_class_ex(&ce, parent, NULL TSRMLS_CC); \
! 1107: memcpy(&sqlite_object_handlers_ ## c_name, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); \
! 1108: sqlite_object_handlers_ ## c_name.clone_obj = NULL; \
! 1109: sqlite_ce_ ## c_name->ce_flags |= ZEND_ACC_FINAL_CLASS; \
! 1110: }
! 1111:
! 1112: zend_class_entry *sqlite_ce_db, *sqlite_ce_exception;
! 1113: zend_class_entry *sqlite_ce_query, *sqlite_ce_ub_query;
! 1114:
! 1115: static zend_object_handlers sqlite_object_handlers_db;
! 1116: static zend_object_handlers sqlite_object_handlers_query;
! 1117: static zend_object_handlers sqlite_object_handlers_ub_query;
! 1118: static zend_object_handlers sqlite_object_handlers_exception;
! 1119:
! 1120: typedef enum {
! 1121: is_db,
! 1122: is_result
! 1123: } sqlite_obj_type;
! 1124:
! 1125: typedef struct _sqlite_object {
! 1126: zend_object std;
! 1127: sqlite_obj_type type;
! 1128: union {
! 1129: struct php_sqlite_db *db;
! 1130: struct php_sqlite_result *res;
! 1131: void *ptr;
! 1132: } u;
! 1133: } sqlite_object;
! 1134:
! 1135: static int sqlite_free_persistent(zend_rsrc_list_entry *le, void *ptr TSRMLS_DC)
! 1136: {
! 1137: return le->ptr == ptr ? ZEND_HASH_APPLY_REMOVE : ZEND_HASH_APPLY_KEEP;
! 1138: }
! 1139:
! 1140: static void sqlite_object_free_storage(void *object TSRMLS_DC)
! 1141: {
! 1142: sqlite_object *intern = (sqlite_object *)object;
! 1143:
! 1144: zend_object_std_dtor(&intern->std TSRMLS_CC);
! 1145:
! 1146: if (intern->u.ptr) {
! 1147: if (intern->type == is_db) {
! 1148: if (intern->u.db->rsrc_id) {
! 1149: zend_list_delete(intern->u.db->rsrc_id);
! 1150: zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) sqlite_free_persistent, &intern->u.ptr TSRMLS_CC);
! 1151: }
! 1152: } else {
! 1153: real_result_dtor(intern->u.res TSRMLS_CC);
! 1154: }
! 1155: }
! 1156:
! 1157: efree(object);
! 1158: }
! 1159:
! 1160: static void sqlite_object_new(zend_class_entry *class_type, zend_object_handlers *handlers, zend_object_value *retval TSRMLS_DC)
! 1161: {
! 1162: sqlite_object *intern;
! 1163: zval *tmp;
! 1164:
! 1165: intern = emalloc(sizeof(sqlite_object));
! 1166: memset(intern, 0, sizeof(sqlite_object));
! 1167:
! 1168: zend_object_std_init(&intern->std, class_type TSRMLS_CC);
! 1169: zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
! 1170:
! 1171: retval->handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) sqlite_object_free_storage, NULL TSRMLS_CC);
! 1172: retval->handlers = handlers;
! 1173: }
! 1174:
! 1175: static zend_object_value sqlite_object_new_db(zend_class_entry *class_type TSRMLS_DC)
! 1176: {
! 1177: zend_object_value retval;
! 1178:
! 1179: sqlite_object_new(class_type, &sqlite_object_handlers_db, &retval TSRMLS_CC);
! 1180: return retval;
! 1181: }
! 1182:
! 1183: static zend_object_value sqlite_object_new_query(zend_class_entry *class_type TSRMLS_DC)
! 1184: {
! 1185: zend_object_value retval;
! 1186:
! 1187: sqlite_object_new(class_type, &sqlite_object_handlers_query, &retval TSRMLS_CC);
! 1188: return retval;
! 1189: }
! 1190:
! 1191: static zend_object_value sqlite_object_new_ub_query(zend_class_entry *class_type TSRMLS_DC)
! 1192: {
! 1193: zend_object_value retval;
! 1194:
! 1195: sqlite_object_new(class_type, &sqlite_object_handlers_ub_query, &retval TSRMLS_CC);
! 1196: return retval;
! 1197: }
! 1198:
! 1199: static zend_object_value sqlite_object_new_exception(zend_class_entry *class_type TSRMLS_DC)
! 1200: {
! 1201: zend_object_value retval;
! 1202:
! 1203: sqlite_object_new(class_type, &sqlite_object_handlers_exception, &retval TSRMLS_CC);
! 1204: return retval;
! 1205: }
! 1206:
! 1207: #define SQLITE_REGISTER_OBJECT(_type, _object, _ptr) \
! 1208: { \
! 1209: sqlite_object *obj; \
! 1210: obj = (sqlite_object*)zend_object_store_get_object(_object TSRMLS_CC); \
! 1211: obj->type = is_ ## _type; \
! 1212: obj->u._type = _ptr; \
! 1213: }
! 1214:
! 1215: static zend_class_entry *sqlite_get_ce_query(const zval *object TSRMLS_DC)
! 1216: {
! 1217: return sqlite_ce_query;
! 1218: }
! 1219:
! 1220: static zend_class_entry *sqlite_get_ce_ub_query(const zval *object TSRMLS_DC)
! 1221: {
! 1222: return sqlite_ce_ub_query;
! 1223: }
! 1224:
! 1225: static zval * sqlite_instanciate(zend_class_entry *pce, zval *object TSRMLS_DC)
! 1226: {
! 1227: if (!object) {
! 1228: ALLOC_ZVAL(object);
! 1229: }
! 1230: Z_TYPE_P(object) = IS_OBJECT;
! 1231: object_init_ex(object, pce);
! 1232: Z_SET_REFCOUNT_P(object, 1);
! 1233: Z_SET_ISREF_P(object);
! 1234: return object;
! 1235: }
! 1236:
! 1237: typedef struct _sqlite_object_iterator {
! 1238: zend_object_iterator it;
! 1239: struct php_sqlite_result *res;
! 1240: zval *value;
! 1241: } sqlite_object_iterator;
! 1242:
! 1243: void sqlite_iterator_dtor(zend_object_iterator *iter TSRMLS_DC)
! 1244: {
! 1245: zval *object = (zval*)((sqlite_object_iterator*)iter)->it.data;
! 1246:
! 1247: if (((sqlite_object_iterator*)iter)->value) {
! 1248: zval_ptr_dtor(&((sqlite_object_iterator*)iter)->value);
! 1249: ((sqlite_object_iterator*)iter)->value = NULL;
! 1250: }
! 1251: zval_ptr_dtor(&object);
! 1252: efree(iter);
! 1253: }
! 1254:
! 1255: void sqlite_iterator_rewind(zend_object_iterator *iter TSRMLS_DC)
! 1256: {
! 1257: struct php_sqlite_result *res = ((sqlite_object_iterator*)iter)->res;
! 1258:
! 1259: if (((sqlite_object_iterator*)iter)->value) {
! 1260: zval_ptr_dtor(&((sqlite_object_iterator*)iter)->value);
! 1261: ((sqlite_object_iterator*)iter)->value = NULL;
! 1262: }
! 1263: if (res) {
! 1264: res->curr_row = 0;
! 1265: }
! 1266: }
! 1267:
! 1268: int sqlite_iterator_valid(zend_object_iterator *iter TSRMLS_DC)
! 1269: {
! 1270: struct php_sqlite_result *res = ((sqlite_object_iterator*)iter)->res;
! 1271:
! 1272: if (res && res->curr_row < res->nrows && res->nrows) { /* curr_row may be -1 */
! 1273: return SUCCESS;
! 1274: } else {
! 1275: return FAILURE;
! 1276: }
! 1277: }
! 1278:
! 1279: void sqlite_iterator_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
! 1280: {
! 1281: struct php_sqlite_result *res = ((sqlite_object_iterator*)iter)->res;
! 1282:
! 1283: *data = &((sqlite_object_iterator*)iter)->value;
! 1284: if (res && !**data) {
! 1285: MAKE_STD_ZVAL(**data);
! 1286: php_sqlite_fetch_array(res, res->mode, 1, 0, **data TSRMLS_CC);
! 1287: }
! 1288:
! 1289: }
! 1290:
! 1291: int sqlite_iterator_get_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC)
! 1292: {
! 1293: struct php_sqlite_result *res = ((sqlite_object_iterator*)iter)->res;
! 1294:
! 1295: *str_key = NULL;
! 1296: *str_key_len = 0;
! 1297: *int_key = res ? res->curr_row : 0;
! 1298: return HASH_KEY_IS_LONG;
! 1299: }
! 1300:
! 1301: void sqlite_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
! 1302: {
! 1303: struct php_sqlite_result *res = ((sqlite_object_iterator*)iter)->res;
! 1304:
! 1305: if (((sqlite_object_iterator*)iter)->value) {
! 1306: zval_ptr_dtor(&((sqlite_object_iterator*)iter)->value);
! 1307: ((sqlite_object_iterator*)iter)->value = NULL;
! 1308: }
! 1309: if (res) {
! 1310: if (!res->buffered && res->vm) {
! 1311: php_sqlite_fetch(res TSRMLS_CC);
! 1312: }
! 1313: if (res->curr_row >= res->nrows) {
! 1314: /* php_error_docref(NULL TSRMLS_CC, E_WARNING, "no more rows available"); */
! 1315: return;
! 1316: }
! 1317:
! 1318: res->curr_row++;
! 1319: }
! 1320: }
! 1321:
! 1322: zend_object_iterator_funcs sqlite_ub_query_iterator_funcs = {
! 1323: sqlite_iterator_dtor,
! 1324: sqlite_iterator_valid,
! 1325: sqlite_iterator_get_current_data,
! 1326: sqlite_iterator_get_current_key,
! 1327: sqlite_iterator_move_forward,
! 1328: NULL
! 1329: };
! 1330:
! 1331: zend_object_iterator_funcs sqlite_query_iterator_funcs = {
! 1332: sqlite_iterator_dtor,
! 1333: sqlite_iterator_valid,
! 1334: sqlite_iterator_get_current_data,
! 1335: sqlite_iterator_get_current_key,
! 1336: sqlite_iterator_move_forward,
! 1337: sqlite_iterator_rewind
! 1338: };
! 1339:
! 1340: zend_object_iterator *sqlite_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
! 1341: {
! 1342: sqlite_object_iterator *iterator = emalloc(sizeof(sqlite_object_iterator));
! 1343:
! 1344: sqlite_object *obj = (sqlite_object*) zend_object_store_get_object(object TSRMLS_CC);
! 1345:
! 1346: if (by_ref) {
! 1347: zend_error(E_RECOVERABLE_ERROR, "An iterator cannot be used with foreach by reference");
! 1348: }
! 1349: Z_ADDREF_P(object);
! 1350: iterator->it.data = (void*)object;
! 1351: iterator->it.funcs = ce->iterator_funcs.funcs;
! 1352: iterator->res = obj->u.res;
! 1353: iterator->value = NULL;
! 1354: return (zend_object_iterator*)iterator;
! 1355: }
! 1356: /* }}} */
! 1357:
! 1358: static PHP_GINIT_FUNCTION(sqlite)
! 1359: {
! 1360: sqlite_globals->assoc_case = 0;
! 1361: }
! 1362:
! 1363: PHP_MINIT_FUNCTION(sqlite)
! 1364: {
! 1365: REGISTER_SQLITE_CLASS(Database, db, NULL);
! 1366: REGISTER_SQLITE_CLASS(Result, query, NULL);
! 1367: REGISTER_SQLITE_CLASS(Unbuffered, ub_query, NULL);
! 1368: #if defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
! 1369: REGISTER_SQLITE_CLASS(Exception, exception, spl_ce_RuntimeException);
! 1370: #else
! 1371: REGISTER_SQLITE_CLASS(Exception, exception, zend_exception_get_default(TSRMLS_C));
! 1372: #endif
! 1373:
! 1374: sqlite_ce_db->ce_flags &= ~ZEND_ACC_FINAL_CLASS;
! 1375: sqlite_ce_db->constructor->common.fn_flags |= ZEND_ACC_FINAL;
! 1376:
! 1377: sqlite_object_handlers_query.get_class_entry = sqlite_get_ce_query;
! 1378: sqlite_object_handlers_ub_query.get_class_entry = sqlite_get_ce_ub_query;
! 1379: sqlite_object_handlers_ub_query.count_elements = sqlite_count_elements;
! 1380:
! 1381: sqlite_ce_ub_query->get_iterator = sqlite_get_iterator;
! 1382: sqlite_ce_ub_query->iterator_funcs.funcs = &sqlite_ub_query_iterator_funcs;
! 1383:
! 1384: #if defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
! 1385: zend_class_implements(sqlite_ce_query TSRMLS_CC, 2, zend_ce_iterator, spl_ce_Countable);
! 1386: #else
! 1387: zend_class_implements(sqlite_ce_query TSRMLS_CC, 1, zend_ce_iterator);
! 1388: #endif
! 1389: sqlite_ce_query->get_iterator = sqlite_get_iterator;
! 1390: sqlite_ce_query->iterator_funcs.funcs = &sqlite_query_iterator_funcs;
! 1391:
! 1392: REGISTER_INI_ENTRIES();
! 1393:
! 1394: #if HAVE_PHP_SESSION && !defined(COMPILE_DL_SESSION)
! 1395: php_session_register_module(ps_sqlite_ptr);
! 1396: #endif
! 1397:
! 1398: le_sqlite_db = zend_register_list_destructors_ex(php_sqlite_db_dtor, NULL, "sqlite database", module_number);
! 1399: le_sqlite_pdb = zend_register_list_destructors_ex(NULL, php_sqlite_db_dtor, "sqlite database (persistent)", module_number);
! 1400: le_sqlite_result = zend_register_list_destructors_ex(php_sqlite_result_dtor, NULL, "sqlite result", module_number);
! 1401:
! 1402: REGISTER_LONG_CONSTANT("SQLITE_BOTH", PHPSQLITE_BOTH, CONST_CS|CONST_PERSISTENT);
! 1403: REGISTER_LONG_CONSTANT("SQLITE_NUM", PHPSQLITE_NUM, CONST_CS|CONST_PERSISTENT);
! 1404: REGISTER_LONG_CONSTANT("SQLITE_ASSOC", PHPSQLITE_ASSOC, CONST_CS|CONST_PERSISTENT);
! 1405:
! 1406: REGISTER_LONG_CONSTANT("SQLITE_OK", SQLITE_OK, CONST_CS|CONST_PERSISTENT);
! 1407: REGISTER_LONG_CONSTANT("SQLITE_ERROR", SQLITE_ERROR, CONST_CS|CONST_PERSISTENT);
! 1408: REGISTER_LONG_CONSTANT("SQLITE_INTERNAL", SQLITE_INTERNAL, CONST_CS|CONST_PERSISTENT);
! 1409: REGISTER_LONG_CONSTANT("SQLITE_PERM", SQLITE_PERM, CONST_CS|CONST_PERSISTENT);
! 1410: REGISTER_LONG_CONSTANT("SQLITE_ABORT", SQLITE_ABORT, CONST_CS|CONST_PERSISTENT);
! 1411: REGISTER_LONG_CONSTANT("SQLITE_BUSY", SQLITE_BUSY, CONST_CS|CONST_PERSISTENT);
! 1412: REGISTER_LONG_CONSTANT("SQLITE_LOCKED", SQLITE_LOCKED, CONST_CS|CONST_PERSISTENT);
! 1413: REGISTER_LONG_CONSTANT("SQLITE_NOMEM", SQLITE_NOMEM, CONST_CS|CONST_PERSISTENT);
! 1414: REGISTER_LONG_CONSTANT("SQLITE_READONLY", SQLITE_READONLY, CONST_CS|CONST_PERSISTENT);
! 1415: REGISTER_LONG_CONSTANT("SQLITE_INTERRUPT", SQLITE_INTERRUPT, CONST_CS|CONST_PERSISTENT);
! 1416: REGISTER_LONG_CONSTANT("SQLITE_IOERR", SQLITE_IOERR, CONST_CS|CONST_PERSISTENT);
! 1417: REGISTER_LONG_CONSTANT("SQLITE_CORRUPT", SQLITE_CORRUPT, CONST_CS|CONST_PERSISTENT);
! 1418: REGISTER_LONG_CONSTANT("SQLITE_NOTFOUND", SQLITE_NOTFOUND, CONST_CS|CONST_PERSISTENT);
! 1419: REGISTER_LONG_CONSTANT("SQLITE_FULL", SQLITE_FULL, CONST_CS|CONST_PERSISTENT);
! 1420: REGISTER_LONG_CONSTANT("SQLITE_CANTOPEN", SQLITE_CANTOPEN, CONST_CS|CONST_PERSISTENT);
! 1421: REGISTER_LONG_CONSTANT("SQLITE_PROTOCOL", SQLITE_PROTOCOL, CONST_CS|CONST_PERSISTENT);
! 1422: REGISTER_LONG_CONSTANT("SQLITE_EMPTY", SQLITE_EMPTY, CONST_CS|CONST_PERSISTENT);
! 1423: REGISTER_LONG_CONSTANT("SQLITE_SCHEMA", SQLITE_SCHEMA, CONST_CS|CONST_PERSISTENT);
! 1424: REGISTER_LONG_CONSTANT("SQLITE_TOOBIG", SQLITE_TOOBIG, CONST_CS|CONST_PERSISTENT);
! 1425: REGISTER_LONG_CONSTANT("SQLITE_CONSTRAINT", SQLITE_CONSTRAINT, CONST_CS|CONST_PERSISTENT);
! 1426: REGISTER_LONG_CONSTANT("SQLITE_MISMATCH", SQLITE_MISMATCH, CONST_CS|CONST_PERSISTENT);
! 1427: REGISTER_LONG_CONSTANT("SQLITE_MISUSE", SQLITE_MISUSE, CONST_CS|CONST_PERSISTENT);
! 1428: REGISTER_LONG_CONSTANT("SQLITE_NOLFS", SQLITE_NOLFS, CONST_CS|CONST_PERSISTENT);
! 1429: REGISTER_LONG_CONSTANT("SQLITE_AUTH", SQLITE_AUTH, CONST_CS|CONST_PERSISTENT);
! 1430: REGISTER_LONG_CONSTANT("SQLITE_NOTADB", SQLITE_NOTADB, CONST_CS|CONST_PERSISTENT);
! 1431: #ifdef SQLITE_FORMAT
! 1432: REGISTER_LONG_CONSTANT("SQLITE_FORMAT", SQLITE_FORMAT, CONST_CS|CONST_PERSISTENT);
! 1433: #endif
! 1434: REGISTER_LONG_CONSTANT("SQLITE_ROW", SQLITE_ROW, CONST_CS|CONST_PERSISTENT);
! 1435: REGISTER_LONG_CONSTANT("SQLITE_DONE", SQLITE_DONE, CONST_CS|CONST_PERSISTENT);
! 1436:
! 1437: #ifdef PHP_SQLITE2_HAVE_PDO
! 1438: if (FAILURE == php_pdo_register_driver(&pdo_sqlite2_driver)) {
! 1439: return FAILURE;
! 1440: }
! 1441: #endif
! 1442:
! 1443: return SUCCESS;
! 1444: }
! 1445:
! 1446: PHP_MSHUTDOWN_FUNCTION(sqlite)
! 1447: {
! 1448: UNREGISTER_INI_ENTRIES();
! 1449:
! 1450: #ifdef PHP_SQLITE2_HAVE_PDO
! 1451: php_pdo_unregister_driver(&pdo_sqlite2_driver);
! 1452: #endif
! 1453:
! 1454: return SUCCESS;
! 1455: }
! 1456:
! 1457: PHP_MINFO_FUNCTION(sqlite)
! 1458: {
! 1459: php_info_print_table_start();
! 1460: php_info_print_table_header(2, "SQLite support", "enabled");
! 1461: php_info_print_table_row(2, "PECL Module version", PHP_SQLITE_MODULE_VERSION " $Id: sqlite.c 321634 2012-01-01 13:15:04Z felipe $");
! 1462: php_info_print_table_row(2, "SQLite Library", sqlite_libversion());
! 1463: php_info_print_table_row(2, "SQLite Encoding", sqlite_libencoding());
! 1464: php_info_print_table_end();
! 1465:
! 1466: DISPLAY_INI_ENTRIES();
! 1467: }
! 1468:
! 1469: static struct php_sqlite_db *php_sqlite_open(char *filename, int mode, char *persistent_id, zval *return_value, zval *errmsg, zval *object TSRMLS_DC)
! 1470: {
! 1471: char *errtext = NULL;
! 1472: sqlite *sdb = NULL;
! 1473: struct php_sqlite_db *db = NULL;
! 1474:
! 1475: sdb = sqlite_open(filename, mode, &errtext);
! 1476:
! 1477: if (sdb == NULL) {
! 1478:
! 1479: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 1480:
! 1481: if (errmsg) {
! 1482: ZVAL_STRING(errmsg, errtext, 1);
! 1483: }
! 1484:
! 1485: sqlite_freemem(errtext);
! 1486:
! 1487: /* if object is not an object then we're called from the factory() function */
! 1488: if (object && Z_TYPE_P(object) != IS_OBJECT) {
! 1489: RETVAL_NULL();
! 1490: } else {
! 1491: RETVAL_FALSE;
! 1492: }
! 1493: return NULL;
! 1494: }
! 1495:
! 1496: db = (struct php_sqlite_db *)pemalloc(sizeof(struct php_sqlite_db), persistent_id ? 1 : 0);
! 1497: db->is_persistent = persistent_id ? 1 : 0;
! 1498: db->last_err_code = SQLITE_OK;
! 1499: db->db = sdb;
! 1500:
! 1501: zend_hash_init(&db->callbacks, 0, NULL, php_sqlite_callback_dtor, db->is_persistent);
! 1502:
! 1503: /* register the PHP functions */
! 1504: sqlite_create_function(sdb, "php", -1, php_sqlite_generic_function_callback, 0);
! 1505:
! 1506: /* set default busy handler; keep retrying up until 1 minute has passed,
! 1507: * then fail with a busy status code */
! 1508: sqlite_busy_timeout(sdb, 60000);
! 1509:
! 1510: /* authorizer hook so we can enforce safe mode
! 1511: * Note: the declaration of php_sqlite_authorizer is correct for 2.8.2 of libsqlite,
! 1512: * and IS backwards binary compatible with earlier versions */
! 1513: if (PG(safe_mode) || (PG(open_basedir) && *PG(open_basedir))) {
! 1514: sqlite_set_authorizer(sdb, php_sqlite_authorizer, NULL);
! 1515: }
! 1516:
! 1517: db->rsrc_id = ZEND_REGISTER_RESOURCE(object ? NULL : return_value, db, persistent_id ? le_sqlite_pdb : le_sqlite_db);
! 1518: if (object) {
! 1519: /* if object is not an object then we're called from the factory() function */
! 1520: if (Z_TYPE_P(object) != IS_OBJECT) {
! 1521: sqlite_instanciate(sqlite_ce_db, object TSRMLS_CC);
! 1522: }
! 1523: /* and now register the object */
! 1524: SQLITE_REGISTER_OBJECT(db, object, db)
! 1525: }
! 1526:
! 1527: if (persistent_id) {
! 1528: zend_rsrc_list_entry le;
! 1529:
! 1530: Z_TYPE(le) = le_sqlite_pdb;
! 1531: le.ptr = db;
! 1532:
! 1533: if (FAILURE == zend_hash_update(&EG(persistent_list), persistent_id,
! 1534: strlen(persistent_id)+1,
! 1535: (void *)&le, sizeof(le), NULL)) {
! 1536: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to register persistent resource");
! 1537: }
! 1538: }
! 1539:
! 1540: return db;
! 1541: }
! 1542:
! 1543: /* {{{ proto resource sqlite_popen(string filename [, int mode [, string &error_message]])
! 1544: Opens a persistent handle to a SQLite database. Will create the database if it does not exist. */
! 1545: PHP_FUNCTION(sqlite_popen)
! 1546: {
! 1547: long mode = 0666;
! 1548: char *filename, *fullpath, *hashkey;
! 1549: int filename_len, hashkeylen;
! 1550: zval *errmsg = NULL;
! 1551: struct php_sqlite_db *db = NULL;
! 1552: zend_rsrc_list_entry *le;
! 1553:
! 1554: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lz/",
! 1555: &filename, &filename_len, &mode, &errmsg)) {
! 1556: return;
! 1557: }
! 1558: if (errmsg) {
! 1559: zval_dtor(errmsg);
! 1560: ZVAL_NULL(errmsg);
! 1561: }
! 1562:
! 1563: if (strlen(filename) != filename_len) {
! 1564: RETURN_FALSE;
! 1565: }
! 1566: if (strncmp(filename, ":memory:", sizeof(":memory:") - 1)) {
! 1567: /* resolve the fully-qualified path name to use as the hash key */
! 1568: if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) {
! 1569: RETURN_FALSE;
! 1570: }
! 1571:
! 1572: if ((PG(safe_mode) && (!php_checkuid(fullpath, NULL, CHECKUID_CHECK_FILE_AND_DIR))) ||
! 1573: php_check_open_basedir(fullpath TSRMLS_CC)) {
! 1574: efree(fullpath);
! 1575: RETURN_FALSE;
! 1576: }
! 1577: } else {
! 1578: fullpath = estrndup(filename, filename_len);
! 1579: }
! 1580:
! 1581: hashkeylen = spprintf(&hashkey, 0, "sqlite_pdb_%s:%ld", fullpath, mode);
! 1582:
! 1583: /* do we have an existing persistent connection ? */
! 1584: if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, hashkeylen+1, (void*)&le)) {
! 1585: if (Z_TYPE_P(le) == le_sqlite_pdb) {
! 1586: db = (struct php_sqlite_db*)le->ptr;
! 1587:
! 1588: if (db->rsrc_id == FAILURE) {
! 1589: /* give it a valid resource id for this request */
! 1590: db->rsrc_id = ZEND_REGISTER_RESOURCE(return_value, db, le_sqlite_pdb);
! 1591: } else {
! 1592: int type;
! 1593: /* sanity check to ensure that the resource is still a valid regular resource
! 1594: * number */
! 1595: if (zend_list_find(db->rsrc_id, &type) == db) {
! 1596: /* already accessed this request; map it */
! 1597: zend_list_addref(db->rsrc_id);
! 1598: ZVAL_RESOURCE(return_value, db->rsrc_id);
! 1599: } else {
! 1600: db->rsrc_id = ZEND_REGISTER_RESOURCE(return_value, db, le_sqlite_pdb);
! 1601: }
! 1602: }
! 1603:
! 1604: /* all set */
! 1605: goto done;
! 1606: }
! 1607:
! 1608: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Some other type of persistent resource is using this hash key!?");
! 1609: RETVAL_FALSE;
! 1610: goto done;
! 1611: }
! 1612:
! 1613: /* now we need to open the database */
! 1614: php_sqlite_open(fullpath, (int)mode, hashkey, return_value, errmsg, NULL TSRMLS_CC);
! 1615: done:
! 1616: efree(fullpath);
! 1617: efree(hashkey);
! 1618: }
! 1619: /* }}} */
! 1620:
! 1621: /* {{{ proto resource sqlite_open(string filename [, int mode [, string &error_message]])
! 1622: Opens a SQLite database. Will create the database if it does not exist. */
! 1623: PHP_FUNCTION(sqlite_open)
! 1624: {
! 1625: long mode = 0666;
! 1626: char *filename, *fullpath = NULL;
! 1627: int filename_len;
! 1628: zval *errmsg = NULL;
! 1629: zval *object = getThis();
! 1630: zend_error_handling error_handling;
! 1631:
! 1632: zend_replace_error_handling(object ? EH_THROW : EH_NORMAL, sqlite_ce_exception, &error_handling TSRMLS_CC);
! 1633: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lz/",
! 1634: &filename, &filename_len, &mode, &errmsg)) {
! 1635: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1636: return;
! 1637: }
! 1638: if (errmsg) {
! 1639: zval_dtor(errmsg);
! 1640: ZVAL_NULL(errmsg);
! 1641: }
! 1642:
! 1643: if (strlen(filename) != filename_len) {
! 1644: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1645: RETURN_FALSE;
! 1646: }
! 1647:
! 1648: if (strncmp(filename, ":memory:", sizeof(":memory:") - 1)) {
! 1649: /* resolve the fully-qualified path name to use as the hash key */
! 1650: if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) {
! 1651: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1652: if (object) {
! 1653: RETURN_NULL();
! 1654: } else {
! 1655: RETURN_FALSE;
! 1656: }
! 1657: }
! 1658:
! 1659: if ((PG(safe_mode) && (!php_checkuid(fullpath, NULL, CHECKUID_CHECK_FILE_AND_DIR))) ||
! 1660: php_check_open_basedir(fullpath TSRMLS_CC)) {
! 1661: efree(fullpath);
! 1662: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1663: if (object) {
! 1664: RETURN_NULL();
! 1665: } else {
! 1666: RETURN_FALSE;
! 1667: }
! 1668: }
! 1669: }
! 1670:
! 1671: php_sqlite_open(fullpath ? fullpath : filename, (int)mode, NULL, return_value, errmsg, object TSRMLS_CC);
! 1672:
! 1673: if (fullpath) {
! 1674: efree(fullpath);
! 1675: }
! 1676: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1677: }
! 1678: /* }}} */
! 1679:
! 1680: /* {{{ proto object sqlite_factory(string filename [, int mode [, string &error_message]])
! 1681: Opens a SQLite database and creates an object for it. Will create the database if it does not exist. */
! 1682: PHP_FUNCTION(sqlite_factory)
! 1683: {
! 1684: long mode = 0666;
! 1685: char *filename, *fullpath = NULL;
! 1686: int filename_len;
! 1687: zval *errmsg = NULL;
! 1688: zend_error_handling error_handling;
! 1689:
! 1690: zend_replace_error_handling(EH_THROW, sqlite_ce_exception, &error_handling TSRMLS_CC);
! 1691: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lz/",
! 1692: &filename, &filename_len, &mode, &errmsg)) {
! 1693: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1694: RETURN_NULL();
! 1695: }
! 1696: if (errmsg) {
! 1697: zval_dtor(errmsg);
! 1698: ZVAL_NULL(errmsg);
! 1699: }
! 1700:
! 1701: if (strlen(filename) != filename_len) {
! 1702: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1703: RETURN_FALSE;
! 1704: }
! 1705:
! 1706: if (strncmp(filename, ":memory:", sizeof(":memory:") - 1)) {
! 1707: /* resolve the fully-qualified path name to use as the hash key */
! 1708: if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) {
! 1709: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1710: RETURN_NULL();
! 1711: }
! 1712:
! 1713: if ((PG(safe_mode) && (!php_checkuid(fullpath, NULL, CHECKUID_CHECK_FILE_AND_DIR))) ||
! 1714: php_check_open_basedir(fullpath TSRMLS_CC)) {
! 1715: efree(fullpath);
! 1716: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1717: RETURN_NULL();
! 1718: }
! 1719: }
! 1720:
! 1721: php_sqlite_open(fullpath ? fullpath : filename, (int)mode, NULL, return_value, errmsg, return_value TSRMLS_CC);
! 1722: if (fullpath) {
! 1723: efree(fullpath);
! 1724: }
! 1725: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1726: }
! 1727: /* }}} */
! 1728:
! 1729: /* {{{ proto void sqlite_busy_timeout(resource db, int ms)
! 1730: Set busy timeout duration. If ms <= 0, all busy handlers are disabled. */
! 1731: PHP_FUNCTION(sqlite_busy_timeout)
! 1732: {
! 1733: zval *zdb;
! 1734: struct php_sqlite_db *db;
! 1735: long ms;
! 1736: zval *object = getThis();
! 1737:
! 1738: if (object) {
! 1739: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ms)) {
! 1740: return;
! 1741: }
! 1742: DB_FROM_OBJECT(db, object);
! 1743: } else {
! 1744: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zdb, &ms)) {
! 1745: return;
! 1746: }
! 1747: DB_FROM_ZVAL(db, &zdb);
! 1748: }
! 1749:
! 1750: sqlite_busy_timeout(db->db, ms);
! 1751: }
! 1752: /* }}} */
! 1753:
! 1754: /* {{{ proto void sqlite_close(resource db)
! 1755: Closes an open sqlite database. */
! 1756: PHP_FUNCTION(sqlite_close)
! 1757: {
! 1758: zval *zdb;
! 1759: struct php_sqlite_db *db;
! 1760: zval *object = getThis();
! 1761:
! 1762: if (object) {
! 1763: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Ignored, you must destruct the object instead");
! 1764: } else {
! 1765: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zdb)) {
! 1766: return;
! 1767: }
! 1768: DB_FROM_ZVAL(db, &zdb);
! 1769: }
! 1770:
! 1771: zend_hash_apply_with_argument(&EG(regular_list),
! 1772: (apply_func_arg_t) _clean_unfinished_results,
! 1773: db TSRMLS_CC);
! 1774:
! 1775: zend_list_delete(Z_RESVAL_P(zdb));
! 1776: }
! 1777: /* }}} */
! 1778:
! 1779: /* {{{ php_sqlite_fetch */
! 1780: static int php_sqlite_fetch(struct php_sqlite_result *rres TSRMLS_DC)
! 1781: {
! 1782: const char **rowdata, **colnames;
! 1783: int ret, i, base;
! 1784: char *errtext = NULL;
! 1785:
! 1786: next_row:
! 1787: ret = sqlite_step(rres->vm, &rres->ncolumns, &rowdata, &colnames);
! 1788: if (!rres->nrows) {
! 1789: /* first row - lets copy the column names */
! 1790: rres->col_names = safe_emalloc(rres->ncolumns, sizeof(char *), 0);
! 1791: for (i = 0; i < rres->ncolumns; i++) {
! 1792: rres->col_names[i] = estrdup((char*)colnames[i]);
! 1793:
! 1794: if (SQLITE_G(assoc_case) == 1) {
! 1795: php_sqlite_strtoupper(rres->col_names[i]);
! 1796: } else if (SQLITE_G(assoc_case) == 2) {
! 1797: php_sqlite_strtolower(rres->col_names[i]);
! 1798: }
! 1799: }
! 1800: if (!rres->buffered) {
! 1801: /* non buffered mode - also fetch memory for on single row */
! 1802: rres->table = safe_emalloc(rres->ncolumns, sizeof(char *), 0);
! 1803: }
! 1804: }
! 1805:
! 1806: switch (ret) {
! 1807: case SQLITE_ROW:
! 1808: if (rres->buffered) {
! 1809: /* add the row to our collection */
! 1810: if (rres->nrows + 1 >= rres->alloc_rows) {
! 1811: rres->alloc_rows = rres->alloc_rows ? rres->alloc_rows * 2 : 16;
! 1812: rres->table = safe_erealloc(rres->table, rres->alloc_rows, rres->ncolumns*sizeof(char *), 0);
! 1813: }
! 1814: base = rres->nrows * rres->ncolumns;
! 1815: for (i = 0; i < rres->ncolumns; i++) {
! 1816: if (rowdata[i]) {
! 1817: rres->table[base + i] = estrdup(rowdata[i]);
! 1818: } else {
! 1819: rres->table[base + i] = NULL;
! 1820: }
! 1821: }
! 1822: rres->nrows++;
! 1823: goto next_row;
! 1824: } else {
! 1825: /* non buffered: only fetch one row but first free data if not first row */
! 1826: if (rres->nrows++) {
! 1827: for (i = 0; i < rres->ncolumns; i++) {
! 1828: if (rres->table[i]) {
! 1829: efree(rres->table[i]);
! 1830: }
! 1831: }
! 1832: }
! 1833: for (i = 0; i < rres->ncolumns; i++) {
! 1834: if (rowdata[i]) {
! 1835: rres->table[i] = estrdup(rowdata[i]);
! 1836: } else {
! 1837: rres->table[i] = NULL;
! 1838: }
! 1839: }
! 1840: }
! 1841: ret = SQLITE_OK;
! 1842: break;
! 1843:
! 1844: case SQLITE_BUSY:
! 1845: case SQLITE_ERROR:
! 1846: case SQLITE_MISUSE:
! 1847: case SQLITE_DONE:
! 1848: default:
! 1849: if (rres->vm) {
! 1850: ret = sqlite_finalize(rres->vm, &errtext);
! 1851: }
! 1852: rres->vm = NULL;
! 1853: if (ret != SQLITE_OK) {
! 1854: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 1855: sqlite_freemem(errtext);
! 1856: }
! 1857: break;
! 1858: }
! 1859: rres->db->last_err_code = ret;
! 1860:
! 1861: return ret;
! 1862: }
! 1863: /* }}} */
! 1864:
! 1865: /* {{{ sqlite_query */
! 1866: void sqlite_query(zval *object, struct php_sqlite_db *db, char *sql, long sql_len, int mode, int buffered, zval *return_value, struct php_sqlite_result **prres, zval *errmsg TSRMLS_DC)
! 1867: {
! 1868: struct php_sqlite_result res, *rres;
! 1869: int ret;
! 1870: char *errtext = NULL;
! 1871: const char *tail;
! 1872:
! 1873: memset(&res, 0, sizeof(res));
! 1874: res.buffered = buffered;
! 1875: res.mode = mode;
! 1876:
! 1877: ret = sqlite_compile(db->db, sql, &tail, &res.vm, &errtext);
! 1878: db->last_err_code = ret;
! 1879:
! 1880: if (ret != SQLITE_OK) {
! 1881: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 1882: if (errmsg) {
! 1883: ZVAL_STRING(errmsg, errtext, 1);
! 1884: }
! 1885: sqlite_freemem(errtext);
! 1886: goto terminate;
! 1887: } else if (!res.vm) { /* empty query */
! 1888: terminate:
! 1889: if (return_value) {
! 1890: RETURN_FALSE;
! 1891: } else {
! 1892: return;
! 1893: }
! 1894: }
! 1895:
! 1896: if (!prres) {
! 1897: rres = NULL;
! 1898: prres = &rres;
! 1899: }
! 1900: if (!*prres) {
! 1901: *prres = (struct php_sqlite_result*)emalloc(sizeof(**prres));
! 1902: }
! 1903: memcpy(*prres, &res, sizeof(**prres));
! 1904: (*prres)->db = db;
! 1905: zend_list_addref(db->rsrc_id);
! 1906:
! 1907:
! 1908: /* now the result set is ready for stepping: get first row */
! 1909: if (php_sqlite_fetch((*prres) TSRMLS_CC) != SQLITE_OK) {
! 1910: real_result_dtor((*prres) TSRMLS_CC);
! 1911: *prres = NULL;
! 1912: if (return_value) {
! 1913: RETURN_FALSE;
! 1914: } else {
! 1915: return;
! 1916: }
! 1917: }
! 1918:
! 1919: (*prres)->curr_row = 0;
! 1920:
! 1921: if (object) {
! 1922: sqlite_object *obj;
! 1923: if (buffered) {
! 1924: sqlite_instanciate(sqlite_ce_query, return_value TSRMLS_CC);
! 1925: } else {
! 1926: sqlite_instanciate(sqlite_ce_ub_query, return_value TSRMLS_CC);
! 1927: }
! 1928: obj = (sqlite_object *) zend_object_store_get_object(return_value TSRMLS_CC);
! 1929: obj->type = is_result;
! 1930: obj->u.res = (*prres);
! 1931: } else if (return_value) {
! 1932: ZEND_REGISTER_RESOURCE(object ? NULL : return_value, (*prres), le_sqlite_result);
! 1933: }
! 1934: }
! 1935: /* }}} */
! 1936:
! 1937: /* {{{ proto resource sqlite_unbuffered_query(string query, resource db [ , int result_type [, string &error_message]])
! 1938: Executes a query that does not prefetch and buffer all data. */
! 1939: PHP_FUNCTION(sqlite_unbuffered_query)
! 1940: {
! 1941: zval *zdb;
! 1942: struct php_sqlite_db *db;
! 1943: char *sql;
! 1944: int sql_len;
! 1945: long mode = PHPSQLITE_BOTH;
! 1946: char *errtext = NULL;
! 1947: zval *errmsg = NULL;
! 1948: zval *object = getThis();
! 1949:
! 1950: if (object) {
! 1951: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lz/", &sql, &sql_len, &mode, &errmsg)) {
! 1952: return;
! 1953: }
! 1954: DB_FROM_OBJECT(db, object);
! 1955: } else {
! 1956: if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
! 1957: ZEND_NUM_ARGS() TSRMLS_CC, "sr|lz/", &sql, &sql_len, &zdb, &mode, &errmsg) &&
! 1958: FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|lz/", &zdb, &sql, &sql_len, &mode, &errmsg)) {
! 1959: return;
! 1960: }
! 1961: DB_FROM_ZVAL(db, &zdb);
! 1962: }
! 1963:
! 1964: if (errmsg) {
! 1965: zval_dtor(errmsg);
! 1966: ZVAL_NULL(errmsg);
! 1967: }
! 1968:
! 1969: PHP_SQLITE_EMPTY_QUERY;
! 1970:
! 1971: /* avoid doing work if we can */
! 1972: if (!return_value_used) {
! 1973: db->last_err_code = sqlite_exec(db->db, sql, NULL, NULL, &errtext);
! 1974:
! 1975: if (db->last_err_code != SQLITE_OK) {
! 1976: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 1977: if (errmsg) {
! 1978: ZVAL_STRING(errmsg, errtext, 1);
! 1979: }
! 1980: sqlite_freemem(errtext);
! 1981: }
! 1982: return;
! 1983: }
! 1984:
! 1985: sqlite_query(object, db, sql, sql_len, (int)mode, 0, return_value, NULL, errmsg TSRMLS_CC);
! 1986: }
! 1987: /* }}} */
! 1988:
! 1989: /* {{{ proto resource sqlite_fetch_column_types(string table_name, resource db [, int result_type])
! 1990: Return an array of column types from a particular table. */
! 1991: PHP_FUNCTION(sqlite_fetch_column_types)
! 1992: {
! 1993: zval *zdb;
! 1994: struct php_sqlite_db *db;
! 1995: char *tbl, *sql;
! 1996: int tbl_len;
! 1997: char *errtext = NULL;
! 1998: zval *object = getThis();
! 1999: struct php_sqlite_result res;
! 2000: const char **rowdata, **colnames, *tail;
! 2001: int i, ncols;
! 2002: long result_type = PHPSQLITE_ASSOC;
! 2003:
! 2004: if (object) {
! 2005: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &tbl, &tbl_len, &result_type)) {
! 2006: return;
! 2007: }
! 2008: DB_FROM_OBJECT(db, object);
! 2009: } else {
! 2010: if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
! 2011: ZEND_NUM_ARGS() TSRMLS_CC, "sr|l", &tbl, &tbl_len, &zdb, &result_type) &&
! 2012: FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &zdb, &tbl, &tbl_len, &result_type)) {
! 2013: return;
! 2014: }
! 2015: DB_FROM_ZVAL(db, &zdb);
! 2016: }
! 2017:
! 2018: if (!(sql = sqlite_mprintf("SELECT * FROM '%q' LIMIT 1", tbl))) {
! 2019: RETURN_FALSE;
! 2020: }
! 2021:
! 2022: sqlite_exec(db->db, "PRAGMA show_datatypes = ON", NULL, NULL, NULL);
! 2023:
! 2024: db->last_err_code = sqlite_compile(db->db, sql, &tail, &res.vm, &errtext);
! 2025:
! 2026: sqlite_freemem(sql);
! 2027:
! 2028: if (db->last_err_code != SQLITE_OK) {
! 2029: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 2030: sqlite_freemem(errtext);
! 2031: RETVAL_FALSE;
! 2032: goto done;
! 2033: }
! 2034:
! 2035: sqlite_step(res.vm, &ncols, &rowdata, &colnames);
! 2036:
! 2037: array_init(return_value);
! 2038:
! 2039: for (i = 0; i < ncols; i++) {
! 2040: if (result_type == PHPSQLITE_ASSOC) {
! 2041: char *colname = estrdup((char *)colnames[i]);
! 2042:
! 2043: if (SQLITE_G(assoc_case) == 1) {
! 2044: php_sqlite_strtoupper(colname);
! 2045: } else if (SQLITE_G(assoc_case) == 2) {
! 2046: php_sqlite_strtolower(colname);
! 2047: }
! 2048:
! 2049: add_assoc_string(return_value, colname, colnames[ncols + i] ? (char *)colnames[ncols + i] : "", 1);
! 2050: efree(colname);
! 2051: }
! 2052: if (result_type == PHPSQLITE_NUM) {
! 2053: add_index_string(return_value, i, colnames[ncols + i] ? (char *)colnames[ncols + i] : "", 1);
! 2054: }
! 2055: }
! 2056: if (res.vm) {
! 2057: sqlite_finalize(res.vm, NULL);
! 2058: }
! 2059: done:
! 2060: sqlite_exec(db->db, "PRAGMA show_datatypes = OFF", NULL, NULL, NULL);
! 2061: }
! 2062: /* }}} */
! 2063:
! 2064: /* {{{ proto resource sqlite_query(string query, resource db [, int result_type [, string &error_message]])
! 2065: Executes a query against a given database and returns a result handle. */
! 2066: PHP_FUNCTION(sqlite_query)
! 2067: {
! 2068: zval *zdb;
! 2069: struct php_sqlite_db *db;
! 2070: char *sql;
! 2071: int sql_len;
! 2072: long mode = PHPSQLITE_BOTH;
! 2073: char *errtext = NULL;
! 2074: zval *errmsg = NULL;
! 2075: zval *object = getThis();
! 2076:
! 2077: if (object) {
! 2078: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lz/", &sql, &sql_len, &mode, &errmsg)) {
! 2079: return;
! 2080: }
! 2081: DB_FROM_OBJECT(db, object);
! 2082: } else {
! 2083: if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
! 2084: ZEND_NUM_ARGS() TSRMLS_CC, "sr|lz/", &sql, &sql_len, &zdb, &mode, &errmsg) &&
! 2085: FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|lz/", &zdb, &sql, &sql_len, &mode, &errmsg)) {
! 2086: return;
! 2087: }
! 2088: DB_FROM_ZVAL(db, &zdb);
! 2089: }
! 2090:
! 2091: if (errmsg) {
! 2092: zval_dtor(errmsg);
! 2093: ZVAL_NULL(errmsg);
! 2094: }
! 2095:
! 2096: PHP_SQLITE_EMPTY_QUERY;
! 2097:
! 2098: /* avoid doing work if we can */
! 2099: if (!return_value_used) {
! 2100: db->last_err_code = sqlite_exec(db->db, sql, NULL, NULL, &errtext);
! 2101:
! 2102: if (db->last_err_code != SQLITE_OK) {
! 2103: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 2104: if (errmsg) {
! 2105: ZVAL_STRING(errmsg, errtext, 1);
! 2106: }
! 2107: sqlite_freemem(errtext);
! 2108: }
! 2109: return;
! 2110: }
! 2111:
! 2112: sqlite_query(object, db, sql, sql_len, (int)mode, 1, return_value, NULL, errmsg TSRMLS_CC);
! 2113: }
! 2114: /* }}} */
! 2115:
! 2116: /* {{{ proto boolean sqlite_exec(string query, resource db[, string &error_message])
! 2117: Executes a result-less query against a given database */
! 2118: PHP_FUNCTION(sqlite_exec)
! 2119: {
! 2120: zval *zdb;
! 2121: struct php_sqlite_db *db;
! 2122: char *sql;
! 2123: int sql_len;
! 2124: char *errtext = NULL;
! 2125: zval *errmsg = NULL;
! 2126: zval *object = getThis();
! 2127:
! 2128: if (object) {
! 2129: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z/", &sql, &sql_len, &errmsg)) {
! 2130: return;
! 2131: }
! 2132: DB_FROM_OBJECT(db, object);
! 2133: } else {
! 2134: if(FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
! 2135: ZEND_NUM_ARGS() TSRMLS_CC, "sr", &sql, &sql_len, &zdb) &&
! 2136: FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|z/", &zdb, &sql, &sql_len, &errmsg)) {
! 2137: return;
! 2138: }
! 2139: DB_FROM_ZVAL(db, &zdb);
! 2140: }
! 2141:
! 2142: if (errmsg) {
! 2143: zval_dtor(errmsg);
! 2144: ZVAL_NULL(errmsg);
! 2145: }
! 2146:
! 2147: PHP_SQLITE_EMPTY_QUERY;
! 2148:
! 2149: db->last_err_code = sqlite_exec(db->db, sql, NULL, NULL, &errtext);
! 2150:
! 2151: if (db->last_err_code != SQLITE_OK) {
! 2152: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 2153: if (errmsg) {
! 2154: ZVAL_STRING(errmsg, errtext, 1);
! 2155: }
! 2156: sqlite_freemem(errtext);
! 2157: RETURN_FALSE;
! 2158: }
! 2159:
! 2160: RETURN_TRUE;
! 2161: }
! 2162: /* }}} */
! 2163:
! 2164: /* {{{ php_sqlite_fetch_array */
! 2165: static void php_sqlite_fetch_array(struct php_sqlite_result *res, int mode, zend_bool decode_binary, int move_next, zval *return_value TSRMLS_DC)
! 2166: {
! 2167: int j, n = res->ncolumns, buffered = res->buffered;
! 2168: const char **rowdata, **colnames;
! 2169:
! 2170: /* check range of the row */
! 2171: if (res->curr_row >= res->nrows) {
! 2172: /* no more */
! 2173: RETURN_FALSE;
! 2174: }
! 2175: colnames = (const char**)res->col_names;
! 2176: if (res->buffered) {
! 2177: rowdata = (const char**)&res->table[res->curr_row * res->ncolumns];
! 2178: } else {
! 2179: rowdata = (const char**)res->table;
! 2180: }
! 2181:
! 2182: /* now populate the result */
! 2183: array_init(return_value);
! 2184:
! 2185: for (j = 0; j < n; j++) {
! 2186: zval *decoded;
! 2187: MAKE_STD_ZVAL(decoded);
! 2188:
! 2189: if (rowdata[j] == NULL) {
! 2190: ZVAL_NULL(decoded);
! 2191: } else if (decode_binary && rowdata[j][0] == '\x01') {
! 2192: Z_STRVAL_P(decoded) = emalloc(strlen(rowdata[j]));
! 2193: Z_STRLEN_P(decoded) = php_sqlite_decode_binary(rowdata[j]+1, Z_STRVAL_P(decoded));
! 2194: Z_STRVAL_P(decoded)[Z_STRLEN_P(decoded)] = '\0';
! 2195: Z_TYPE_P(decoded) = IS_STRING;
! 2196: if (!buffered) {
! 2197: efree((char*)rowdata[j]);
! 2198: rowdata[j] = NULL;
! 2199: }
! 2200: } else {
! 2201: ZVAL_STRING(decoded, (char*)rowdata[j], buffered);
! 2202: if (!buffered) {
! 2203: rowdata[j] = NULL;
! 2204: }
! 2205: }
! 2206:
! 2207: if (mode & PHPSQLITE_NUM) {
! 2208: if (mode & PHPSQLITE_ASSOC) {
! 2209: add_index_zval(return_value, j, decoded);
! 2210: Z_ADDREF_P(decoded);
! 2211: add_assoc_zval(return_value, (char*)colnames[j], decoded);
! 2212: } else {
! 2213: add_next_index_zval(return_value, decoded);
! 2214: }
! 2215: } else {
! 2216: add_assoc_zval(return_value, (char*)colnames[j], decoded);
! 2217: }
! 2218: }
! 2219:
! 2220: if (move_next) {
! 2221: if (!res->buffered) {
! 2222: /* non buffered: fetch next row */
! 2223: php_sqlite_fetch(res TSRMLS_CC);
! 2224: }
! 2225: /* advance the row pointer */
! 2226: res->curr_row++;
! 2227: }
! 2228: }
! 2229: /* }}} */
! 2230:
! 2231: /* {{{ php_sqlite_fetch_column */
! 2232: static void php_sqlite_fetch_column(struct php_sqlite_result *res, zval *which, zend_bool decode_binary, zval *return_value TSRMLS_DC)
! 2233: {
! 2234: int j;
! 2235: const char **rowdata, **colnames;
! 2236:
! 2237: /* check range of the row */
! 2238: if (res->curr_row >= res->nrows) {
! 2239: /* no more */
! 2240: RETURN_FALSE;
! 2241: }
! 2242: colnames = (const char**)res->col_names;
! 2243:
! 2244: if (Z_TYPE_P(which) == IS_LONG) {
! 2245: j = Z_LVAL_P(which);
! 2246: } else {
! 2247: convert_to_string_ex(&which);
! 2248: for (j = 0; j < res->ncolumns; j++) {
! 2249: if (!strcasecmp((char*)colnames[j], Z_STRVAL_P(which))) {
! 2250: break;
! 2251: }
! 2252: }
! 2253: }
! 2254: if (j < 0 || j >= res->ncolumns) {
! 2255: php_error_docref(NULL TSRMLS_CC, E_WARNING, "No such column %d", j);
! 2256: RETURN_FALSE;
! 2257: }
! 2258:
! 2259: if (res->buffered) {
! 2260: rowdata = (const char**)&res->table[res->curr_row * res->ncolumns];
! 2261: } else {
! 2262: rowdata = (const char**)res->table;
! 2263: }
! 2264:
! 2265: if (rowdata[j] == NULL) {
! 2266: RETURN_NULL();
! 2267: } else if (decode_binary && rowdata[j] != NULL && rowdata[j][0] == '\x01') {
! 2268: int l = strlen(rowdata[j]);
! 2269: char *decoded = emalloc(l);
! 2270: l = php_sqlite_decode_binary(rowdata[j]+1, decoded);
! 2271: decoded[l] = '\0';
! 2272: RETVAL_STRINGL(decoded, l, 0);
! 2273: if (!res->buffered) {
! 2274: efree((char*)rowdata[j]);
! 2275: rowdata[j] = NULL;
! 2276: }
! 2277: } else {
! 2278: RETVAL_STRING((char*)rowdata[j], res->buffered);
! 2279: if (!res->buffered) {
! 2280: rowdata[j] = NULL;
! 2281: }
! 2282: }
! 2283: }
! 2284: /* }}} */
! 2285:
! 2286: /* {{{ proto array sqlite_fetch_all(resource result [, int result_type [, bool decode_binary]])
! 2287: Fetches all rows from a result set as an array of arrays. */
! 2288: PHP_FUNCTION(sqlite_fetch_all)
! 2289: {
! 2290: zval *zres, *ent;
! 2291: long mode = PHPSQLITE_BOTH;
! 2292: zend_bool decode_binary = 1;
! 2293: struct php_sqlite_result *res;
! 2294: zval *object = getThis();
! 2295:
! 2296: if (object) {
! 2297: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lb", &mode, &decode_binary)) {
! 2298: return;
! 2299: }
! 2300: RES_FROM_OBJECT(res, object);
! 2301: if (!ZEND_NUM_ARGS()) {
! 2302: mode = res->mode;
! 2303: }
! 2304: } else {
! 2305: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|lb", &zres, &mode, &decode_binary)) {
! 2306: return;
! 2307: }
! 2308: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2309: if (ZEND_NUM_ARGS() < 2) {
! 2310: mode = res->mode;
! 2311: }
! 2312: }
! 2313:
! 2314: if (res->curr_row >= res->nrows && res->nrows) {
! 2315: if (!res->buffered) {
! 2316: php_error_docref(NULL TSRMLS_CC, E_WARNING, "One or more rowsets were already returned; returning NULL this time");
! 2317: } else {
! 2318: res->curr_row = 0;
! 2319: }
! 2320: }
! 2321:
! 2322: array_init(return_value);
! 2323:
! 2324: while (res->curr_row < res->nrows) {
! 2325: MAKE_STD_ZVAL(ent);
! 2326: php_sqlite_fetch_array(res, mode, decode_binary, 1, ent TSRMLS_CC);
! 2327: add_next_index_zval(return_value, ent);
! 2328: }
! 2329: }
! 2330: /* }}} */
! 2331:
! 2332: /* {{{ proto array sqlite_fetch_array(resource result [, int result_type [, bool decode_binary]])
! 2333: Fetches the next row from a result set as an array. */
! 2334: PHP_FUNCTION(sqlite_fetch_array)
! 2335: {
! 2336: zval *zres;
! 2337: long mode = PHPSQLITE_BOTH;
! 2338: zend_bool decode_binary = 1;
! 2339: struct php_sqlite_result *res;
! 2340: zval *object = getThis();
! 2341:
! 2342: if (object) {
! 2343: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lb", &mode, &decode_binary)) {
! 2344: return;
! 2345: }
! 2346: RES_FROM_OBJECT(res, object);
! 2347: if (!ZEND_NUM_ARGS()) {
! 2348: mode = res->mode;
! 2349: }
! 2350: } else {
! 2351: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|lb", &zres, &mode, &decode_binary)) {
! 2352: return;
! 2353: }
! 2354: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2355: if (ZEND_NUM_ARGS() < 2) {
! 2356: mode = res->mode;
! 2357: }
! 2358: }
! 2359:
! 2360: php_sqlite_fetch_array(res, mode, decode_binary, 1, return_value TSRMLS_CC);
! 2361: }
! 2362: /* }}} */
! 2363:
! 2364: /* {{{ proto object sqlite_fetch_object(resource result [, string class_name [, NULL|array ctor_params [, bool decode_binary]]])
! 2365: Fetches the next row from a result set as an object. */
! 2366: /* note that you can do array(&$val) for param ctor_params */
! 2367: PHP_FUNCTION(sqlite_fetch_object)
! 2368: {
! 2369: zval *zres;
! 2370: zend_bool decode_binary = 1;
! 2371: struct php_sqlite_result *res;
! 2372: zval *object = getThis();
! 2373: char *class_name = NULL;
! 2374: int class_name_len;
! 2375: zend_class_entry *ce;
! 2376: zval dataset;
! 2377: zend_fcall_info fci;
! 2378: zend_fcall_info_cache fcc;
! 2379: zval *retval_ptr;
! 2380: zval *ctor_params = NULL;
! 2381: zend_error_handling error_handling;
! 2382:
! 2383: zend_replace_error_handling(object ? EH_THROW : EH_NORMAL, sqlite_ce_exception, &error_handling TSRMLS_CC);
! 2384: if (object) {
! 2385: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|szb", &class_name, &class_name_len, &ctor_params, &decode_binary)) {
! 2386: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2387: return;
! 2388: }
! 2389: RES_FROM_OBJECT_RESTORE_ERH(res, object, &error_handling);
! 2390: if (!class_name) {
! 2391: ce = zend_standard_class_def;
! 2392: } else {
! 2393: ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
! 2394: }
! 2395: } else {
! 2396: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|szb", &zres, &class_name, &class_name_len, &ctor_params, &decode_binary)) {
! 2397: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2398: return;
! 2399: }
! 2400: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2401: if (!class_name) {
! 2402: ce = zend_standard_class_def;
! 2403: } else {
! 2404: ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
! 2405: }
! 2406: }
! 2407:
! 2408: if (!ce) {
! 2409: zend_throw_exception_ex(sqlite_ce_exception, 0 TSRMLS_CC, "Could not find class '%s'", class_name);
! 2410: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2411: return;
! 2412: }
! 2413:
! 2414: if (res->curr_row < res->nrows) {
! 2415: php_sqlite_fetch_array(res, PHPSQLITE_ASSOC, decode_binary, 1, &dataset TSRMLS_CC);
! 2416: } else {
! 2417: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2418: RETURN_FALSE;
! 2419: }
! 2420:
! 2421: object_and_properties_init(return_value, ce, NULL);
! 2422: zend_merge_properties(return_value, Z_ARRVAL(dataset), 1 TSRMLS_CC);
! 2423:
! 2424: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 2425:
! 2426: if (ce->constructor) {
! 2427: fci.size = sizeof(fci);
! 2428: fci.function_table = &ce->function_table;
! 2429: fci.function_name = NULL;
! 2430: fci.symbol_table = NULL;
! 2431: fci.object_ptr = return_value;
! 2432: fci.retval_ptr_ptr = &retval_ptr;
! 2433: if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) {
! 2434: if (Z_TYPE_P(ctor_params) == IS_ARRAY) {
! 2435: HashTable *ht = Z_ARRVAL_P(ctor_params);
! 2436: Bucket *p;
! 2437:
! 2438: fci.param_count = 0;
! 2439: fci.params = safe_emalloc(sizeof(zval*), ht->nNumOfElements, 0);
! 2440: p = ht->pListHead;
! 2441: while (p != NULL) {
! 2442: fci.params[fci.param_count++] = (zval**)p->pData;
! 2443: p = p->pListNext;
! 2444: }
! 2445: } else {
! 2446: /* Two problems why we throw exceptions here: PHP is typeless
! 2447: * and hence passing one argument that's not an array could be
! 2448: * by mistake and the other way round is possible, too. The
! 2449: * single value is an array. Also we'd have to make that one
! 2450: * argument passed by reference.
! 2451: */
! 2452: zend_throw_exception(sqlite_ce_exception, "Parameter ctor_params must be an array", 0 TSRMLS_CC);
! 2453: return;
! 2454: }
! 2455: } else {
! 2456: fci.param_count = 0;
! 2457: fci.params = NULL;
! 2458: }
! 2459: fci.no_separation = 1;
! 2460:
! 2461: fcc.initialized = 1;
! 2462: fcc.function_handler = ce->constructor;
! 2463: fcc.calling_scope = EG(scope);
! 2464: fcc.called_scope = Z_OBJCE_P(return_value);
! 2465: fcc.object_ptr = return_value;
! 2466:
! 2467: if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
! 2468: zend_throw_exception_ex(sqlite_ce_exception, 0 TSRMLS_CC, "Could not execute %s::%s()", class_name, ce->constructor->common.function_name);
! 2469: } else {
! 2470: if (retval_ptr) {
! 2471: zval_ptr_dtor(&retval_ptr);
! 2472: }
! 2473: }
! 2474: if (fci.params) {
! 2475: efree(fci.params);
! 2476: }
! 2477: } else if (ctor_params && Z_TYPE_P(ctor_params) != IS_NULL) {
! 2478: zend_throw_exception_ex(sqlite_ce_exception, 0 TSRMLS_CC, "Class %s does not have a constructor, use NULL for parameter ctor_params or omit it", class_name);
! 2479: }
! 2480: }
! 2481: /* }}} */
! 2482:
! 2483: /* {{{ proto array sqlite_array_query(resource db, string query [ , int result_type [, bool decode_binary]])
! 2484: Executes a query against a given database and returns an array of arrays. */
! 2485: PHP_FUNCTION(sqlite_array_query)
! 2486: {
! 2487: zval *zdb, *ent;
! 2488: struct php_sqlite_db *db;
! 2489: struct php_sqlite_result *rres;
! 2490: char *sql;
! 2491: int sql_len;
! 2492: long mode = PHPSQLITE_BOTH;
! 2493: char *errtext = NULL;
! 2494: zend_bool decode_binary = 1;
! 2495: zval *object = getThis();
! 2496:
! 2497: if (object) {
! 2498: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lb", &sql, &sql_len, &mode, &decode_binary)) {
! 2499: return;
! 2500: }
! 2501: DB_FROM_OBJECT(db, object);
! 2502: } else {
! 2503: if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
! 2504: ZEND_NUM_ARGS() TSRMLS_CC, "sr|lb", &sql, &sql_len, &zdb, &mode, &decode_binary) &&
! 2505: FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|lb", &zdb, &sql, &sql_len, &mode, &decode_binary)) {
! 2506: return;
! 2507: }
! 2508: DB_FROM_ZVAL(db, &zdb);
! 2509: }
! 2510:
! 2511: PHP_SQLITE_EMPTY_QUERY;
! 2512:
! 2513: /* avoid doing work if we can */
! 2514: if (!return_value_used) {
! 2515: db->last_err_code = sqlite_exec(db->db, sql, NULL, NULL, &errtext);
! 2516:
! 2517: if (db->last_err_code != SQLITE_OK) {
! 2518: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 2519: sqlite_freemem(errtext);
! 2520: }
! 2521: return;
! 2522: }
! 2523:
! 2524: rres = (struct php_sqlite_result *)ecalloc(1, sizeof(*rres));
! 2525: sqlite_query(NULL, db, sql, sql_len, (int)mode, 0, NULL, &rres, NULL TSRMLS_CC);
! 2526: if (db->last_err_code != SQLITE_OK) {
! 2527: if (rres) {
! 2528: efree(rres);
! 2529: }
! 2530: RETURN_FALSE;
! 2531: }
! 2532:
! 2533: array_init(return_value);
! 2534:
! 2535: while (rres->curr_row < rres->nrows) {
! 2536: MAKE_STD_ZVAL(ent);
! 2537: php_sqlite_fetch_array(rres, mode, decode_binary, 1, ent TSRMLS_CC);
! 2538: add_next_index_zval(return_value, ent);
! 2539: }
! 2540: real_result_dtor(rres TSRMLS_CC);
! 2541: }
! 2542: /* }}} */
! 2543:
! 2544: /* {{{ php_sqlite_fetch_single */
! 2545: static void php_sqlite_fetch_single(struct php_sqlite_result *res, zend_bool decode_binary, zval *return_value TSRMLS_DC)
! 2546: {
! 2547: const char **rowdata;
! 2548: char *decoded;
! 2549: int decoded_len;
! 2550:
! 2551: /* check range of the row */
! 2552: if (res->curr_row >= res->nrows) {
! 2553: /* no more */
! 2554: RETURN_FALSE;
! 2555: }
! 2556:
! 2557: if (res->buffered) {
! 2558: rowdata = (const char**)&res->table[res->curr_row * res->ncolumns];
! 2559: } else {
! 2560: rowdata = (const char**)res->table;
! 2561: }
! 2562:
! 2563: if (decode_binary && rowdata[0] != NULL && rowdata[0][0] == '\x01') {
! 2564: decoded = emalloc(strlen(rowdata[0]));
! 2565: decoded_len = php_sqlite_decode_binary(rowdata[0]+1, decoded);
! 2566: if (!res->buffered) {
! 2567: efree((char*)rowdata[0]);
! 2568: rowdata[0] = NULL;
! 2569: }
! 2570: } else if (rowdata[0]) {
! 2571: decoded_len = strlen((char*)rowdata[0]);
! 2572: if (res->buffered) {
! 2573: decoded = estrndup((char*)rowdata[0], decoded_len);
! 2574: } else {
! 2575: decoded = (char*)rowdata[0];
! 2576: rowdata[0] = NULL;
! 2577: }
! 2578: } else {
! 2579: decoded = NULL;
! 2580: decoded_len = 0;
! 2581: }
! 2582:
! 2583: if (!res->buffered) {
! 2584: /* non buffered: fetch next row */
! 2585: php_sqlite_fetch(res TSRMLS_CC);
! 2586: }
! 2587: /* advance the row pointer */
! 2588: res->curr_row++;
! 2589:
! 2590: if (decoded == NULL) {
! 2591: RETURN_NULL();
! 2592: } else {
! 2593: RETURN_STRINGL(decoded, decoded_len, 0);
! 2594: }
! 2595: }
! 2596: /* }}} */
! 2597:
! 2598:
! 2599: /* {{{ proto array sqlite_single_query(resource db, string query [, bool first_row_only [, bool decode_binary]])
! 2600: Executes a query and returns either an array for one single column or the value of the first row. */
! 2601: PHP_FUNCTION(sqlite_single_query)
! 2602: {
! 2603: zval *zdb, *ent;
! 2604: struct php_sqlite_db *db;
! 2605: struct php_sqlite_result *rres;
! 2606: char *sql;
! 2607: int sql_len;
! 2608: char *errtext = NULL;
! 2609: zend_bool decode_binary = 1;
! 2610: zend_bool srow = 1;
! 2611: zval *object = getThis();
! 2612:
! 2613: if (object) {
! 2614: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|bb", &sql, &sql_len, &srow, &decode_binary)) {
! 2615: return;
! 2616: }
! 2617: RES_FROM_OBJECT(db, object);
! 2618: } else {
! 2619: if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
! 2620: ZEND_NUM_ARGS() TSRMLS_CC, "sr|bb", &sql, &sql_len, &zdb, &srow, &decode_binary) &&
! 2621: FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|bb", &zdb, &sql, &sql_len, &srow, &decode_binary)) {
! 2622: return;
! 2623: }
! 2624: DB_FROM_ZVAL(db, &zdb);
! 2625: }
! 2626:
! 2627: PHP_SQLITE_EMPTY_QUERY;
! 2628:
! 2629: /* avoid doing work if we can */
! 2630: if (!return_value_used) {
! 2631: db->last_err_code = sqlite_exec(db->db, sql, NULL, NULL, &errtext);
! 2632:
! 2633: if (db->last_err_code != SQLITE_OK) {
! 2634: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext);
! 2635: sqlite_freemem(errtext);
! 2636: }
! 2637: return;
! 2638: }
! 2639:
! 2640: rres = (struct php_sqlite_result *)ecalloc(1, sizeof(*rres));
! 2641: sqlite_query(NULL, db, sql, sql_len, PHPSQLITE_NUM, 0, NULL, &rres, NULL TSRMLS_CC);
! 2642: if (db->last_err_code != SQLITE_OK) {
! 2643: if (rres) {
! 2644: efree(rres);
! 2645: }
! 2646: RETURN_FALSE;
! 2647: }
! 2648:
! 2649: if (!srow) {
! 2650: array_init(return_value);
! 2651: }
! 2652:
! 2653: while (rres->curr_row < rres->nrows) {
! 2654: MAKE_STD_ZVAL(ent);
! 2655: php_sqlite_fetch_single(rres, decode_binary, ent TSRMLS_CC);
! 2656:
! 2657: /* if set and we only have 1 row in the result set, return the result as a string. */
! 2658: if (srow) {
! 2659: if (rres->curr_row == 1 && rres->curr_row >= rres->nrows) {
! 2660: *return_value = *ent;
! 2661: zval_copy_ctor(return_value);
! 2662: zval_dtor(ent);
! 2663: FREE_ZVAL(ent);
! 2664: break;
! 2665: } else {
! 2666: srow = 0;
! 2667: array_init(return_value);
! 2668: }
! 2669: }
! 2670: add_next_index_zval(return_value, ent);
! 2671: }
! 2672:
! 2673: real_result_dtor(rres TSRMLS_CC);
! 2674: }
! 2675: /* }}} */
! 2676:
! 2677:
! 2678: /* {{{ proto string sqlite_fetch_single(resource result [, bool decode_binary])
! 2679: Fetches the first column of a result set as a string. */
! 2680: PHP_FUNCTION(sqlite_fetch_single)
! 2681: {
! 2682: zval *zres;
! 2683: zend_bool decode_binary = 1;
! 2684: struct php_sqlite_result *res;
! 2685: zval *object = getThis();
! 2686:
! 2687: if (object) {
! 2688: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &decode_binary)) {
! 2689: return;
! 2690: }
! 2691: RES_FROM_OBJECT(res, object);
! 2692: } else {
! 2693: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|b", &zres, &decode_binary)) {
! 2694: return;
! 2695: }
! 2696: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2697: }
! 2698:
! 2699: php_sqlite_fetch_single(res, decode_binary, return_value TSRMLS_CC);
! 2700: }
! 2701: /* }}} */
! 2702:
! 2703: /* {{{ proto array sqlite_current(resource result [, int result_type [, bool decode_binary]])
! 2704: Fetches the current row from a result set as an array. */
! 2705: PHP_FUNCTION(sqlite_current)
! 2706: {
! 2707: zval *zres;
! 2708: long mode = PHPSQLITE_BOTH;
! 2709: zend_bool decode_binary = 1;
! 2710: struct php_sqlite_result *res;
! 2711: zval *object = getThis();
! 2712:
! 2713: if (object) {
! 2714: if (ZEND_NUM_ARGS() && FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lb", &mode, &decode_binary)) {
! 2715: return;
! 2716: }
! 2717: RES_FROM_OBJECT(res, object);
! 2718: if (!ZEND_NUM_ARGS()) {
! 2719: mode = res->mode;
! 2720: }
! 2721: } else {
! 2722: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|lb", &zres, &mode, &decode_binary)) {
! 2723: return;
! 2724: }
! 2725: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2726: if (ZEND_NUM_ARGS() < 2) {
! 2727: mode = res->mode;
! 2728: }
! 2729: }
! 2730:
! 2731: php_sqlite_fetch_array(res, mode, decode_binary, 0, return_value TSRMLS_CC);
! 2732: }
! 2733: /* }}} */
! 2734:
! 2735: /* {{{ proto mixed sqlite_column(resource result, mixed index_or_name [, bool decode_binary])
! 2736: Fetches a column from the current row of a result set. */
! 2737: PHP_FUNCTION(sqlite_column)
! 2738: {
! 2739: zval *zres;
! 2740: zval *which;
! 2741: zend_bool decode_binary = 1;
! 2742: struct php_sqlite_result *res;
! 2743: zval *object = getThis();
! 2744:
! 2745: if (object) {
! 2746: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &which, &decode_binary)) {
! 2747: return;
! 2748: }
! 2749: RES_FROM_OBJECT(res, object);
! 2750: } else {
! 2751: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|b", &zres, &which, &decode_binary)) {
! 2752: return;
! 2753: }
! 2754: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2755: }
! 2756:
! 2757: php_sqlite_fetch_column(res, which, decode_binary, return_value TSRMLS_CC);
! 2758: }
! 2759: /* }}} */
! 2760:
! 2761: /* {{{ proto string sqlite_libversion()
! 2762: Returns the version of the linked SQLite library. */
! 2763: PHP_FUNCTION(sqlite_libversion)
! 2764: {
! 2765: if (zend_parse_parameters_none() == FAILURE) {
! 2766: return;
! 2767: }
! 2768: RETURN_STRING((char*)sqlite_libversion(), 1);
! 2769: }
! 2770: /* }}} */
! 2771:
! 2772: /* {{{ proto string sqlite_libencoding()
! 2773: Returns the encoding (iso8859 or UTF-8) of the linked SQLite library. */
! 2774: PHP_FUNCTION(sqlite_libencoding)
! 2775: {
! 2776: if (zend_parse_parameters_none() == FAILURE) {
! 2777: return;
! 2778: }
! 2779: RETURN_STRING((char*)sqlite_libencoding(), 1);
! 2780: }
! 2781: /* }}} */
! 2782:
! 2783: /* {{{ proto int sqlite_changes(resource db)
! 2784: Returns the number of rows that were changed by the most recent SQL statement. */
! 2785: PHP_FUNCTION(sqlite_changes)
! 2786: {
! 2787: zval *zdb;
! 2788: struct php_sqlite_db *db;
! 2789: zval *object = getThis();
! 2790:
! 2791: if (object) {
! 2792: if (zend_parse_parameters_none() == FAILURE) {
! 2793: return;
! 2794: }
! 2795: DB_FROM_OBJECT(db, object);
! 2796: } else {
! 2797: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zdb)) {
! 2798: return;
! 2799: }
! 2800: DB_FROM_ZVAL(db, &zdb);
! 2801: }
! 2802:
! 2803: RETURN_LONG(sqlite_changes(db->db));
! 2804: }
! 2805: /* }}} */
! 2806:
! 2807: /* {{{ proto int sqlite_last_insert_rowid(resource db)
! 2808: Returns the rowid of the most recently inserted row. */
! 2809: PHP_FUNCTION(sqlite_last_insert_rowid)
! 2810: {
! 2811: zval *zdb;
! 2812: struct php_sqlite_db *db;
! 2813: zval *object = getThis();
! 2814:
! 2815: if (object) {
! 2816: if (zend_parse_parameters_none() == FAILURE) {
! 2817: return;
! 2818: }
! 2819: DB_FROM_OBJECT(db, object);
! 2820: } else {
! 2821: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zdb)) {
! 2822: return;
! 2823: }
! 2824: DB_FROM_ZVAL(db, &zdb);
! 2825: }
! 2826:
! 2827: RETURN_LONG(sqlite_last_insert_rowid(db->db));
! 2828: }
! 2829: /* }}} */
! 2830:
! 2831: static int sqlite_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
! 2832: {
! 2833: sqlite_object *obj = (sqlite_object*) zend_object_store_get_object(object TSRMLS_CC);
! 2834:
! 2835: if (obj->u.res == NULL) {
! 2836: zend_throw_exception(sqlite_ce_exception, "Row count is not available for this query", 0 TSRMLS_CC);
! 2837: return FAILURE;
! 2838: }
! 2839:
! 2840: if (obj->u.res->buffered) {
! 2841: * count = obj->u.res->nrows;
! 2842: return SUCCESS;
! 2843: } else {
! 2844: zend_throw_exception(sqlite_ce_exception, "Row count is not available for unbuffered queries", 0 TSRMLS_CC);
! 2845: return FAILURE;
! 2846: }
! 2847: } /* }}} */
! 2848:
! 2849: /* {{{ proto int sqlite_num_rows(resource result)
! 2850: Returns the number of rows in a buffered result set. */
! 2851: PHP_FUNCTION(sqlite_num_rows)
! 2852: {
! 2853: zval *zres;
! 2854: struct php_sqlite_result *res;
! 2855: zval *object = getThis();
! 2856:
! 2857: if (object) {
! 2858: if (zend_parse_parameters_none() == FAILURE) {
! 2859: return;
! 2860: }
! 2861: RES_FROM_OBJECT(res, object);
! 2862: } else {
! 2863: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 2864: return;
! 2865: }
! 2866: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2867: }
! 2868:
! 2869: if (res->buffered) {
! 2870: RETURN_LONG(res->nrows);
! 2871: } else {
! 2872: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Row count is not available for unbuffered queries");
! 2873: RETURN_FALSE;
! 2874: }
! 2875: }
! 2876: /* }}} */
! 2877:
! 2878: /* {{{ proto bool sqlite_valid(resource result)
! 2879: Returns whether more rows are available. */
! 2880: PHP_FUNCTION(sqlite_valid)
! 2881: {
! 2882: zval *zres;
! 2883: struct php_sqlite_result *res;
! 2884: zval *object = getThis();
! 2885:
! 2886: if (object) {
! 2887: if (zend_parse_parameters_none() == FAILURE) {
! 2888: return;
! 2889: }
! 2890: RES_FROM_OBJECT(res, object);
! 2891: } else {
! 2892: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 2893: return;
! 2894: }
! 2895: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2896: }
! 2897:
! 2898: RETURN_BOOL(res->curr_row < res->nrows && res->nrows); /* curr_row may be -1 */
! 2899: }
! 2900: /* }}} */
! 2901:
! 2902: /* {{{ proto bool sqlite_has_prev(resource result)
! 2903: * Returns whether a previous row is available. */
! 2904: PHP_FUNCTION(sqlite_has_prev)
! 2905: {
! 2906: zval *zres;
! 2907: struct php_sqlite_result *res;
! 2908: zval *object = getThis();
! 2909:
! 2910: if (object) {
! 2911: if (zend_parse_parameters_none() == FAILURE) {
! 2912: return;
! 2913: }
! 2914: RES_FROM_OBJECT(res, object);
! 2915: } else {
! 2916: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 2917: return;
! 2918: }
! 2919: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2920: }
! 2921:
! 2922: if(!res->buffered) {
! 2923: php_error_docref(NULL TSRMLS_CC, E_WARNING, "you cannot use sqlite_has_prev on unbuffered querys");
! 2924: RETURN_FALSE;
! 2925: }
! 2926:
! 2927: RETURN_BOOL(res->curr_row);
! 2928: }
! 2929: /* }}} */
! 2930:
! 2931: /* {{{ proto int sqlite_num_fields(resource result)
! 2932: Returns the number of fields in a result set. */
! 2933: PHP_FUNCTION(sqlite_num_fields)
! 2934: {
! 2935: zval *zres;
! 2936: struct php_sqlite_result *res;
! 2937: zval *object = getThis();
! 2938:
! 2939: if (object) {
! 2940: if (zend_parse_parameters_none() == FAILURE) {
! 2941: return;
! 2942: }
! 2943: RES_FROM_OBJECT(res, object);
! 2944: } else {
! 2945: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 2946: return;
! 2947: }
! 2948: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2949: }
! 2950:
! 2951: RETURN_LONG(res->ncolumns);
! 2952: }
! 2953: /* }}} */
! 2954:
! 2955: /* {{{ proto string sqlite_field_name(resource result, int field_index)
! 2956: Returns the name of a particular field of a result set. */
! 2957: PHP_FUNCTION(sqlite_field_name)
! 2958: {
! 2959: zval *zres;
! 2960: struct php_sqlite_result *res;
! 2961: long field;
! 2962: zval *object = getThis();
! 2963:
! 2964: if (object) {
! 2965: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &field)) {
! 2966: return;
! 2967: }
! 2968: RES_FROM_OBJECT(res, object);
! 2969: } else {
! 2970: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zres, &field)) {
! 2971: return;
! 2972: }
! 2973: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 2974: }
! 2975:
! 2976: if (field < 0 || field >= res->ncolumns) {
! 2977: php_error_docref(NULL TSRMLS_CC, E_WARNING, "field %ld out of range", field);
! 2978: RETURN_FALSE;
! 2979: }
! 2980:
! 2981: RETURN_STRING(res->col_names[field], 1);
! 2982: }
! 2983: /* }}} */
! 2984:
! 2985: /* {{{ proto bool sqlite_seek(resource result, int row)
! 2986: Seek to a particular row number of a buffered result set. */
! 2987: PHP_FUNCTION(sqlite_seek)
! 2988: {
! 2989: zval *zres;
! 2990: struct php_sqlite_result *res;
! 2991: long row;
! 2992: zval *object = getThis();
! 2993:
! 2994: if (object) {
! 2995: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &row)) {
! 2996: return;
! 2997: }
! 2998: RES_FROM_OBJECT(res, object);
! 2999: } else {
! 3000: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zres, &row)) {
! 3001: return;
! 3002: }
! 3003: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 3004: }
! 3005:
! 3006: if (!res->buffered) {
! 3007: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot seek an unbuffered result set");
! 3008: RETURN_FALSE;
! 3009: }
! 3010:
! 3011: if (row < 0 || row >= res->nrows) {
! 3012: php_error_docref(NULL TSRMLS_CC, E_WARNING, "row %ld out of range", row);
! 3013: RETURN_FALSE;
! 3014: }
! 3015:
! 3016: res->curr_row = row;
! 3017: RETURN_TRUE;
! 3018: }
! 3019: /* }}} */
! 3020:
! 3021: /* {{{ proto bool sqlite_rewind(resource result)
! 3022: Seek to the first row number of a buffered result set. */
! 3023: PHP_FUNCTION(sqlite_rewind)
! 3024: {
! 3025: zval *zres;
! 3026: struct php_sqlite_result *res;
! 3027: zval *object = getThis();
! 3028:
! 3029: if (object) {
! 3030: if (zend_parse_parameters_none() == FAILURE) {
! 3031: return;
! 3032: }
! 3033: RES_FROM_OBJECT(res, object);
! 3034: } else {
! 3035: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 3036: return;
! 3037: }
! 3038: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 3039: }
! 3040:
! 3041: if (!res->buffered) {
! 3042: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot rewind an unbuffered result set");
! 3043: RETURN_FALSE;
! 3044: }
! 3045:
! 3046: if (!res->nrows) {
! 3047: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "no rows received");
! 3048: RETURN_FALSE;
! 3049: }
! 3050:
! 3051: res->curr_row = 0;
! 3052: RETURN_TRUE;
! 3053: }
! 3054: /* }}} */
! 3055:
! 3056: /* {{{ proto bool sqlite_next(resource result)
! 3057: Seek to the next row number of a result set. */
! 3058: PHP_FUNCTION(sqlite_next)
! 3059: {
! 3060: zval *zres;
! 3061: struct php_sqlite_result *res;
! 3062: zval *object = getThis();
! 3063:
! 3064: if (object) {
! 3065: if (zend_parse_parameters_none() == FAILURE) {
! 3066: return;
! 3067: }
! 3068: RES_FROM_OBJECT(res, object);
! 3069: } else {
! 3070: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 3071: return;
! 3072: }
! 3073: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 3074: }
! 3075:
! 3076: if (!res->buffered && res->vm) {
! 3077: php_sqlite_fetch(res TSRMLS_CC);
! 3078: }
! 3079:
! 3080: if (res->curr_row >= res->nrows) {
! 3081: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no more rows available");
! 3082: RETURN_FALSE;
! 3083: }
! 3084:
! 3085: res->curr_row++;
! 3086:
! 3087: RETURN_TRUE;
! 3088: }
! 3089: /* }}} */
! 3090:
! 3091: /* {{{ proto int sqlite_key(resource result)
! 3092: Return the current row index of a buffered result. */
! 3093: PHP_FUNCTION(sqlite_key)
! 3094: {
! 3095: zval *zres;
! 3096: struct php_sqlite_result *res;
! 3097: zval *object = getThis();
! 3098:
! 3099: if (object) {
! 3100: if (zend_parse_parameters_none() == FAILURE) {
! 3101: return;
! 3102: }
! 3103: RES_FROM_OBJECT(res, object);
! 3104: } else {
! 3105: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 3106: return;
! 3107: }
! 3108: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 3109: }
! 3110:
! 3111: RETURN_LONG(res->curr_row);
! 3112: }
! 3113: /* }}} */
! 3114:
! 3115: /* {{{ proto bool sqlite_prev(resource result)
! 3116: * Seek to the previous row number of a result set. */
! 3117: PHP_FUNCTION(sqlite_prev)
! 3118: {
! 3119: zval *zres;
! 3120: struct php_sqlite_result *res;
! 3121: zval *object = getThis();
! 3122:
! 3123: if (object) {
! 3124: if (zend_parse_parameters_none() == FAILURE) {
! 3125: return;
! 3126: }
! 3127: RES_FROM_OBJECT(res, object);
! 3128: } else {
! 3129: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zres)) {
! 3130: return;
! 3131: }
! 3132: ZEND_FETCH_RESOURCE(res, struct php_sqlite_result *, &zres, -1, "sqlite result", le_sqlite_result);
! 3133: }
! 3134:
! 3135: if (!res->buffered) {
! 3136: php_error_docref(NULL TSRMLS_CC, E_WARNING, "you cannot use sqlite_prev on unbuffered querys");
! 3137: RETURN_FALSE;
! 3138: }
! 3139:
! 3140: if (res->curr_row <= 0) {
! 3141: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no previous row available");
! 3142: RETURN_FALSE;
! 3143: }
! 3144:
! 3145: res->curr_row--;
! 3146:
! 3147: RETURN_TRUE;
! 3148: }
! 3149: /* }}} */
! 3150:
! 3151: /* {{{ proto string sqlite_escape_string(string item)
! 3152: Escapes a string for use as a query parameter. */
! 3153: PHP_FUNCTION(sqlite_escape_string)
! 3154: {
! 3155: char *string = NULL;
! 3156: int stringlen;
! 3157: char *ret;
! 3158:
! 3159: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &string, &stringlen)) {
! 3160: return;
! 3161: }
! 3162:
! 3163: if (stringlen && (string[0] == '\x01' || memchr(string, '\0', stringlen) != NULL)) {
! 3164: /* binary string */
! 3165: int enclen;
! 3166:
! 3167: ret = safe_emalloc(1 + stringlen / 254, 257, 3);
! 3168: ret[0] = '\x01';
! 3169: enclen = php_sqlite_encode_binary(string, stringlen, ret+1);
! 3170: RETVAL_STRINGL(ret, enclen+1, 0);
! 3171:
! 3172: } else if (stringlen) {
! 3173: ret = sqlite_mprintf("%q", string);
! 3174: if (ret) {
! 3175: RETVAL_STRING(ret, 1);
! 3176: sqlite_freemem(ret);
! 3177: }
! 3178: } else {
! 3179: RETURN_EMPTY_STRING();
! 3180: }
! 3181: }
! 3182: /* }}} */
! 3183:
! 3184: /* {{{ proto int sqlite_last_error(resource db)
! 3185: Returns the error code of the last error for a database. */
! 3186: PHP_FUNCTION(sqlite_last_error)
! 3187: {
! 3188: zval *zdb;
! 3189: struct php_sqlite_db *db;
! 3190: zval *object = getThis();
! 3191:
! 3192: if (object) {
! 3193: if (zend_parse_parameters_none() == FAILURE) {
! 3194: return;
! 3195: }
! 3196: DB_FROM_OBJECT(db, object);
! 3197: } else {
! 3198: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zdb)) {
! 3199: return;
! 3200: }
! 3201: DB_FROM_ZVAL(db, &zdb);
! 3202: }
! 3203:
! 3204: RETURN_LONG(db->last_err_code);
! 3205: }
! 3206: /* }}} */
! 3207:
! 3208: /* {{{ proto string sqlite_error_string(int error_code)
! 3209: Returns the textual description of an error code. */
! 3210: PHP_FUNCTION(sqlite_error_string)
! 3211: {
! 3212: long code;
! 3213: const char *msg;
! 3214:
! 3215: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &code)) {
! 3216: return;
! 3217: }
! 3218:
! 3219: msg = sqlite_error_string(code);
! 3220:
! 3221: if (msg) {
! 3222: RETURN_STRING((char*)msg, 1);
! 3223: } else {
! 3224: RETURN_NULL();
! 3225: }
! 3226: }
! 3227: /* }}} */
! 3228:
! 3229: /* manages duplicate registrations of a particular function, and
! 3230: * also handles the case where the db is using a persistent connection */
! 3231: enum callback_prep_t { DO_REG, SKIP_REG, ERR };
! 3232:
! 3233: static enum callback_prep_t prep_callback_struct(struct php_sqlite_db *db, int is_agg,
! 3234: char *funcname,
! 3235: zval *step, zval *fini, struct php_sqlite_agg_functions **funcs)
! 3236: {
! 3237: struct php_sqlite_agg_functions *alloc_funcs, func_tmp;
! 3238: char *hashkey;
! 3239: int hashkeylen;
! 3240: enum callback_prep_t ret;
! 3241:
! 3242: hashkeylen = spprintf(&hashkey, 0, "%s-%s", is_agg ? "agg" : "reg", funcname);
! 3243:
! 3244: /* is it already registered ? */
! 3245: if (SUCCESS == zend_hash_find(&db->callbacks, hashkey, hashkeylen+1, (void*)&alloc_funcs)) {
! 3246: /* override the previous definition */
! 3247:
! 3248: if (alloc_funcs->is_valid) {
! 3249: /* release these */
! 3250:
! 3251: if (alloc_funcs->step) {
! 3252: zval_ptr_dtor(&alloc_funcs->step);
! 3253: alloc_funcs->step = NULL;
! 3254: }
! 3255:
! 3256: if (alloc_funcs->fini) {
! 3257: zval_ptr_dtor(&alloc_funcs->fini);
! 3258: alloc_funcs->fini = NULL;
! 3259: }
! 3260: }
! 3261:
! 3262: ret = SKIP_REG;
! 3263: } else {
! 3264: /* add a new one */
! 3265: func_tmp.db = db;
! 3266:
! 3267: ret = SUCCESS == zend_hash_update(&db->callbacks, hashkey, hashkeylen+1,
! 3268: (void*)&func_tmp, sizeof(func_tmp), (void**)&alloc_funcs) ? DO_REG : ERR;
! 3269: }
! 3270:
! 3271: efree(hashkey);
! 3272:
! 3273: MAKE_STD_ZVAL(alloc_funcs->step);
! 3274: *(alloc_funcs->step) = *step;
! 3275: zval_copy_ctor(alloc_funcs->step);
! 3276: INIT_PZVAL(alloc_funcs->step);
! 3277:
! 3278: if (is_agg) {
! 3279: MAKE_STD_ZVAL(alloc_funcs->fini);
! 3280: *(alloc_funcs->fini) = *fini;
! 3281: zval_copy_ctor(alloc_funcs->fini);
! 3282: INIT_PZVAL(alloc_funcs->fini);
! 3283: } else {
! 3284: alloc_funcs->fini = NULL;
! 3285: }
! 3286: alloc_funcs->is_valid = 1;
! 3287: *funcs = alloc_funcs;
! 3288:
! 3289: return ret;
! 3290: }
! 3291:
! 3292:
! 3293: /* {{{ proto bool sqlite_create_aggregate(resource db, string funcname, mixed step_func, mixed finalize_func[, long num_args])
! 3294: Registers an aggregate function for queries. */
! 3295: PHP_FUNCTION(sqlite_create_aggregate)
! 3296: {
! 3297: char *funcname = NULL;
! 3298: int funcname_len;
! 3299: zval *zstep, *zfinal, *zdb;
! 3300: struct php_sqlite_db *db;
! 3301: struct php_sqlite_agg_functions *funcs;
! 3302: char *callable = NULL;
! 3303: long num_args = -1;
! 3304: zval *object = getThis();
! 3305:
! 3306: if (object) {
! 3307: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l", &funcname, &funcname_len, &zstep, &zfinal, &num_args)) {
! 3308: return;
! 3309: }
! 3310: DB_FROM_OBJECT(db, object);
! 3311: } else {
! 3312: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rszz|l", &zdb, &funcname, &funcname_len, &zstep, &zfinal, &num_args)) {
! 3313: return;
! 3314: }
! 3315: DB_FROM_ZVAL(db, &zdb);
! 3316: }
! 3317:
! 3318: if (!zend_is_callable(zstep, 0, &callable TSRMLS_CC)) {
! 3319: php_error_docref(NULL TSRMLS_CC, E_WARNING, "step function `%s' is not callable", callable);
! 3320: efree(callable);
! 3321: return;
! 3322: }
! 3323: efree(callable);
! 3324:
! 3325: if (!zend_is_callable(zfinal, 0, &callable TSRMLS_CC)) {
! 3326: php_error_docref(NULL TSRMLS_CC, E_WARNING, "finalize function `%s' is not callable", callable);
! 3327: efree(callable);
! 3328: return;
! 3329: }
! 3330: efree(callable);
! 3331:
! 3332:
! 3333: if (prep_callback_struct(db, 1, funcname, zstep, zfinal, &funcs) == DO_REG) {
! 3334: sqlite_create_aggregate(db->db, funcname, num_args,
! 3335: php_sqlite_agg_step_function_callback,
! 3336: php_sqlite_agg_fini_function_callback, funcs);
! 3337: }
! 3338:
! 3339:
! 3340: }
! 3341: /* }}} */
! 3342:
! 3343: /* {{{ proto bool sqlite_create_function(resource db, string funcname, mixed callback[, long num_args])
! 3344: Registers a "regular" function for queries. */
! 3345: PHP_FUNCTION(sqlite_create_function)
! 3346: {
! 3347: char *funcname = NULL;
! 3348: int funcname_len;
! 3349: zval *zcall, *zdb;
! 3350: struct php_sqlite_db *db;
! 3351: struct php_sqlite_agg_functions *funcs;
! 3352: char *callable = NULL;
! 3353: long num_args = -1;
! 3354:
! 3355: zval *object = getThis();
! 3356:
! 3357: if (object) {
! 3358: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &funcname, &funcname_len, &zcall, &num_args)) {
! 3359: return;
! 3360: }
! 3361: DB_FROM_OBJECT(db, object);
! 3362: } else {
! 3363: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsz|l", &zdb, &funcname, &funcname_len, &zcall, &num_args)) {
! 3364: return;
! 3365: }
! 3366: DB_FROM_ZVAL(db, &zdb);
! 3367: }
! 3368:
! 3369: if (!zend_is_callable(zcall, 0, &callable TSRMLS_CC)) {
! 3370: php_error_docref(NULL TSRMLS_CC, E_WARNING, "function `%s' is not callable", callable);
! 3371: efree(callable);
! 3372: return;
! 3373: }
! 3374: efree(callable);
! 3375:
! 3376: if (prep_callback_struct(db, 0, funcname, zcall, NULL, &funcs) == DO_REG) {
! 3377: sqlite_create_function(db->db, funcname, num_args, php_sqlite_function_callback, funcs);
! 3378: }
! 3379: }
! 3380: /* }}} */
! 3381:
! 3382: /* {{{ proto string sqlite_udf_encode_binary(string data)
! 3383: Apply binary encoding (if required) to a string to return from an UDF. */
! 3384: PHP_FUNCTION(sqlite_udf_encode_binary)
! 3385: {
! 3386: char *data = NULL;
! 3387: int datalen;
! 3388:
! 3389: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!", &data, &datalen)) {
! 3390: return;
! 3391: }
! 3392:
! 3393: if (data == NULL) {
! 3394: RETURN_NULL();
! 3395: }
! 3396: if (datalen && (data[0] == '\x01' || memchr(data, '\0', datalen) != NULL)) {
! 3397: /* binary string */
! 3398: int enclen;
! 3399: char *ret;
! 3400:
! 3401: ret = safe_emalloc(1 + datalen / 254, 257, 3);
! 3402: ret[0] = '\x01';
! 3403: enclen = php_sqlite_encode_binary(data, datalen, ret+1);
! 3404: RETVAL_STRINGL(ret, enclen+1, 0);
! 3405: } else {
! 3406: RETVAL_STRINGL(data, datalen, 1);
! 3407: }
! 3408: }
! 3409: /* }}} */
! 3410:
! 3411: /* {{{ proto string sqlite_udf_decode_binary(string data)
! 3412: Decode binary encoding on a string parameter passed to an UDF. */
! 3413: PHP_FUNCTION(sqlite_udf_decode_binary)
! 3414: {
! 3415: char *data = NULL;
! 3416: int datalen;
! 3417:
! 3418: if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s!", &data, &datalen)) {
! 3419: return;
! 3420: }
! 3421:
! 3422: if (data == NULL) {
! 3423: RETURN_NULL();
! 3424: }
! 3425: if (datalen && data[0] == '\x01') {
! 3426: /* encoded string */
! 3427: int enclen;
! 3428: char *ret;
! 3429:
! 3430: ret = emalloc(datalen);
! 3431: enclen = php_sqlite_decode_binary(data+1, ret);
! 3432: ret[enclen] = '\0';
! 3433: RETVAL_STRINGL(ret, enclen, 0);
! 3434: } else {
! 3435: RETVAL_STRINGL(data, datalen, 1);
! 3436: }
! 3437: }
! 3438: /* }}} */
! 3439:
! 3440:
! 3441: /*
! 3442: * Local variables:
! 3443: * tab-width: 4
! 3444: * c-basic-offset: 4
! 3445: * End:
! 3446: * vim600: sw=4 ts=4 fdm=marker
! 3447: * vim<600: sw=4 ts=4
! 3448: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sqlite.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 / sqlite