From: Scott MacVicar Date: Sat, 26 Jul 2008 01:23:45 +0000 (+0000) Subject: Forgot to add these earlier X-Git-Tag: BEFORE_HEAD_NS_CHANGE~1038 X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=de9093bf87f97df8538940d3f06fcd9c84567cd0;p=php Forgot to add these earlier SQLite3 extension, still has 2 failing tests that will be sorted shortly. --- diff --git a/ext/sqlite3/CREDITS b/ext/sqlite3/CREDITS new file mode 100644 index 0000000000..46b8b3e3ab --- /dev/null +++ b/ext/sqlite3/CREDITS @@ -0,0 +1,4 @@ +SQLite3 + +Scott MacVicar + diff --git a/ext/sqlite3/config.m4 b/ext/sqlite3/config.m4 new file mode 100644 index 0000000000..758e7c7cb3 --- /dev/null +++ b/ext/sqlite3/config.m4 @@ -0,0 +1,86 @@ +dnl $Id$ +dnl config.m4 for extension sqlite3 +dnl vim:et:ts=2:sw=2 + +PHP_ARG_WITH(sqlite3, whether to enable the SQLite3 extension, +[ --with-sqlite3[=DIR] Include SQLite3 support. DIR is the prefix to + SQLite3 installation directory.], no) + +if test $PHP_SQLITE3 != "no"; then + sqlite3_extra_sources="" + PHP_SQLITE3_CFLAGS="" + + dnl when running phpize enable_maintainer_zts is not available + if test -z "$enable_maintainer_zts"; then + if test -f "$phpincludedir/main/php_config.h"; then + ZTS=`grep '#define ZTS' $phpincludedir/main/php_config.h|$SED 's/#define ZTS//'` + if test "$ZTS" -eq "1"; then + enable_maintainer_zts="yes" + fi + fi + fi + + if test $PHP_SQLITE3 != "yes"; then + AC_MSG_CHECKING([for sqlite3 files in default path]) + for i in $PHP_SQLITE3 /usr/local /usr; do + if test -r $i/include/sqlite3.h; then + SQLITE3_DIR=$i + AC_MSG_RESULT(found in $i) + break + fi + done + + if test -z "$SQLITE3_DIR"; then + AC_MSG_RESULT([not found]) + AC_MSG_ERROR([Please reinstall the sqlite distribution from http://www.sqlite.org]) + fi + + AC_MSG_CHECKING([for SQLite 3.3.9+]) + PHP_CHECK_LIBRARY(sqlite3, sqlite3_prepare_v2, [ + AC_MSG_RESULT(found) + PHP_ADD_LIBRARY_WITH_PATH(sqlite3, $SQLITE3_DIR/$PHP_LIBDIR, SQLITE3_SHARED_LIBADD) + PHP_ADD_INCLUDE($SQLITE3_DIR/include) + ],[ + AC_MSG_RESULT([not found]) + AC_MSG_ERROR([Please install SQLite 3.3.9 first or check libsqlite3 is present]) + ],[ + -L$SQLITE3_DIR/$PHP_LIBDIR -lm + ]) + + PHP_CHECK_LIBRARY(sqlite3,sqlite3_key,[ + AC_DEFINE(HAVE_SQLITE3_KEY, 1, [have commercial sqlite3 with crypto support]) + ]) + + else + AC_MSG_CHECKING([built in sqlite3 library]) + AC_MSG_RESULT([yes]) + + sqlite3_extra_sources="libsqlite/sqlite3.c" + + if test "$enable_maintainer_zts" = "yes"; then + threadsafe_flags="-DSQLITE_THREADSAFE=1" + else + threadsafe_flags="-DSQLITE_THREADSAFE=0" + fi + + if test "$ZEND_DEBUG" = "yes"; then + debug_flags="-DSQLITE_DEBUG=1" + fi + + other_flags="-DSQLITE_ENABLE_FTS3=1 -DSQLITE_CORE=1" + +dnl if test "$PHP_MAJOR_VERSION" -ge "6"; then +dnl other_flags="$other_flags -DSQLITE_ENABLE_ICU=1" +dnl fi + + PHP_SQLITE3_CFLAGS="-I@ext_srcdir@/libsqlite -I@ext_builddir@/libsqlite $other_flags $threadsafe_flags $debug_flags" + fi + + AC_DEFINE(HAVE_SQLITE3,1,[ ]) + + sqlite3_sources="sqlite3.c $sqlite3_extra_sources" + + PHP_NEW_EXTENSION(sqlite3, $sqlite3_sources, $ext_shared, ,$PHP_SQLITE3_CFLAGS) + PHP_SUBST(SQLITE3_SHARED_LIBADD) + +fi diff --git a/ext/sqlite3/config.w32 b/ext/sqlite3/config.w32 new file mode 100644 index 0000000000..81c3c41b16 --- /dev/null +++ b/ext/sqlite3/config.w32 @@ -0,0 +1,17 @@ +// $Id$ +// vim:ft=javascript + +ARG_WITH("sqlite3", "SQLite 3 support", "no"); + +if (PHP_SQLITE3 != "no") { + ADD_FLAG("CFLAGS_SQLITE3", "/D SQLITE_THREADSAFE=1 /D SQLITE_ENABLE_FTS3=1 /D SQLITE_CORE=1 "); + EXTENSION("sqlite3", "sqlite3.c", null, "/I" + configure_module_dirname + "/libsqlite /I" + configure_module_dirname); + + ADD_SOURCES(configure_module_dirname + "/libsqlite", "sqlite3.c", "sqlite3"); + + AC_DEFINE("HAVE_SQLITE3", 1, "SQLite support"); + + if (!PHP_SQLITE3_SHARED) { + ADD_DEF_FILE(configure_module_dirname + "\\php_sqlite3.def"); + } +} diff --git a/ext/sqlite3/config0.m4 b/ext/sqlite3/config0.m4 new file mode 100644 index 0000000000..758e7c7cb3 --- /dev/null +++ b/ext/sqlite3/config0.m4 @@ -0,0 +1,86 @@ +dnl $Id$ +dnl config.m4 for extension sqlite3 +dnl vim:et:ts=2:sw=2 + +PHP_ARG_WITH(sqlite3, whether to enable the SQLite3 extension, +[ --with-sqlite3[=DIR] Include SQLite3 support. DIR is the prefix to + SQLite3 installation directory.], no) + +if test $PHP_SQLITE3 != "no"; then + sqlite3_extra_sources="" + PHP_SQLITE3_CFLAGS="" + + dnl when running phpize enable_maintainer_zts is not available + if test -z "$enable_maintainer_zts"; then + if test -f "$phpincludedir/main/php_config.h"; then + ZTS=`grep '#define ZTS' $phpincludedir/main/php_config.h|$SED 's/#define ZTS//'` + if test "$ZTS" -eq "1"; then + enable_maintainer_zts="yes" + fi + fi + fi + + if test $PHP_SQLITE3 != "yes"; then + AC_MSG_CHECKING([for sqlite3 files in default path]) + for i in $PHP_SQLITE3 /usr/local /usr; do + if test -r $i/include/sqlite3.h; then + SQLITE3_DIR=$i + AC_MSG_RESULT(found in $i) + break + fi + done + + if test -z "$SQLITE3_DIR"; then + AC_MSG_RESULT([not found]) + AC_MSG_ERROR([Please reinstall the sqlite distribution from http://www.sqlite.org]) + fi + + AC_MSG_CHECKING([for SQLite 3.3.9+]) + PHP_CHECK_LIBRARY(sqlite3, sqlite3_prepare_v2, [ + AC_MSG_RESULT(found) + PHP_ADD_LIBRARY_WITH_PATH(sqlite3, $SQLITE3_DIR/$PHP_LIBDIR, SQLITE3_SHARED_LIBADD) + PHP_ADD_INCLUDE($SQLITE3_DIR/include) + ],[ + AC_MSG_RESULT([not found]) + AC_MSG_ERROR([Please install SQLite 3.3.9 first or check libsqlite3 is present]) + ],[ + -L$SQLITE3_DIR/$PHP_LIBDIR -lm + ]) + + PHP_CHECK_LIBRARY(sqlite3,sqlite3_key,[ + AC_DEFINE(HAVE_SQLITE3_KEY, 1, [have commercial sqlite3 with crypto support]) + ]) + + else + AC_MSG_CHECKING([built in sqlite3 library]) + AC_MSG_RESULT([yes]) + + sqlite3_extra_sources="libsqlite/sqlite3.c" + + if test "$enable_maintainer_zts" = "yes"; then + threadsafe_flags="-DSQLITE_THREADSAFE=1" + else + threadsafe_flags="-DSQLITE_THREADSAFE=0" + fi + + if test "$ZEND_DEBUG" = "yes"; then + debug_flags="-DSQLITE_DEBUG=1" + fi + + other_flags="-DSQLITE_ENABLE_FTS3=1 -DSQLITE_CORE=1" + +dnl if test "$PHP_MAJOR_VERSION" -ge "6"; then +dnl other_flags="$other_flags -DSQLITE_ENABLE_ICU=1" +dnl fi + + PHP_SQLITE3_CFLAGS="-I@ext_srcdir@/libsqlite -I@ext_builddir@/libsqlite $other_flags $threadsafe_flags $debug_flags" + fi + + AC_DEFINE(HAVE_SQLITE3,1,[ ]) + + sqlite3_sources="sqlite3.c $sqlite3_extra_sources" + + PHP_NEW_EXTENSION(sqlite3, $sqlite3_sources, $ext_shared, ,$PHP_SQLITE3_CFLAGS) + PHP_SUBST(SQLITE3_SHARED_LIBADD) + +fi diff --git a/ext/sqlite3/php_sqlite3.h b/ext/sqlite3/php_sqlite3.h new file mode 100644 index 0000000000..63e8749fbf --- /dev/null +++ b/ext/sqlite3/php_sqlite3.h @@ -0,0 +1,310 @@ +/* + + +----------------------------------------------------------------------+ + + | PHP Version 5 | + + +----------------------------------------------------------------------+ + + | Copyright (c) 1997-2008 The PHP Group | + + +----------------------------------------------------------------------+ + + | This source file is subject to version 3.01 of the PHP license, | + + | that is bundled with this package in the file LICENSE, and is | + + | available through the world-wide-web at the following url: | + + | http://www.php.net/license/3_01.txt | + + | If you did not receive a copy of the PHP license and are unable to | + + | obtain it through the world-wide-web, please send a note to | + + | license@php.net so we can mail you a copy immediately. | + + +----------------------------------------------------------------------+ + + | Authors: Scott MacVicar | + + +----------------------------------------------------------------------+ + + + + $Id$ + +*/ + + + +#ifndef PHP_SQLITE_H + +#define PHP_SQLITE_H + + + +#ifdef HAVE_CONFIG_H + +#include "config.h" + +#endif + + + +#ifdef ZTS + +#include "TSRM.h" + +#endif + + + +/* Include PHP Standard Header */ + +#include "php.h" + + + +/* Include headers */ + +#include + + + +#define PHP_SQLITE3_VERSION "0.7-dev" + + + +extern zend_module_entry sqlite3_module_entry; + +#define phpext_sqlite3_ptr &sqlite3_module_entry + + + +ZEND_BEGIN_MODULE_GLOBALS(sqlite3) + + char *extension_dir; + +ZEND_END_MODULE_GLOBALS(sqlite3) + + + +#ifdef ZTS + +# define SQLITE3G(v) TSRMG(sqlite3_globals_id, zend_sqlite3_globals *, v) + +#else + +# define SQLITE3G(v) (sqlite3_globals.v) + +#endif + + + +#define PHP_SQLITE3_ASSOC 1<<0 + +#define PHP_SQLITE3_NUM 1<<1 + +#define PHP_SQLITE3_BOTH (PHP_SQLITE3_ASSOC|PHP_SQLITE3_NUM) + + + +/* for backwards compatability reasons */ + +#ifndef SQLITE_OPEN_READONLY + +#define SQLITE_OPEN_READONLY 0x00000001 + +#endif + + + +#ifndef SQLITE_OPEN_READWRITE + +#define SQLITE_OPEN_READWRITE 0x00000002 + +#endif + + + +#ifndef SQLITE_OPEN_CREATE + +#define SQLITE_OPEN_CREATE 0x00000004 + +#endif + + + +/* Structure for SQLite Statement Parameter. */ + +struct php_sqlite3_bound_param { + + long param_number; + + char *name; + + int name_len; + + int type; + + + + zval *parameter; + +}; + + + +struct php_sqlite3_fci { + + zend_fcall_info fci; + + zend_fcall_info_cache fcc; + +}; + + + +/* Structure for SQLite function. */ + +typedef struct _php_sqlite3_func { + + struct _php_sqlite3_func *next; + + + + const char *func_name; + + int argc; + + + + zval *func, *step, *fini; + + struct php_sqlite3_fci afunc, astep, afini; + +} php_sqlite3_func; + + + +/* Structure for SQLite Database object. */ + +typedef struct _php_sqlite3_db_object { + + zend_object zo; + + int initialised; + + sqlite3 *db; + + php_sqlite3_func *funcs; + +} php_sqlite3_db_object; + + + +/*typedef struct _php_sqlite3_stmt { + + sqlite3_stmt *stmt; + + int initialised; + +} php_sqlite3_stmt;*/ + + + +typedef struct _php_sqlite3_stmt_object php_sqlite3_stmt; + +typedef struct _php_sqlite3_result_object php_sqlite3_result; + + + +/* sqlite3 objects to be destroyed */ + +typedef struct _php_sqlite3_stmt_free_list { + + sqlite3_stmt *stmt; + + + + zval *statement_object; + + zval *result_object; + +} php_sqlite3_stmt_free_list; + + + +/* Structure for SQLite Result object. */ + +struct _php_sqlite3_result_object { + + zend_object zo; + + php_sqlite3_db_object *db_obj; + + php_sqlite3_stmt *stmt_obj; + + zval *stmt_obj_zval; + + + + int initialised; + + + + int is_prepared_statement; + + int complete; + +}; + + + +/* Structure for SQLite Statement object. */ + +struct _php_sqlite3_stmt_object { + + zend_object zo; + + sqlite3_stmt *stmt; + + php_sqlite3_db_object *db_obj; + + zval *db_obj_zval; + + + + int initialised; + + + + /* Keep track of the zvals for bound parameters */ + + HashTable *bound_params; + +}; + + + +#endif + + + + + +/* + + * Local variables: + + * tab-width: 4 + + * c-basic-offset: 4 + + * indent-tabs-mode: t + + * End: + + */ + diff --git a/ext/sqlite3/sqlite3.c b/ext/sqlite3/sqlite3.c new file mode 100644 index 0000000000..77e8e76dba --- /dev/null +++ b/ext/sqlite3/sqlite3.c @@ -0,0 +1,1901 @@ +/* + +----------------------------------------------------------------------+ + | PHP Version 5 | + +----------------------------------------------------------------------+ + | Copyright (c) 1997-2008 The PHP Group | + +----------------------------------------------------------------------+ + | This source file is subject to version 3.01 of the PHP license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.php.net/license/3_01.txt | + | If you did not receive a copy of the PHP license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@php.net so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ + | Authors: Scott MacVicar | + +----------------------------------------------------------------------+ + + $Id$ +*/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "php.h" +#include "php_ini.h" +#include "ext/standard/info.h" +#include "ext/standard/file.h" +#include "php_sqlite3.h" + +#include + +#include "zend_exceptions.h" +#include "zend_interfaces.h" + +ZEND_DECLARE_MODULE_GLOBALS(sqlite3) +static PHP_GINIT_FUNCTION(sqlite3); +static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, + const char *arg5, const char *arg6); +static void sqlite3_param_dtor(void *data); +static int php_sqlite3_compare_stmt_free( php_sqlite3_stmt_free_list **stmt_list, sqlite3_stmt *statement ); + +#define SQLITE3_CHECK_INITIALIZED(member, class_name) \ + if (!(member)) { \ + php_error_docref(NULL TSRMLS_CC, E_WARNING, "The " #class_name " object has not been correctly initialised"); \ + RETURN_FALSE; \ + } + +/* {{{ PHP_INI + */ +PHP_INI_BEGIN() + STD_PHP_INI_ENTRY("sqlite3.extension_dir", NULL, PHP_INI_SYSTEM, OnUpdateString, extension_dir, zend_sqlite3_globals, sqlite3_globals) +PHP_INI_END() +/* }}} */ + +/* Handlers */ +static zend_object_handlers sqlite3_object_handlers; +static zend_object_handlers sqlite3_stmt_object_handlers; +static zend_object_handlers sqlite3_result_object_handlers; + +/* Class entries */ +zend_class_entry *php_sqlite3_sc_entry; +zend_class_entry *php_sqlite3_stmt_entry; +zend_class_entry *php_sqlite3_result_entry; + +/* {{{ proto bool SQLite3::open(String filename [, int Flags [, string Encryption Key]]) U + Opens a SQLite 3 Database, if the build includes encryption then it will attempt to use the key +*/ +PHP_METHOD(sqlite3, open) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + char *filename, *encryption_key, *fullpath; + zend_uchar filename_type; + int filename_len, encryption_key_len, flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "t|lS", + &filename, &filename_len, &filename_type, &flags, &encryption_key, &encryption_key_len)) { + return; + } + + if (db_obj->initialised) { + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Already initialised DB Object"); + } + + if (filename_type == IS_UNICODE) { + if (php_stream_path_encode(NULL, &filename, &filename_len, (UChar *)filename, filename_len, REPORT_ERRORS, FG(default_context)) == FAILURE) { + RETURN_FALSE; + } + } + + if (strncmp(filename, ":memory:", 8) != 0) { + if (!(fullpath = expand_filepath(filename, NULL TSRMLS_CC))) { + if (filename_type == IS_UNICODE) { + efree(filename); + } + RETURN_FALSE; + } + + if (php_check_open_basedir(fullpath TSRMLS_CC)) { + if (filename_type == IS_UNICODE) { + efree(filename); + } + efree(fullpath); + RETURN_FALSE; + } + } else { + fullpath = estrdup(filename); + } + + if (filename_type == IS_UNICODE) { + efree(filename); + } + +#if SQLITE_VERSION_NUMBER >= 3005000 + if (sqlite3_open_v2(fullpath, &(db_obj->db), flags, NULL) != SQLITE_OK) { +#else + /* Todo: utf-16 = sqlite3_open16 */ + if (sqlite3_open(fullpath, &(db_obj->db)) != SQLITE_OK) { +#endif + php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unable to open database: %s", sqlite3_errmsg(db_obj->db)); + if (fullpath) { + efree(fullpath); + } + return; + } + + db_obj->initialised = 1; + +#if SQLITE_HAS_CODEC + if (encryption_key_len > 0) { + if (sqlite3_key(db_obj->db, encryption_key, encryption_key_len) != SQLITE_OK) { + return; + } + } +#endif + + if ((PG(open_basedir) && *PG(open_basedir))) { + sqlite3_set_authorizer(db_obj->db, php_sqlite3_authorizer, NULL); + } + + if (fullpath) { + efree(fullpath); + } + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto bool SQLite3::close() U + Close a SQLite 3 Database. +*/ +PHP_METHOD(sqlite3, close) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + int errcode; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + if (db_obj->initialised) { + errcode = sqlite3_close(db_obj->db); + if (errcode != SQLITE_OK) { + RETURN_TRUE; + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to close database: %d, %s", errcode, sqlite3_errmsg(db_obj->db)); + RETURN_FALSE; + } + db_obj->initialised = 0; + } + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto bool SQLite3::exec(String Query) U + Executes a result-less query against a given database +*/ +PHP_METHOD(sqlite3, exec) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + char *sql, *errtext = NULL; + int sql_len; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s&", + &sql, &sql_len, UG(utf8_conv))) { + return; + } + + if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext); + sqlite3_free(errtext); + RETURN_FALSE; + } + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto Array SQLite3::version() U + Returns the SQLite3 Library version as a string constant and as a number. +*/ +PHP_METHOD(sqlite3, version) +{ + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + array_init(return_value); + + add_assoc_utf8_string(return_value, "versionString", (char*)sqlite3_libversion(), 1); + add_assoc_long(return_value, "versionNumber", sqlite3_libversion_number()); + + return; +} +/* }}} */ + +/* {{{ proto int SQLite3::lastInsertRowID() U + Returns the rowid of the most recent INSERT into the database from the database connection. +*/ +PHP_METHOD(sqlite3, lastInsertRowID) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + RETURN_LONG(sqlite3_last_insert_rowid(db_obj->db)); +} +/* }}} */ + +/* {{{ proto int SQLite3::lastErrorCode() U + Returns the numeric result code of the most recent failed sqlite API call for the database connection. +*/ +PHP_METHOD(sqlite3, lastErrorCode) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + RETURN_LONG(sqlite3_errcode(db_obj->db)); +} +/* }}} */ + +/* {{{ proto string SQLite3::lastErrorMsg() U + Returns english text describing the most recent failed sqlite API call for the database connection. +*/ +PHP_METHOD(sqlite3, lastErrorMsg) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + RETVAL_UNICODE((UChar *)sqlite3_errmsg16(db_obj->db), 1); +} +/* }}} */ + +/* {{{ proto bool SQLite3::loadExtension(String Shared Library) + Attempts to load an SQLite extension library +*/ +PHP_METHOD(sqlite3, loadExtension) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + char *extension, *lib_path, *extension_dir, *errtext = NULL; + char fullpath[MAXPATHLEN]; + int extension_len, extension_dir_len; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", + &extension, &extension_len)) { + return; + } + + if (!SQLITE3G(extension_dir)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "SQLite Extension are disabled"); + RETURN_FALSE; + } + + if (extension_len == 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty string as an extension"); + RETURN_FALSE; + } + + extension_dir = SQLITE3G(extension_dir); + extension_dir_len = strlen(SQLITE3G(extension_dir)); + + if (IS_SLASH(extension_dir[extension_dir_len-1])) { + spprintf(&lib_path, 0, "%s%s", extension_dir, extension); + } else { + spprintf(&lib_path, 0, "%s%c%s", extension_dir, DEFAULT_SLASH, extension); + } + + if (!VCWD_REALPATH(lib_path, fullpath)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to load extension at '%s'", lib_path); + efree(lib_path); + RETURN_FALSE; + } + + efree(lib_path); + + if (strncmp(fullpath, extension_dir, extension_dir_len) != 0) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to open extensions outside the defined directory"); + RETURN_FALSE; + } + + /* Extension loading should only be enabled for when we attempt to load */ + sqlite3_enable_load_extension(db_obj->db, 1); + if (sqlite3_load_extension(db_obj->db, fullpath, 0, &errtext) != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext); + sqlite3_free(errtext); + sqlite3_enable_load_extension(db_obj->db, 0); + RETURN_FALSE; + } + sqlite3_enable_load_extension(db_obj->db, 0); + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto int SQLite3::changes() U + Returns the number of database rows that were changed (or inserted or deleted) by the most recent SQL statement. +*/ +PHP_METHOD(sqlite3, changes) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + RETURN_LONG(sqlite3_changes(db_obj->db)); +} +/* }}} */ + +/* {{{ proto String SQLite3::escapeString(String value) U + Returns a string that has been properly escaped +*/ +PHP_METHOD(sqlite3, escapeString) +{ + char *sql, *ret; + int sql_len; + + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s&", + &sql, &sql_len, UG(utf8_conv))) { + return; + } + + if (sql_len) { + ret = sqlite3_mprintf("%q", sql); + if (ret) { + RETVAL_STRING(ret, 1); + sqlite3_free(ret); + } + } else { + RETURN_EMPTY_STRING(); + } +} +/* }}} */ + +/* {{{ proto sqlite3_stmt SQLite3::prepare(String Query) + Returns a prepared SQL statement for execution +*/ +PHP_METHOD(sqlite3, prepare) +{ + php_sqlite3_db_object *db_obj; + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + char *sql; + int sql_len, errcode; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", + &sql, &sql_len)) { + return; + } + + if (!sql_len) { + RETURN_FALSE; + } + + object_init_ex(return_value, php_sqlite3_stmt_entry); + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(return_value TSRMLS_CC); + stmt_obj->db_obj = db_obj; + stmt_obj->db_obj_zval = getThis(); + + Z_ADDREF_P(object); + + /* Todo: utf-8 or utf-16 = sqlite3_prepare16_v2 */ + errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL); + if (errcode != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to prepare statement: %d, %s", errcode, sqlite3_errmsg(db_obj->db)); + zval_dtor(return_value); + RETURN_FALSE; + } +} +/* }}} */ + +/* {{{ proto sqlite3_result SQLite3::query(String Query) + Returns true or false, for queries that return data it will return a sqlite3_result object +*/ +PHP_METHOD(sqlite3, query) +{ + php_sqlite3_db_object *db_obj; + php_sqlite3_result *result; + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + zval *stmt = NULL; + char *sql, *errtext = NULL; + int sql_len, return_code; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", + &sql, &sql_len)) { + return; + } + + if (!sql_len) { + RETURN_FALSE; + } + + /* If there was no return value then just execute the query */ + if (!return_value_used) { + /* Todo: utf-8 */ + if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext); + sqlite3_free(errtext); + } + return; + } + + MAKE_STD_ZVAL(stmt); + + object_init_ex(stmt, php_sqlite3_stmt_entry); + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(stmt TSRMLS_CC); + stmt_obj->db_obj = db_obj; + stmt_obj->db_obj_zval = getThis(); + + Z_ADDREF_P(object); + + /* Todo: utf-8 or utf-16 = sqlite3_prepare16_v2 */ + return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL); + if (return_code != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to prepare statement: %d, %s", return_code, sqlite3_errmsg(db_obj->db)); + zval_ptr_dtor(&stmt); + RETURN_FALSE; + } + + object_init_ex(return_value, php_sqlite3_result_entry); + result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC); + result->db_obj = db_obj; + result->stmt_obj = stmt_obj; + result->stmt_obj_zval = stmt; + + result->initialised = 1; + return_code = sqlite3_step(result->stmt_obj->stmt); + + switch (return_code) { + case SQLITE_ROW: /* Valid Row */ + case SQLITE_DONE: /* Valid but no results */ + { + /*php_sqlite3_stmt_free_list *free_item; + free_item = emalloc(sizeof(php_sqlite3_stmt_free_list)); + free_item->stmt = result->intern_stmt; + free_item->statement_object = NULL; + free_item->result_object = return_value; + zend_llist_add_element(&(db_obj->stmt_list), &free_item);*/ + sqlite3_reset(result->stmt_obj->stmt); + break; + } + default: + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(db_obj->db)); + sqlite3_finalize(result->stmt_obj->stmt); + zval_dtor(return_value); + RETURN_FALSE; + } +} +/* }}} */ + +static zval* sqlite_value_to_zval(sqlite3_stmt *stmt, int column) +{ + zval *data; + MAKE_STD_ZVAL(data); + switch (sqlite3_column_type(stmt, column)) { + case SQLITE_INTEGER: + if ((sqlite3_column_int64(stmt, column)) >= INT_MAX || sqlite3_column_int64(stmt, column) <= INT_MIN) { + ZVAL_STRINGL(data, (char *)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column), 1); + } else { + ZVAL_LONG(data, sqlite3_column_int64(stmt, column)); + } + break; + + case SQLITE_FLOAT: + ZVAL_DOUBLE(data, sqlite3_column_double(stmt, column)); + break; + + case SQLITE_NULL: + ZVAL_NULL(data); + break; + + case SQLITE3_TEXT: + ZVAL_UNICODE(data, (UChar*)sqlite3_column_text16(stmt, column), 1); + /*ZVAL_STRING(data, (char*)sqlite3_column_text(stmt, column), 1);*/ + break; + + case SQLITE_BLOB: + default: + ZVAL_STRINGL(data, (char*)sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column), 1); + } + return data; +} + +/* {{{ proto sqlite3_result SQLite3::querySingle(String Query [, entire_row = false]) + Returns a string of the first column, or an array of the entire row +*/ +PHP_METHOD(sqlite3, querySingle) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + char *sql, *errtext = NULL; + int sql_len, return_code, entire_row = 0; + sqlite3_stmt *stmt; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", + &sql, &sql_len, &entire_row)) { + return; + } + + if (!sql_len) { + RETURN_FALSE; + } + + /* If there was no return value then just execute the query */ + if (!return_value_used) { + /* Todo: utf-8 */ + if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", errtext); + sqlite3_free(errtext); + } + return; + } + + /* Todo: utf-8 or utf-16 = sqlite3_prepare16_v2 */ + return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &stmt, NULL); + if (return_code != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to prepare statement: %d, %s", return_code, sqlite3_errmsg(db_obj->db)); + RETURN_FALSE; + } + + + return_code = sqlite3_step(stmt); + + switch (return_code) { + case SQLITE_ROW: /* Valid Row */ + { + if (!entire_row) { + zval *data; + data = sqlite_value_to_zval(stmt, 0); + *return_value = *data; + zval_copy_ctor(return_value); + zval_dtor(data); + FREE_ZVAL(data); + } else { + int i = 0; + array_init(return_value); + for (i = 0; i < sqlite3_data_count(stmt); i++) { + zval *data; + UChar *ustr = (UChar *)sqlite3_column_name16(stmt, i); + data = sqlite_value_to_zval(stmt, i); + + add_u_assoc_zval(return_value, IS_UNICODE, ZSTR(ustr), data); + /*add_assoc_zval(return_value, (char*)sqlite3_column_name(stmt, i), data);*/ + } + } + break; + } + case SQLITE_DONE: /* Valid but no results */ + { + if (!entire_row) { + RETVAL_NULL(); + } else { + array_init(return_value); + } + break; + } + default: + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(db_obj->db)); + RETVAL_FALSE; + } + sqlite3_finalize(stmt); +} +/* }}} */ + +static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, + int argc, sqlite3_value **argv, sqlite3_context *context, + int is_agg TSRMLS_DC) +{ + zval ***zargs = NULL; + zval *retval = NULL; + int i; + int ret; + int fake_argc; + zval **agg_context = NULL; + + if (is_agg) { + is_agg = 2; + } + + fake_argc = argc + is_agg; + + fc->fci.size = sizeof(fc->fci); + fc->fci.function_table = EG(function_table); + fc->fci.function_name = cb; + fc->fci.symbol_table = NULL; + fc->fci.object_pp = NULL; + fc->fci.retval_ptr_ptr = &retval; + fc->fci.param_count = fake_argc; + + /* build up the params */ + + if (fake_argc) { + zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0); + } + + if (is_agg) { + /* summon the aggregation context */ + agg_context = (zval**)sqlite3_aggregate_context(context, sizeof(zval*)); + if (!*agg_context) { + MAKE_STD_ZVAL(*agg_context); + ZVAL_NULL(*agg_context); + } + zargs[0] = agg_context; + + zargs[1] = emalloc(sizeof(zval*)); + MAKE_STD_ZVAL(*zargs[1]); + ZVAL_LONG(*zargs[1], sqlite3_aggregate_count(context)); + } + + for (i = 0; i < argc; i++) { + zargs[i + is_agg] = emalloc(sizeof(zval *)); + MAKE_STD_ZVAL(*zargs[i + is_agg]); + + switch (sqlite3_value_type(argv[i])) { + case SQLITE_INTEGER: + ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i])); + break; + + case SQLITE_FLOAT: + ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i])); + break; + + case SQLITE_NULL: + ZVAL_NULL(*zargs[i + is_agg]); + break; + + case SQLITE_BLOB: + case SQLITE3_TEXT: + default: + /* Todo: utf-8 / utf-16 and proper blob stuff */ + ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), + sqlite3_value_bytes(argv[i]), 1); + break; + } + } + + fc->fci.params = zargs; + + if ((ret = zend_call_function(&fc->fci, &fc->fcc TSRMLS_CC)) == FAILURE) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback"); + } + + /* clean up the params */ + if (fake_argc) { + for (i = is_agg; i < argc + is_agg; i++) { + zval_ptr_dtor(zargs[i]); + efree(zargs[i]); + } + if (is_agg) { + zval_ptr_dtor(zargs[1]); + efree(zargs[1]); + } + efree(zargs); + } + + if (!is_agg || !argv) { + /* only set the sqlite return value if we are a scalar function, + * or if we are finalizing an aggregate */ + if (retval) { + switch (Z_TYPE_P(retval)) { + case IS_LONG: + sqlite3_result_int(context, Z_LVAL_P(retval)); + break; + + case IS_NULL: + sqlite3_result_null(context); + break; + + case IS_DOUBLE: + sqlite3_result_double(context, Z_DVAL_P(retval)); + break; + + default: + /* Todo: utf-8 or utf-16 = sqlite3_result_text16 */ + convert_to_string_ex(&retval); + sqlite3_result_text(context, Z_STRVAL_P(retval), + Z_STRLEN_P(retval), SQLITE_TRANSIENT); + break; + } + } else { + sqlite3_result_error(context, "failed to invoke callback", 0); + } + + if (agg_context) { + zval_ptr_dtor(agg_context); + } + } else { + /* we're stepping in an aggregate; the return value goes into + * the context */ + if (agg_context) { + zval_ptr_dtor(agg_context); + } + if (retval) { + *agg_context = retval; + retval = NULL; + } else { + *agg_context = NULL; + } + } + + if (retval) { + zval_ptr_dtor(&retval); + } + + return ret; +} + +static void php_sqlite3_callback_func(sqlite3_context *context, int argc, sqlite3_value **argv) +{ + php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context); + TSRMLS_FETCH(); + + sqlite3_do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC); +} + +static void php_sqlite3_callback_step(sqlite3_context *context, int argc, sqlite3_value **argv) +{ + php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context); + TSRMLS_FETCH(); + + sqlite3_do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC); +} + +static void php_sqlite3_callback_final(sqlite3_context *context) +{ + php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context); + TSRMLS_FETCH(); + + sqlite3_do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC); +} + +/* {{{ proto bool SQLite3::createFunction(string name, mixed callback [, int argcount])) + Allows registration of a PHP function as a SQLite UDF that can be called within SQL statements +*/ +PHP_METHOD(sqlite3, createFunction) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + php_sqlite3_func *func; + char *sql_func; + int sql_func_len; + zval *callback_func, callback_name; + long sql_func_num_args = -1; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &sql_func, &sql_func_len, &callback_func, &sql_func_num_args) == FAILURE) { + return; + } + + if (!sql_func_len) { + RETURN_FALSE; + } + + if (!zend_is_callable(callback_func, 0, &callback_name)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback function %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name)); + zval_dtor(&callback_name); + RETURN_FALSE; + } + zval_dtor(&callback_name); + + func = (php_sqlite3_func *)ecalloc(1, sizeof(*func)); + + /* Todo: utf-8 or utf-16 = sqlite3_create_function16 */ + if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, php_sqlite3_callback_func, NULL, NULL) == SQLITE_OK) { + func->func_name = estrdup(sql_func); + + MAKE_STD_ZVAL(func->func); + *(func->func) = *callback_func; + zval_copy_ctor(func->func); + + func->argc = sql_func_num_args; + func->next = db_obj->funcs; + db_obj->funcs = func; + + RETURN_TRUE; + } + efree(func); + + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto bool SQLite3::createAggregate(string name, mixed step, mixed final [, int argcount])) + Allows registration of a PHP function for use as an aggregate +*/ +PHP_METHOD(sqlite3, createAggregate) +{ + php_sqlite3_db_object *db_obj; + zval *object = getThis(); + php_sqlite3_func *func; + char *sql_func; + int sql_func_len; + zval *step_callback, *fini_callback, callback_name; + long sql_func_num_args = -1; + db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(db_obj->initialised, SQLite3) + + 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) { + return; + } + + if (!sql_func_len) { + RETURN_FALSE; + } + + if (!zend_is_callable(step_callback, 0, &callback_name)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback function %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name)); + zval_dtor(&callback_name); + RETURN_FALSE; + } + zval_dtor(&callback_name); + + if (!zend_is_callable(fini_callback, 0, &callback_name)) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not a valid callback function %R", Z_TYPE(callback_name), Z_UNIVAL(callback_name)); + zval_dtor(&callback_name); + RETURN_FALSE; + } + zval_dtor(&callback_name); + + func = (php_sqlite3_func *)ecalloc(1, sizeof(*func)); + + /* Todo: utf-8 or utf-16 = sqlite3_create_function16 */ + 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) { + func->func_name = estrdup(sql_func); + + MAKE_STD_ZVAL(func->step); + *(func->step) = *step_callback; + zval_copy_ctor(func->step); + + MAKE_STD_ZVAL(func->fini); + *(func->fini) = *fini_callback; + zval_copy_ctor(func->fini); + + func->argc = sql_func_num_args; + func->next = db_obj->funcs; + db_obj->funcs = func; + + RETURN_TRUE; + } + efree(func); + + RETURN_FALSE; +} +/* }}} */ + +/* {{{ proto int SQLite3_stmt::paramCount() U + Returns the number of parameters within the prepared statement +*/ +PHP_METHOD(sqlite3_stmt, paramCount) +{ + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + RETURN_LONG(sqlite3_bind_parameter_count(stmt_obj->stmt)); +} +/* }}} */ + +/* {{{ proto bool SQLite3_stmt::close() U + Closes the prepared statement +*/ +PHP_METHOD(sqlite3_stmt, close) +{ + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + /*zend_llist_del_element(&(stmt_obj->db_obj->stmt_list), stmt_obj->stmt, + (int (*)(void *, void *)) php_sqlite3_compare_stmt_free);*/ + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto bool SQLite3_stmt::reset() U + Reset the prepared statement to the state before it was executed, bindings still remain. +*/ +PHP_METHOD(sqlite3_stmt, reset) +{ + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + if (sqlite3_reset(stmt_obj->stmt) != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to reset statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt))); + RETURN_FALSE; + } + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto bool SQLite3_stmt::clear() U + Clear all current bound parameters +*/ +PHP_METHOD(sqlite3_stmt, clear) +{ + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + if (sqlite3_clear_bindings(stmt_obj->stmt) != SQLITE_OK) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt))); + RETURN_FALSE; + } + + RETURN_TRUE; +} +/* }}} */ + +static int register_bound_parameter_to_sqlite(struct php_sqlite3_bound_param *param, php_sqlite3_stmt *stmt TSRMLS_DC) /* {{{ */ +{ + HashTable *hash; + hash = stmt->bound_params; + + if (!hash) { + ALLOC_HASHTABLE(hash); + zend_hash_init(hash, 13, NULL, sqlite3_param_dtor, 0); + stmt->bound_params = hash; + } + + /* We need a : prefix to resolve a name to a parameter number */ + if (param->name) { + if (param->name[0] != ':') { + /* pre-increment for character + 1 for null */ + char *temp = emalloc(++param->name_len + 1); + temp[0] = ':'; + memmove(temp+1, param->name, param->name_len); + param->name = temp; + } else { + param->name = estrndup(param->name, param->name_len); + } + /* do lookup*/ + param->param_number = sqlite3_bind_parameter_index(stmt->stmt, param->name); + } + + if (param->param_number < 1) { + efree(param->name); + return 0; + } + + if (param->param_number >= 1) { + zend_hash_index_del(hash, param->param_number); + } + + if (param->name) { + zend_hash_update(hash, param->name, param->name_len, param, sizeof(*param), NULL); + } else { + zend_hash_index_update(hash, param->param_number, param, sizeof(*param), NULL); + } + + return 1; +} +/* }}} */ + +/* {{{ proto bool SQLite3_stmt::bindParam(int parameter_number, mixed parameter [, int type]) + Bind Paramater to a stmt variable +*/ +PHP_METHOD(sqlite3_stmt, bindParam) +{ + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + struct php_sqlite3_bound_param param = {0}; + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); + + param.param_number = -1; + param.type = SQLITE3_TEXT; + + if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", + ¶m.param_number, ¶m.parameter, ¶m.type) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", + ¶m.name, ¶m.name_len, ¶m.parameter, ¶m.type) == FAILURE) { + return; + } + } + + Z_ADDREF_P(param.parameter); + + if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) { + if (param.parameter) { + zval_ptr_dtor(&(param.parameter)); + param.parameter = NULL; + } + RETURN_FALSE; + } + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto bool SQLite3_stmt::bindValue(inte parameter_number, mixed parameter [, int type]) + Bind Value of a parameter to a stmt variable +*/ +PHP_METHOD(sqlite3_stmt, bindValue) +{ + php_sqlite3_stmt *stmt_obj; + zval *object = getThis(); + struct php_sqlite3_bound_param param = {0}; + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); + + param.param_number = -1; + param.type = SQLITE3_TEXT; + + if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", + ¶m.param_number, ¶m.parameter, ¶m.type) == FAILURE) { + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|l", + ¶m.name, ¶m.name_len, ¶m.parameter, ¶m.type) == FAILURE) { + return; + } + } + + Z_ADDREF_P(param.parameter); + + if (!register_bound_parameter_to_sqlite(¶m, stmt_obj TSRMLS_CC)) { + if (param.parameter) { + zval_ptr_dtor(&(param.parameter)); + param.parameter = NULL; + } + RETURN_FALSE; + } + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto SQLite3_result SQLite3_stmt::execute() + Executes a prepared statement and returns a result set object +*/ +PHP_METHOD(sqlite3_stmt, execute) +{ + php_sqlite3_stmt *stmt_obj; + php_sqlite3_result *result; + zval *object = getThis(); + int return_code = 0; + struct php_sqlite3_bound_param *param; + stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC); + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + if (stmt_obj->bound_params) { + zend_hash_internal_pointer_reset(stmt_obj->bound_params); + while (zend_hash_get_current_data(stmt_obj->bound_params, (void **)¶m) == SUCCESS) { + /* If the ZVAL is null then it should be bound as that */ + if (Z_TYPE_P(param->parameter) == IS_NULL) { + sqlite3_bind_null(stmt_obj->stmt, param->param_number); + continue; + } + + switch (param->type) { + case SQLITE_INTEGER: + convert_to_long(param->parameter); + sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter)); + break; + + case SQLITE_FLOAT: + /* convert_to_double(param->parameter);*/ + sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(param->parameter)); + break; + + case SQLITE_BLOB: + { + php_stream *stream = NULL; + int blength; + char *buffer = NULL; + if (Z_TYPE_P(param->parameter) == IS_RESOURCE) { + php_stream_from_zval_no_verify(stream, ¶m->parameter); + if (stream == NULL) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to read stream for parameter %ld", param->param_number); + RETURN_FALSE; + } + blength = php_stream_copy_to_mem(stream, (void *)&buffer, PHP_STREAM_COPY_ALL, 0); + } else { + convert_to_string(param->parameter); + blength = Z_STRLEN_P(param->parameter); + buffer = Z_STRVAL_P(param->parameter); + } + + sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer, blength, SQLITE_TRANSIENT); + + if (stream) { + pefree(buffer, 0); + } + break; + } + + case SQLITE3_TEXT: + convert_to_string(param->parameter); + /* Todo: utf-8 or utf-16 = sqlite3_bind_text16 */ + sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(param->parameter), Z_STRLEN_P(param->parameter), SQLITE_STATIC); + break; + + case SQLITE_NULL: + sqlite3_bind_null(stmt_obj->stmt, param->param_number); + break; + + default: + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown parameter type: %d for parameter %ld", param->type, param->param_number); + RETURN_FALSE; + } + zend_hash_move_forward(stmt_obj->bound_params); + } + } + + return_code = sqlite3_step(stmt_obj->stmt); + + switch (return_code) { + case SQLITE_ROW: /* Valid Row */ + case SQLITE_DONE: /* Valid but no results */ + { + sqlite3_reset(stmt_obj->stmt); + object_init_ex(return_value, php_sqlite3_result_entry); + result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC); + + Z_ADDREF_P(object); + + result->is_prepared_statement = 1; + result->initialised = 1; + result->db_obj = stmt_obj->db_obj; + result->stmt_obj = stmt_obj; + result->stmt_obj_zval = getThis(); + + break; + } + case SQLITE_ERROR: + sqlite3_reset(stmt_obj->stmt); + + default: + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(stmt_obj->stmt))); + zval_dtor(return_value); + RETURN_FALSE; + } + + return; +} +/* }}} */ + +/* {{{ proto int SQLite3_result::numColumns() U + Number of columns in the result set +*/ +PHP_METHOD(sqlite3_result, numColumns) +{ + php_sqlite3_result *result_obj; + zval *object = getThis(); + result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + RETURN_LONG(sqlite3_column_count(result_obj->stmt_obj->stmt)); +} +/* }}} */ + +/* {{{ proto string SQLite3_result::columnName(int column) U + Returns the name of the nth column +*/ +PHP_METHOD(sqlite3_result, columnName) +{ + php_sqlite3_result *result_obj; + zval *object = getThis(); + int column = 0; + result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) { + return; + } + + RETVAL_UNICODE((UChar*)sqlite3_column_name16(result_obj->stmt_obj->stmt, column), 1); +} +/* }}} */ + +/* {{{ proto int SQLite3_result::columnType(int column) U + Returns the type of the nth column +*/ +PHP_METHOD(sqlite3_result, columnType) +{ + php_sqlite3_result *result_obj; + zval *object = getThis(); + int column = 0; + result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &column) == FAILURE) { + return; + } + + RETURN_LONG(sqlite3_column_type(result_obj->stmt_obj->stmt, column)); +} +/* }}} */ + +/* {{{ proto array SQLite3_result::fetchArray([int mode]) U + Fetch a result row as both an associative or numerically indexed array or both +*/ +PHP_METHOD(sqlite3_result, fetchArray) +{ + php_sqlite3_result *result_obj; + zval *object = getThis(); + int i, ret, mode = PHP_SQLITE3_BOTH; + result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mode) == FAILURE) { + return; + } + + ret = sqlite3_step(result_obj->stmt_obj->stmt); + switch (ret) { + case SQLITE_ROW: + /* If there was no return value then just skip fetching */ + if (!return_value_used) { + return; + } + + array_init(return_value); + + for (i = 0; i < sqlite3_data_count(result_obj->stmt_obj->stmt); i++) { + zval *data; + + data = sqlite_value_to_zval(result_obj->stmt_obj->stmt, i); + + if (mode & PHP_SQLITE3_NUM) { + add_index_zval(return_value, i, data); + } + + if (mode & PHP_SQLITE3_ASSOC) { + UChar *ustr = (UChar *)sqlite3_column_name16(result_obj->stmt_obj->stmt, i); + if (mode & PHP_SQLITE3_NUM) { + Z_ADDREF_P(data); + } + add_u_assoc_zval(return_value, IS_UNICODE, ZSTR(ustr), data); + } + } + break; + case SQLITE_DONE: + RETURN_FALSE; + + default: + php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to execute statement: %s", sqlite3_errmsg(sqlite3_db_handle(result_obj->stmt_obj->stmt))); + } +} +/* }}} */ + +/* {{{ proto bool SQLite3_result::reset() U + Resets the result set back to the first row +*/ +PHP_METHOD(sqlite3_result, reset) +{ + php_sqlite3_result *result_obj; + zval *object = getThis(); + result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + if (sqlite3_reset(result_obj->stmt_obj->stmt) != SQLITE_OK) { + RETURN_FALSE; + } + + result_obj->complete = 0; + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ proto bool SQLite3_result::finalize() U + Closes the result set +*/ +PHP_METHOD(sqlite3_result, finalize) +{ + php_sqlite3_result *result_obj; + zval *object = getThis(); + result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC); + + SQLITE3_CHECK_INITIALIZED(result_obj->initialised, SQLite3_result) + + if (zend_parse_parameters_none() == FAILURE) { + return; + } + + /* We need to finalize an internal statement */ + if (result_obj->is_prepared_statement == 0) { + result_obj->initialised = 0; + sqlite3_finalize(result_obj->stmt_obj->stmt); + } else { + sqlite3_reset(result_obj->stmt_obj->stmt); + } + + RETURN_TRUE; +} +/* }}} */ + +/* {{{ arginfo */ +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_open, 0) + ZEND_ARG_INFO(0, filename) + ZEND_ARG_INFO(0, flags) + ZEND_ARG_INFO(0, encryption_key) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_close, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_exec, 0) + ZEND_ARG_INFO(0, query) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_version, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_lastinsertrowid, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_lasterrorcode, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_lasterrormsg, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_loadextension, 0) + ZEND_ARG_INFO(0, shared_library) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_changes, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_escapestring, 0, 0, 1) + ZEND_ARG_INFO(0, value) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_prepare, 0, 0, 1) + ZEND_ARG_INFO(0, query) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_query, 0, 0, 1) + ZEND_ARG_INFO(0, query) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_querysingle, 0, 0, 1) + ZEND_ARG_INFO(0, query) + ZEND_ARG_INFO(0, entire_row) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createfunction, 0, 0, 2) + ZEND_ARG_INFO(0, name) + ZEND_ARG_INFO(0, callback) + ZEND_ARG_INFO(0, argument_count) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_createaggregate, 0, 0, 3) + ZEND_ARG_INFO(0, name) + ZEND_ARG_INFO(0, step_callback) + ZEND_ARG_INFO(0, final_callback) + ZEND_ARG_INFO(0, argument_count) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_stmt_paramcount, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_stmt_close, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_stmt_reset, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_stmt_clear, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_stmt_execute, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_stmt_bindparam, 0, 0, 2) + ZEND_ARG_INFO(0, param_number) + ZEND_ARG_INFO(1, param) + ZEND_ARG_INFO(0, type) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_stmt_bindvalue, 0, 0, 2) + ZEND_ARG_INFO(0, param_number) + ZEND_ARG_INFO(0, param) + ZEND_ARG_INFO(0, type) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_result_numcolumns, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_result_columnname, 0, 0, 1) + ZEND_ARG_INFO(0, column_number) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_result_columntype, 0, 0, 1) + ZEND_ARG_INFO(0, column_number) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_sqlite3_result_fetcharray, 0, 0, 1) + ZEND_ARG_INFO(0, mode) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_result_reset, 0) +ZEND_END_ARG_INFO() + +static +ZEND_BEGIN_ARG_INFO(arginfo_sqlite3_result_finalize, 0) +ZEND_END_ARG_INFO() + +/* }}} */ + +/* {{{ php_sqlite3_class_methods */ +static zend_function_entry php_sqlite3_class_methods[] = { + PHP_ME(sqlite3, open, arginfo_sqlite3_open, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, close, arginfo_sqlite3_close, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, exec, arginfo_sqlite3_exec, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, version, arginfo_sqlite3_version, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + PHP_ME(sqlite3, lastInsertRowID, arginfo_sqlite3_lastinsertrowid, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, lastErrorCode, arginfo_sqlite3_lasterrorcode, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, lastErrorMsg, arginfo_sqlite3_lasterrormsg, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, loadExtension, arginfo_sqlite3_loadextension, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, changes, arginfo_sqlite3_changes, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, escapeString, arginfo_sqlite3_escapestring, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, prepare, arginfo_sqlite3_prepare, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, query, arginfo_sqlite3_query, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, querySingle, arginfo_sqlite3_querysingle, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, createFunction, arginfo_sqlite3_createfunction, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3, createAggregate, arginfo_sqlite3_createaggregate, ZEND_ACC_PUBLIC) + /* Aliases */ + PHP_MALIAS(sqlite3, __construct, open, arginfo_sqlite3_open, ZEND_ACC_PUBLIC) + {NULL, NULL, NULL} +}; +/* }}} */ + +/* {{{ php_sqlite3_stmt_class_methods */ +static zend_function_entry php_sqlite3_stmt_class_methods[] = { + PHP_ME(sqlite3_stmt, paramCount, arginfo_sqlite3_stmt_paramcount, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_stmt, close, arginfo_sqlite3_stmt_close, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_stmt, reset, arginfo_sqlite3_stmt_reset, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_stmt, clear, arginfo_sqlite3_stmt_clear, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_stmt, execute, arginfo_sqlite3_stmt_execute, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_stmt, bindParam, arginfo_sqlite3_stmt_bindparam, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_stmt, bindValue, arginfo_sqlite3_stmt_bindvalue, ZEND_ACC_PUBLIC) + {NULL, NULL, NULL} +}; +/* }}} */ + +/* {{{ php_sqlite3_result_class_methods */ +static zend_function_entry php_sqlite3_result_class_methods[] = { + PHP_ME(sqlite3_result, numColumns, arginfo_sqlite3_result_numcolumns, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_result, columnName, arginfo_sqlite3_result_columnname, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_result, columnType, arginfo_sqlite3_result_columntype, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_result, fetchArray, arginfo_sqlite3_result_fetcharray, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_result, reset, arginfo_sqlite3_result_reset, ZEND_ACC_PUBLIC) + PHP_ME(sqlite3_result, finalize, arginfo_sqlite3_result_finalize, ZEND_ACC_PUBLIC) + + {NULL, NULL, NULL} +}; +/* }}} */ + +/* {{{ Authorization Callback */ +static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, + const char *arg5, const char *arg6) +{ + TSRMLS_FETCH(); + switch (access_type) { + case SQLITE_ATTACH: + { + if (strncmp(arg3, ":memory:", sizeof(":memory:")-1)) { + if (php_check_open_basedir(arg3 TSRMLS_CC)) { + return SQLITE_DENY; + } + } + return SQLITE_OK; + } + + default: + /* access allowed */ + return SQLITE_OK; + } +} +/* }}} */ + +/* {{{ php_sqlite3_stmt_free + */ +static void php_sqlite3_stmt_free(void **item) +{ + php_sqlite3_stmt_free_list *free_item = (php_sqlite3_stmt_free_list *)*item; + + zval_dtor(free_item->result_object); + Z_TYPE_P(free_item->result_object) = IS_NULL; + if (free_item->statement_object) { + zval_dtor(free_item->statement_object); + Z_TYPE_P(free_item->statement_object) = IS_NULL; + } + efree(*item); +} +/* }}} */ + + +static int php_sqlite3_compare_stmt_free( php_sqlite3_stmt_free_list **stmt_list, sqlite3_stmt *statement ) /* {{{ */ +{ + return (statement == (*stmt_list)->stmt); +} + +static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) +{ + php_sqlite3_db_object *intern = (php_sqlite3_db_object *)object; + php_sqlite3_func *func; + + if (!intern) { + return; + } + + while (intern->funcs) { + func = intern->funcs; + intern->funcs = func->next; + if (intern->initialised && intern->db) { + sqlite3_create_function(intern->db, func->func_name, func->argc, SQLITE_UTF8, func, NULL, NULL, NULL); + } + + efree((char*)func->func_name); + + if (func->func) { + zval_ptr_dtor(&func->func); + } + if (func->step) { + zval_ptr_dtor(&func->step); + } + if (func->fini) { + zval_ptr_dtor(&func->fini); + } + efree(func); + } + + if (intern->initialised && intern->db) { + sqlite3_close(intern->db); + intern->initialised = 0; + } + + zend_object_std_dtor(&intern->zo TSRMLS_CC); + efree(intern); +} + +static void php_sqlite3_stmt_object_free_storage(void *object TSRMLS_DC) +{ + php_sqlite3_stmt *intern = (php_sqlite3_stmt *)object; + + if (!intern) { + return; + } + + if (intern->bound_params) { + zend_hash_destroy(intern->bound_params); + FREE_HASHTABLE(intern->bound_params); + intern->bound_params = NULL; + } + + if (intern->initialised) { + intern->initialised = 0; + sqlite3_finalize(intern->stmt); + } + + Z_DELREF_P(intern->db_obj_zval); + + zend_object_std_dtor(&intern->zo TSRMLS_CC); + efree(intern); +} + +static void php_sqlite3_result_object_free_storage(void *object TSRMLS_DC) +{ + php_sqlite3_result *intern = (php_sqlite3_result *)object; + + if (!intern) { + return; + } + + if (intern->stmt_obj->initialised) { + sqlite3_reset(intern->stmt_obj->stmt); + } + + if (intern->is_prepared_statement == 0) { + zval_dtor(intern->stmt_obj_zval); + FREE_ZVAL(intern->stmt_obj_zval); + } else { + zval_ptr_dtor(&intern->stmt_obj_zval); + } + + zend_object_std_dtor(&intern->zo TSRMLS_CC); + efree(intern); +} + +static zend_object_value php_sqlite3_object_new(zend_class_entry *class_type TSRMLS_DC) +{ + zval *tmp; + zend_object_value retval; + php_sqlite3_db_object *intern; + + /* Allocate memory for it */ + intern = emalloc(sizeof(php_sqlite3_db_object)); + memset(&intern->zo, 0, sizeof(php_sqlite3_db_object)); + + /* Non standard stuff, not sure if this is really required still + zend_llist_init(&(intern->stmt_list), sizeof(php_sqlite3_stmt_free_list *), (llist_dtor_func_t)php_sqlite3_stmt_free, 0);*/ + + zend_object_std_init(&intern->zo, class_type TSRMLS_CC); + zend_hash_copy(intern->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &tmp, sizeof(zval *)); + + retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_object_free_storage, NULL TSRMLS_CC); + retval.handlers = (zend_object_handlers *) &sqlite3_object_handlers; + + return retval; +} + +static zend_object_value php_sqlite3_stmt_object_new(zend_class_entry *class_type TSRMLS_DC) +{ + zval *tmp; + zend_object_value retval; + php_sqlite3_stmt *intern; + + /* Allocate memory for it */ + intern = emalloc(sizeof(php_sqlite3_stmt)); + memset(&intern->zo, 0, sizeof(php_sqlite3_stmt)); + + zend_object_std_init(&intern->zo, class_type TSRMLS_CC); + zend_hash_copy(intern->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &tmp, sizeof(zval *)); + + retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_stmt_object_free_storage, NULL TSRMLS_CC); + retval.handlers = (zend_object_handlers *) &sqlite3_stmt_object_handlers; + + return retval; +} + +static zend_object_value php_sqlite3_result_object_new(zend_class_entry *class_type TSRMLS_DC) +{ + zval *tmp; + zend_object_value retval; + php_sqlite3_result *intern; + + /* Allocate memory for it */ + intern = emalloc(sizeof(php_sqlite3_result)); + memset(&intern->zo, 0, sizeof(php_sqlite3_result)); + + intern->complete = 0; + intern->is_prepared_statement = 0; + + zend_object_std_init(&intern->zo, class_type TSRMLS_CC); + zend_hash_copy(intern->zo.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref,(void *) &tmp, sizeof(zval *)); + + retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_result_object_free_storage, NULL TSRMLS_CC); + retval.handlers = (zend_object_handlers *) &sqlite3_result_object_handlers; + + return retval; +} + +static void sqlite3_param_dtor(void *data) +{ + struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)data; + + if (param->name) { + efree(param->name); + } + + if (param->parameter) { + zval_ptr_dtor(&(param->parameter)); + param->parameter = NULL; + } +} + +/* {{{ PHP_MINIT_FUNCTION + */ +PHP_MINIT_FUNCTION(sqlite3) +{ + zend_class_entry ce; + +#if defined(ZTS) + /* Refuse to load if this wasn't a threasafe library loaded */ + if (!sqlite3_threadsafe()) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "A thread safe version of SQLite is required when using a thread safe version of PHP."); + return FAILURE; + } +#endif + + memcpy(&sqlite3_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); + memcpy(&sqlite3_stmt_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); + memcpy(&sqlite3_result_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); + + /* Register SQLite 3 Class */ + INIT_CLASS_ENTRY(ce, "SQLite3", php_sqlite3_class_methods); + ce.create_object = php_sqlite3_object_new; + sqlite3_object_handlers.clone_obj = NULL; + php_sqlite3_sc_entry = zend_register_internal_class(&ce TSRMLS_CC); + + /* Register SQLite 3 Prepared Statement Class */ + INIT_CLASS_ENTRY(ce, "SQLite3_stmt", php_sqlite3_stmt_class_methods); + ce.create_object = php_sqlite3_stmt_object_new; + sqlite3_stmt_object_handlers.clone_obj = NULL; + php_sqlite3_stmt_entry = zend_register_internal_class(&ce TSRMLS_CC); + + /* Register SQLite 3 Result Class */ + INIT_CLASS_ENTRY(ce, "SQLite3_result", php_sqlite3_result_class_methods); + ce.create_object = php_sqlite3_result_object_new; + sqlite3_result_object_handlers.clone_obj = NULL; + php_sqlite3_result_entry = zend_register_internal_class(&ce TSRMLS_CC); + + REGISTER_INI_ENTRIES(); + + REGISTER_LONG_CONSTANT("SQLITE3_ASSOC", PHP_SQLITE3_ASSOC, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_NUM", PHP_SQLITE3_NUM, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_BOTH", PHP_SQLITE3_BOTH, CONST_CS | CONST_PERSISTENT); + + REGISTER_LONG_CONSTANT("SQLITE3_INTEGER", SQLITE_INTEGER, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_FLOAT", SQLITE_FLOAT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_TEXT", SQLITE3_TEXT, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_BLOB", SQLITE_BLOB, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_NULL", SQLITE_NULL, CONST_CS | CONST_PERSISTENT); + + REGISTER_LONG_CONSTANT("SQLITE3_OPEN_READONLY", SQLITE_OPEN_READONLY, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_OPEN_READWRITE", SQLITE_OPEN_READWRITE, CONST_CS | CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("SQLITE3_OPEN_CREATE", SQLITE_OPEN_CREATE, CONST_CS | CONST_PERSISTENT); + + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MSHUTDOWN_FUNCTION + */ +PHP_MSHUTDOWN_FUNCTION(sqlite3) +{ + UNREGISTER_INI_ENTRIES(); + + return SUCCESS; +} +/* }}} */ + +/* {{{ PHP_MINFO_FUNCTION + */ +PHP_MINFO_FUNCTION(sqlite3) +{ + php_info_print_table_start(); + php_info_print_table_header(2, "SQLite3 support", "enabled"); + php_info_print_table_row(2, "SQLite3 module version", PHP_SQLITE3_VERSION); + php_info_print_table_row(2, "SQLite Library", sqlite3_libversion()); + php_info_print_table_end(); + + DISPLAY_INI_ENTRIES(); +} + +/* {{{ PHP_GINIT_FUNCTION + */ +static PHP_GINIT_FUNCTION(sqlite3) +{ + memset(sqlite3_globals, 0, sizeof(*sqlite3_globals)); +} +/* }}} */ + +/* {{{ sqlite3_module_entry + */ +zend_module_entry sqlite3_module_entry = { + STANDARD_MODULE_HEADER, + "sqlite3", + NULL, + PHP_MINIT(sqlite3), + PHP_MSHUTDOWN(sqlite3), + NULL, + NULL, + PHP_MINFO(sqlite3), + PHP_SQLITE3_VERSION, + PHP_MODULE_GLOBALS(sqlite3), + PHP_GINIT(sqlite3), + NULL, + NULL, + STANDARD_MODULE_PROPERTIES_EX +}; +/* }}} */ + +#ifdef COMPILE_DL_SQLITE3 +ZEND_GET_MODULE(sqlite3) +#endif + +/* + * Local variables: + * tab-width: 4 + * c-basic-offset: 4 + * End: + * vim600: sw=4 ts=4 fdm=marker + * vim<600: sw=4 ts=4 + */