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