Imported from /home/lorry/working-area/delta_php2/php-5.4.13.tar.bz2.HEADphp-5.4.13master

33 files changed, 2634 insertions, 0 deletions

diff --git a/ext/pdo_sqlite/CREDITS b/ext/pdo_sqlite/CREDITS
new file mode 100644
index 0000000..0a6c145
--- /dev/null
+++ b/ext/pdo_sqlite/CREDITS
@@ -0,0 +1,2 @@
+SQLite 3.x driver for PDO
+Wez Furlong
diff --git a/ext/pdo_sqlite/config.m4 b/ext/pdo_sqlite/config.m4
new file mode 100644
index 0000000..b2b70a5
--- /dev/null
+++ b/ext/pdo_sqlite/config.m4
@@ -0,0 +1,112 @@
+dnl $Id$
+dnl config.m4 for extension pdo_sqlite
+dnl vim:et:sw=2:ts=2:
+
+PHP_ARG_WITH(pdo-sqlite, for sqlite 3 support for PDO,
+[  --without-pdo-sqlite[=DIR]
+                            PDO: sqlite 3 support.  DIR is the sqlite base
+                            install directory [BUNDLED]], $PHP_PDO)
+
+if test "$PHP_PDO_SQLITE" != "no"; then
+
+  if test "$PHP_PDO" = "no" && test "$ext_shared" = "no"; then
+    AC_MSG_ERROR([PDO is not enabled! Add --enable-pdo to your configure line.])
+  fi
+
+  ifdef([PHP_CHECK_PDO_INCLUDES],
+  [
+    PHP_CHECK_PDO_INCLUDES
+  ],[
+    AC_MSG_CHECKING([for PDO includes])
+    if test -f $abs_srcdir/include/php/ext/pdo/php_pdo_driver.h; then
+      pdo_cv_inc_path=$abs_srcdir/ext
+    elif test -f $abs_srcdir/ext/pdo/php_pdo_driver.h; then
+      pdo_cv_inc_path=$abs_srcdir/ext
+    elif test -f $prefix/include/php/ext/pdo/php_pdo_driver.h; then
+      pdo_cv_inc_path=$prefix/include/php/ext
+    else
+      AC_MSG_ERROR([Cannot find php_pdo_driver.h.])
+    fi
+    AC_MSG_RESULT($pdo_cv_inc_path)
+  ])
+
+  php_pdo_sqlite_sources_core="pdo_sqlite.c sqlite_driver.c sqlite_statement.c"
+
+  if test "$PHP_PDO_SQLITE" != "yes"; then
+    SEARCH_PATH="$PHP_PDO_SQLITE /usr/local /usr"     # you might want to change this
+    SEARCH_FOR="/include/sqlite3.h"  # you most likely want to change this
+    if test -r $PHP_PDO_SQLITE/$SEARCH_FOR; then # path given as parameter
+      PDO_SQLITE_DIR=$PHP_PDO_SQLITE
+    else # search default path list
+      AC_MSG_CHECKING([for sqlite3 files in default path])
+      for i in $SEARCH_PATH ; do
+        if test -r $i/$SEARCH_FOR; then
+          PDO_SQLITE_DIR=$i
+          AC_MSG_RESULT(found in $i)
+        fi
+      done
+    fi
+    if test -z "$PDO_SQLITE_DIR"; then
+      AC_MSG_RESULT([not found])
+      AC_MSG_ERROR([Please reinstall the sqlite3 distribution])
+    fi
+
+    PHP_ADD_INCLUDE($PDO_SQLITE_DIR/include)
+
+    LIBNAME=sqlite3
+    LIBSYMBOL=sqlite3_open
+
+    PHP_CHECK_LIBRARY($LIBNAME,$LIBSYMBOL,
+    [
+      PHP_ADD_LIBRARY_WITH_PATH($LIBNAME, $PDO_SQLITE_DIR/$PHP_LIBDIR, PDO_SQLITE_SHARED_LIBADD)
+      AC_DEFINE(HAVE_PDO_SQLITELIB,1,[ ])
+    ],[
+      AC_MSG_ERROR([wrong sqlite lib version or lib not found])
+    ],[
+      -L$PDO_SQLITE_DIR/$PHP_LIBDIR -lm
+    ])
+    PHP_CHECK_LIBRARY(sqlite3,sqlite3_key,[
+      AC_DEFINE(HAVE_SQLITE3_KEY,1, [have commercial sqlite3 with crypto support])
+    ])
+
+    PHP_SUBST(PDO_SQLITE_SHARED_LIBADD)
+    PHP_NEW_EXTENSION(pdo_sqlite, $php_pdo_sqlite_sources_core, $ext_shared,,-I$pdo_cv_inc_path)
+  else
+      # use bundled libs
+      if test "$enable_maintainer_zts" = "yes"; then
+        threadsafe_flags="-DSQLITE_THREADSAFE=1"
+      else
+        threadsafe_flags="-DSQLITE_THREADSAFE=0"
+      fi
+
+      other_flags="-DSQLITE_ENABLE_FTS3=1 -DSQLITE_CORE=1 -DSQLITE_ENABLE_COLUMN_METADATA=1"
+
+	  dnl As long as intl is not shared we can have ICU support
+      if test "$PHP_INTL" = "yes" && test "$PHP_INTL_SHARED" != "yes"; then
+        other_flags="$other_flags -DSQLITE_ENABLE_ICU=1"
+      fi
+
+      if test "$PHP_SQLITE3" != "yes"; then
+        PHP_ADD_SOURCES(PHP_EXT_DIR(sqlite3), libsqlite/sqlite3.c)
+      fi
+
+      PHP_NEW_EXTENSION(pdo_sqlite,
+        $php_pdo_sqlite_sources_core,
+        $ext_shared,,-DPDO_SQLITE_BUNDLED=1 $other_flags $threadsafe_flags -I$pdo_cv_inc_path)
+
+      PHP_SUBST(PDO_SQLITE_SHARED_LIBADD)
+      PHP_ADD_EXTENSION_DEP(pdo_sqlite, sqlite3)
+      PHP_ADD_INCLUDE($abs_srcdir/ext/sqlite3/libsqlite)
+
+      AC_CHECK_FUNCS(usleep nanosleep)
+      AC_CHECK_HEADERS(time.h)
+  fi
+
+  dnl Solaris fix
+  PHP_CHECK_LIBRARY(rt, fdatasync, [PHP_ADD_LIBRARY(rt,, PDO_SQLITE_SHARED_LIBADD)])
+
+  ifdef([PHP_ADD_EXTENSION_DEP],
+  [
+    PHP_ADD_EXTENSION_DEP(pdo_sqlite, pdo)
+  ])
+fi
diff --git a/ext/pdo_sqlite/config.w32 b/ext/pdo_sqlite/config.w32
new file mode 100644
index 0000000..4f6a5d4
--- /dev/null
+++ b/ext/pdo_sqlite/config.w32
@@ -0,0 +1,26 @@
+// $Id$
+// vim:ft=javascript
+
+ARG_WITH("pdo-sqlite", "for pdo_sqlite support", "no");
+
+if (PHP_PDO_SQLITE != "no") {
+	EXTENSION("pdo_sqlite", "pdo_sqlite.c sqlite_driver.c sqlite_statement.c", null, "/DSQLITE_THREADSAFE=" + (PHP_ZTS == "yes" ? "1" : "0") + " /D SQLITE_ENABLE_FTS3=1 /D SQLITE_ENABLE_COLUMN_METADATA=1 /D SQLITE_CORE=1 /I" + configure_module_dirname + "/../sqlite3/libsqlite /I" + configure_module_dirname);
+	
+	ADD_EXTENSION_DEP('pdo_sqlite', 'pdo');
+	// If pdo_sqlite is static, and sqlite3 is also static, then we don't add a second copy of the sqlite3 libs
+	if (PHP_PDO_SQLITE_SHARED || PHP_SQLITE3_SHARED || PHP_SQLITE3 == 'no') {
+		ADD_SOURCES(configure_module_dirname + "/../sqlite3/libsqlite", "sqlite3.c", "pdo_sqlite");
+	}
+}
+
+ARG_WITH("pdo-sqlite-external", "for pdo_sqlite support from an external dll", "no");
+if (PHP_PDO_SQLITE_EXTERNAL != "no") {
+	if (CHECK_HEADER_ADD_INCLUDE("sqlite3.h", "CFLAGS_PDO_SQLITE_EXTERNAL", PHP_PDO_SQLITE_EXTERNAL + ";" + PHP_PHP_BUILD + "\\include\\sqlite3") &&
+	CHECK_LIB("sqlite3-import.lib", "pdo_sqlite_external", PHP_PDO_SQLITE_EXTERNAL + ";" + PHP_PHP_BUILD + "\\lib")
+	&& ADD_EXTENSION_DEP('pdo_sqlite_external', 'pdo') ) {
+		EXTENSION("pdo_sqlite_external", "pdo_sqlite.c sqlite_driver.c sqlite_statement.c", null, "/I" + configure_module_dirname, null, "ext\\pdo_sqlite_external");
+	} else {
+		WARNING("pdo-sqlite-external support can't be enabled, libraries or headers are missing")
+		PHP_PDO_SQLITE_EXTERNAL = "no"
+	}
+}
diff --git a/ext/pdo_sqlite/package2.xml b/ext/pdo_sqlite/package2.xml
new file mode 100644
index 0000000..9b58229
--- /dev/null
+++ b/ext/pdo_sqlite/package2.xml
@@ -0,0 +1,203 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<package packagerversion="1.4.5" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0
+http://pear.php.net/dtd/tasks-1.0.xsd
+http://pear.php.net/dtd/package-2.0
+http://pear.php.net/dtd/package-2.0.xsd">
+ <name>PDO_SQLITE</name>
+ <channel>pecl.php.net</channel>
+ <summary>SQLite v3 Interface driver for PDO</summary>
+ <description>This extension provides an SQLite v3 driver for PDO.
+SQLite V3 is NOT compatible with the bundled SQLite 2 in PHP 5, but is a significant
+step forwards, featuring complete utf-8 support, native support for blobs,
+native support for prepared statements with bound parameters and improved
+concurrency.
+
+ </description>
+ <lead>
+  <name>Wez Furlong</name>
+  <user>wez</user>
+  <email>wez@php.net</email>
+  <active>yes</active>
+ </lead>
+ <date>2006-05-01</date>
+ <version>
+  <release>1.0.1</release>
+  <api>1.0.1</api>
+ </version>
+ <stability>
+  <release>stable</release>
+  <api>stable</api>
+ </stability>
+ <license uri="http://www.php.net/license">PHP</license>
+ <notes>
+- Updated libsqlite in ext/pdo_sqlite to 3.2.8. (Ilia)
+- Upgraded to new package2 format
+- Fixed PECL Bug #5633; build issues
+- Added sqliteCreateFunction() and sqliteCreateAggregate()
+- Fixed PECL Bug #3452; problem when first row of a result set contains a NULL value.
+- Upgraded bundled sqlite to 3.1.3
+- setting PDO_ATTR_TIMEOUT controls the busy timeout
+- Fixed PECL Bug #3391; cannot bind NULL parameters
+- Fixed build problem when building the bundled sqlite library
+
+Windows binary:
+http://pecl4win.php.net/ext.php/php_pdo_sqlite.dll
+ </notes>
+ <contents>
+  <dir name="/">
+   <dir name="sqlite">
+    <dir name="src">
+     <file name="alter.c" role="src" />
+     <file name="analyze.c" role="src" />
+     <file name="attach.c" role="src" />
+     <file name="auth.c" role="src" />
+     <file name="btree.c" role="src" />
+     <file name="btree.h" role="src" />
+     <file name="build.c" role="src" />
+     <file name="callback.c" role="src" />
+     <file name="date.c" role="src" />
+     <file name="delete.c" role="src" />
+     <file name="expr.c" role="src" />
+     <file name="func.c" role="src" />
+     <file name="hash.c" role="src" />
+     <file name="hash.h" role="src" />
+     <file name="insert.c" role="src" />
+     <file name="keywordhash.h" role="src" />
+     <file name="legacy.c" role="src" />
+     <file name="main.c" role="src" />
+     <file name="md5.c" role="src" />
+     <file name="opcodes.c" role="src" />
+     <file name="opcodes.h" role="src" />
+     <file name="os.h" role="src" />
+     <file name="os.c" role="src" />
+     <file name="os_common.h" role="src" />
+     <file name="os_test.c" role="src" />
+     <file name="os_test.h" role="src" />
+     <file name="os_unix.c" role="src" />
+     <file name="os_unix.h" role="src" />
+     <file name="os_win.c" role="src" />
+     <file name="os_win.h" role="src" />
+     <file name="pager.c" role="src" />
+     <file name="pager.h" role="src" />
+     <file name="parse.c" role="src" />
+     <file name="parse.h" role="src" />
+     <file name="parse.y" role="src" />
+     <file name="pragma.c" role="src" />
+     <file name="prepare.c" role="src" />
+     <file name="printf.c" role="src" />
+     <file name="random.c" role="src" />
+     <file name="select.c" role="src" />
+     <file name="shell.c" role="src" />
+     <file name="sqlite.h.in" role="src" />
+     <file name="sqliteInt.h" role="src" />
+     <file name="table.c" role="src" />
+     <file name="tclsqlite.c" role="src" />
+     <file name="test1.c" role="src" />
+     <file name="test2.c" role="src" />
+     <file name="test3.c" role="src" />
+     <file name="test4.c" role="src" />
+     <file name="test5.c" role="src" />
+     <file name="tokenize.c" role="src" />
+     <file name="trigger.c" role="src" />
+     <file name="update.c" role="src" />
+     <file name="utf.c" role="src" />
+     <file name="util.c" role="src" />
+     <file name="vacuum.c" role="src" />
+     <file name="vdbe.c" role="src" />
+     <file name="vdbe.h" role="src" />
+     <file name="vdbeapi.c" role="src" />
+     <file name="vdbeaux.c" role="src" />
+     <file name="vdbefifo.c" role="src" />
+     <file name="vdbeInt.h" role="src" />
+     <file name="vdbemem.c" role="src" />
+     <file name="where.c" role="src" />
+     <file name="vtab.c" role="src" />
+     <file name="loadext.c" role="src" />
+     <file name="complete.c" role="src" />
+     <file name="sqlite3ext.h" role="src" />
+     <file name="btmutex.c" role="src" />
+     <file name="btreeInt.h" role="src" />
+     <file name="experimental.c" role="src" />
+     <file name="fault.c" role="src" />
+     <file name="journal.c" role="src" />
+     <file name="limits.h" role="src" />
+     <file name="malloc.c" role="src" />
+     <file name="mem1.c" role="src" />
+     <file name="mutex.c" role="src" />
+     <file name="mutex.h" role="src" />
+     <file name="mutex_unix.c" role="src" />
+     <file name="mutex_w32.c" role="src" />
+     <file name="sqliteLimit.h" role="src" />
+     <file name="vdbeblob.c" role="src" />
+    </dir> <!-- //sqlite/src -->
+    <dir name="tool">
+     <file name="diffdb.c" role="src" />
+     <file name="lemon.c" role="src" />
+     <file name="lempar.c" role="src" />
+     <file name="memleak.awk" role="src" />
+     <file name="memleak2.awk" role="src" />
+     <file name="memleak3.tcl" role="src" />
+     <file name="mkkeywordhash.c" role="src" />
+     <file name="mkopts.tcl" role="src" />
+     <file name="opcodeDoc.awk" role="src" />
+     <file name="report1.txt" role="src" />
+     <file name="showdb.c" role="src" />
+     <file name="showjournal.c" role="src" />
+     <file name="spaceanal.tcl" role="src" />
+     <file name="space_used.tcl" role="src" />
+     <file name="speedtest.tcl" role="src" />
+     <file name="speedtest2.tcl" role="src" />
+    </dir> <!-- //sqlite/tool -->
+    <file name="aclocal.m4" role="src" />
+    <file name="config.guess" role="src" />
+    <file name="config.sub" role="src" />
+    <file name="configure" role="src" />
+    <file name="configure.ac" role="src" />
+    <file name="install-sh" role="src" />
+    <file name="ltmain.sh" role="src" />
+    <file name="main.mk" role="src" />
+    <file name="Makefile.in" role="src" />
+    <file name="Makefile.linux-gcc" role="src" />
+    <file name="mkdll.sh" role="src" />
+    <file name="mkopcodec.awk" role="src" />
+    <file name="mkopcodeh.awk" role="src" />
+    <file name="mkso.sh" role="src" />
+    <file name="publish.sh" role="src" />
+    <file name="README" role="src" />
+    <file name="spec.template" role="src" />
+    <file name="sqlite.1" role="src" />
+    <file name="sqlite.pc.in" role="src" />
+    <file name="sqlite3.def" role="src" />
+    <file name="sqlite3.pc.in" role="src" />
+    <file name="VERSION" role="src" />
+   </dir> <!-- //sqlite -->
+   <file name="config.m4" role="src" />
+   <file name="config.w32" role="src" />
+   <file name="CREDITS" role="doc" />
+   <file name="pdo_sqlite.c" role="src" />
+   <file name="php_pdo_sqlite.h" role="src" />
+   <file name="php_pdo_sqlite_int.h" role="src" />
+   <file name="sqlite_driver.c" role="src" />
+   <file name="sqlite_statement.c" role="src" />
+  </dir> <!-- / -->
+ </contents>
+ <dependencies>
+  <required>
+   <php>
+    <min>5.0.3</min>
+   </php>
+   <pearinstaller>
+    <min>1.4.0</min>
+   </pearinstaller>
+   <package>
+    <name>pdo</name>
+    <channel>pecl.php.net</channel>
+    <min>1.0.3</min>
+    <providesextension>PDO</providesextension>
+   </package>
+  </required>
+ </dependencies>
+ <providesextension>PDO_SQLITE</providesextension>
+ <extsrcrelease />
+</package>
+<!-- vim:se ts=1 sw=1 et: -->
diff --git a/ext/pdo_sqlite/pdo_sqlite.c b/ext/pdo_sqlite/pdo_sqlite.c
new file mode 100644
index 0000000..cc9b03e
--- /dev/null
+++ b/ext/pdo_sqlite/pdo_sqlite.c
@@ -0,0 +1,110 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2013 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.               |
+  +----------------------------------------------------------------------+
+  | Author: Wez Furlong <wez@php.net>                                    |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_ini.h"
+#include "ext/standard/info.h"
+#include "pdo/php_pdo.h"
+#include "pdo/php_pdo_driver.h"
+#include "php_pdo_sqlite.h"
+#include "php_pdo_sqlite_int.h"
+#include "zend_exceptions.h"
+
+#define PHP_PDO_SQLITE_MODULE_VERSION	"1.0.1"
+
+/* {{{ pdo_sqlite_functions[] */
+const zend_function_entry pdo_sqlite_functions[] = {
+	PHP_FE_END
+};
+/* }}} */
+
+/* {{{ pdo_sqlite_deps
+ */
+#if ZEND_MODULE_API_NO >= 20050922
+static const zend_module_dep pdo_sqlite_deps[] = {
+	ZEND_MOD_REQUIRED("pdo")
+	ZEND_MOD_END
+};
+#endif
+/* }}} */
+
+/* {{{ pdo_sqlite_module_entry
+ */
+zend_module_entry pdo_sqlite_module_entry = {
+#if ZEND_MODULE_API_NO >= 20050922
+	STANDARD_MODULE_HEADER_EX, NULL,
+	pdo_sqlite_deps,
+#else
+	STANDARD_MODULE_HEADER,
+#endif
+	"pdo_sqlite",
+	pdo_sqlite_functions,
+	PHP_MINIT(pdo_sqlite),
+	PHP_MSHUTDOWN(pdo_sqlite),
+	NULL,
+	NULL,
+	PHP_MINFO(pdo_sqlite),
+	PHP_PDO_SQLITE_MODULE_VERSION,
+	STANDARD_MODULE_PROPERTIES
+};
+/* }}} */
+
+#if defined(COMPILE_DL_PDO_SQLITE) || defined(COMPILE_DL_PDO_SQLITE_EXTERNAL)
+ZEND_GET_MODULE(pdo_sqlite)
+#endif
+
+/* {{{ PHP_MINIT_FUNCTION */
+PHP_MINIT_FUNCTION(pdo_sqlite)
+{
+	return php_pdo_register_driver(&pdo_sqlite_driver);
+}
+/* }}} */
+
+/* {{{ PHP_MSHUTDOWN_FUNCTION */
+PHP_MSHUTDOWN_FUNCTION(pdo_sqlite)
+{
+	php_pdo_unregister_driver(&pdo_sqlite_driver);
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ PHP_MINFO_FUNCTION
+ */
+PHP_MINFO_FUNCTION(pdo_sqlite)
+{
+	php_info_print_table_start();
+	php_info_print_table_header(2, "PDO Driver for SQLite 3.x", "enabled");
+	php_info_print_table_row(2, "SQLite Library", sqlite3_libversion());
+	php_info_print_table_end();
+}
+/* }}} */
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
diff --git a/ext/pdo_sqlite/php_pdo_sqlite.h b/ext/pdo_sqlite/php_pdo_sqlite.h
new file mode 100644
index 0000000..6fa3bab
--- /dev/null
+++ b/ext/pdo_sqlite/php_pdo_sqlite.h
@@ -0,0 +1,65 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2013 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.               |
+  +----------------------------------------------------------------------+
+  | Author: Wez Furlong <wez@php.net>                                    |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+
+#ifndef PHP_PDO_SQLITE_H
+#define PHP_PDO_SQLITE_H
+
+extern zend_module_entry pdo_sqlite_module_entry;
+#define phpext_pdo_sqlite_ptr &pdo_sqlite_module_entry
+
+#ifdef ZTS
+#include "TSRM.h"
+#endif
+
+PHP_MINIT_FUNCTION(pdo_sqlite);
+PHP_MSHUTDOWN_FUNCTION(pdo_sqlite);
+PHP_RINIT_FUNCTION(pdo_sqlite);
+PHP_RSHUTDOWN_FUNCTION(pdo_sqlite);
+PHP_MINFO_FUNCTION(pdo_sqlite);
+
+/* 
+  	Declare any global variables you may need between the BEGIN
+	and END macros here:     
+
+ZEND_BEGIN_MODULE_GLOBALS(pdo_sqlite)
+	long  global_value;
+	char *global_string;
+ZEND_END_MODULE_GLOBALS(pdo_sqlite)
+*/
+
+/* In every utility function you add that needs to use variables 
+   in php_pdo_sqlite_globals, call TSRMLS_FETCH(); after declaring other 
+   variables used by that function, or better yet, pass in TSRMLS_CC
+   after the last function argument and declare your utility function
+   with TSRMLS_DC after the last declared argument.  Always refer to
+   the globals in your function as PDO_SQLITE_G(variable).  You are 
+   encouraged to rename these macros something shorter, see
+   examples in any other php module directory.
+*/
+
+#ifdef ZTS
+#define PDO_SQLITE_G(v) TSRMG(pdo_sqlite_globals_id, zend_pdo_sqlite_globals *, v)
+#else
+#define PDO_SQLITE_G(v) (pdo_sqlite_globals.v)
+#endif
+
+#endif	/* PHP_PDO_SQLITE_H */
+
diff --git a/ext/pdo_sqlite/php_pdo_sqlite_int.h b/ext/pdo_sqlite/php_pdo_sqlite_int.h
new file mode 100644
index 0000000..8e20ca5
--- /dev/null
+++ b/ext/pdo_sqlite/php_pdo_sqlite_int.h
@@ -0,0 +1,78 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2013 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.               |
+  +----------------------------------------------------------------------+
+  | Author: Wez Furlong <wez@php.net>                                    |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifndef PHP_PDO_SQLITE_INT_H
+#define PHP_PDO_SQLITE_INT_H
+
+#include <sqlite3.h>
+
+typedef struct {
+	const char *file;
+	int line;
+	unsigned int errcode;
+	char *errmsg;
+} pdo_sqlite_error_info;
+
+struct pdo_sqlite_fci {
+	zend_fcall_info fci;
+	zend_fcall_info_cache fcc;
+};
+
+struct pdo_sqlite_func {
+	struct pdo_sqlite_func *next;
+
+	zval *func, *step, *fini;
+	int argc;
+	const char *funcname;
+	
+	/* accelerated callback references */
+	struct pdo_sqlite_fci afunc, astep, afini;
+};
+
+struct pdo_sqlite_collation {
+	struct pdo_sqlite_collation *next;
+
+	const char *name;
+	zval *callback;
+	struct pdo_sqlite_fci fc;
+};
+
+typedef struct {
+	sqlite3 *db;
+	pdo_sqlite_error_info einfo;
+	struct pdo_sqlite_func *funcs;
+	struct pdo_sqlite_collation *collations;
+} pdo_sqlite_db_handle;
+
+typedef struct {
+	pdo_sqlite_db_handle 	*H;
+	sqlite3_stmt *stmt;
+	unsigned pre_fetched:1;
+	unsigned done:1;
+} pdo_sqlite_stmt;
+
+extern pdo_driver_t pdo_sqlite_driver;
+
+extern int _pdo_sqlite_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line TSRMLS_DC);
+#define pdo_sqlite_error(s) _pdo_sqlite_error(s, NULL, __FILE__, __LINE__ TSRMLS_CC)
+#define pdo_sqlite_error_stmt(s) _pdo_sqlite_error(stmt->dbh, stmt, __FILE__, __LINE__ TSRMLS_CC)
+
+extern struct pdo_stmt_methods sqlite_stmt_methods;
+#endif
diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
new file mode 100644
index 0000000..0f4a245
--- /dev/null
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -0,0 +1,873 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2013 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.               |
+  +----------------------------------------------------------------------+
+  | Author: Wez Furlong <wez@php.net>                                    |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_ini.h"
+#include "ext/standard/info.h"
+#include "pdo/php_pdo.h"
+#include "pdo/php_pdo_driver.h"
+#include "php_pdo_sqlite.h"
+#include "php_pdo_sqlite_int.h"
+#include "zend_exceptions.h"
+
+int _pdo_sqlite_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line TSRMLS_DC) /* {{{ */
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	pdo_error_type *pdo_err = stmt ? &stmt->error_code : &dbh->error_code;
+	pdo_sqlite_error_info *einfo = &H->einfo;
+
+	einfo->errcode = sqlite3_errcode(H->db);
+	einfo->file = file;
+	einfo->line = line;
+
+	if (einfo->errcode != SQLITE_OK) {
+		if (einfo->errmsg) {
+			pefree(einfo->errmsg, dbh->is_persistent);
+		}
+		einfo->errmsg = pestrdup((char*)sqlite3_errmsg(H->db), dbh->is_persistent);
+	} else { /* no error */
+		strncpy(*pdo_err, PDO_ERR_NONE, sizeof(PDO_ERR_NONE));
+		return 0;
+	}
+	switch (einfo->errcode) {
+		case SQLITE_NOTFOUND:
+			strncpy(*pdo_err, "42S02", sizeof("42S02"));
+			break;	
+
+		case SQLITE_INTERRUPT:
+			strncpy(*pdo_err, "01002", sizeof("01002"));
+			break;
+
+		case SQLITE_NOLFS:
+			strncpy(*pdo_err, "HYC00", sizeof("HYC00"));
+			break;
+
+		case SQLITE_TOOBIG:
+			strncpy(*pdo_err, "22001", sizeof("22001"));
+			break;
+	
+		case SQLITE_CONSTRAINT:
+			strncpy(*pdo_err, "23000", sizeof("23000"));
+			break;
+
+		case SQLITE_ERROR:
+		default:
+			strncpy(*pdo_err, "HY000", sizeof("HY000"));
+			break;
+	}
+
+	if (!dbh->methods) {
+		zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode TSRMLS_CC, "SQLSTATE[%s] [%d] %s",
+				*pdo_err, einfo->errcode, einfo->errmsg);
+	}
+	
+	return einfo->errcode;
+}
+/* }}} */
+
+static int pdo_sqlite_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	pdo_sqlite_error_info *einfo = &H->einfo;
+
+	if (einfo->errcode) {
+		add_next_index_long(info, einfo->errcode);
+		add_next_index_string(info, einfo->errmsg, 1);
+	}
+
+	return 1;
+}
+
+static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
+{
+	struct pdo_sqlite_func *func;
+
+	while (H->funcs) {
+		func = H->funcs;
+		H->funcs = func->next;
+
+		if (H->db) {
+			/* delete the function from the handle */
+			sqlite3_create_function(H->db,
+				func->funcname,
+				func->argc,
+				SQLITE_UTF8,
+				func,
+				NULL, NULL, NULL);
+		}
+
+		efree((char*)func->funcname);
+		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);
+	}
+
+	while (H->collations) {
+		struct pdo_sqlite_collation *collation;
+		collation = H->collations;
+		H->collations = collation->next;
+
+		if (H->db) {
+			/* delete the collation from the handle */
+			sqlite3_create_collation(H->db,
+				collation->name,
+				SQLITE_UTF8,
+				collation,
+				NULL);
+		}
+
+		efree((char*)collation->name);
+		if (collation->callback) {
+			zval_ptr_dtor(&collation->callback);
+		}
+		efree(collation);
+	}
+}
+
+static int sqlite_handle_closer(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	
+	if (H) {
+		pdo_sqlite_error_info *einfo = &H->einfo;
+
+		pdo_sqlite_cleanup_callbacks(H TSRMLS_CC);
+		if (H->db) {
+			sqlite3_close(H->db);
+			H->db = NULL;
+		}
+		if (einfo->errmsg) {
+			pefree(einfo->errmsg, dbh->is_persistent);
+			einfo->errmsg = NULL;
+		}
+		pefree(H, dbh->is_persistent);
+		dbh->driver_data = NULL;
+	}
+	return 0;
+}
+/* }}} */
+
+static int sqlite_handle_preparer(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	pdo_sqlite_stmt *S = ecalloc(1, sizeof(pdo_sqlite_stmt));
+	int i;
+	const char *tail;
+
+	S->H = H;
+	stmt->driver_data = S;
+	stmt->methods = &sqlite_stmt_methods;
+	stmt->supports_placeholders = PDO_PLACEHOLDER_POSITIONAL|PDO_PLACEHOLDER_NAMED;
+
+	if (PDO_CURSOR_FWDONLY != pdo_attr_lval(driver_options, PDO_ATTR_CURSOR, PDO_CURSOR_FWDONLY TSRMLS_CC)) {
+		H->einfo.errcode = SQLITE_ERROR;
+		pdo_sqlite_error(dbh);
+		return 0;
+	}
+
+	i = sqlite3_prepare(H->db, sql, sql_len, &S->stmt, &tail);
+	if (i == SQLITE_OK) {
+		return 1;
+	}
+
+	pdo_sqlite_error(dbh);
+
+	return 0;
+}
+
+static long sqlite_handle_doer(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	char *errmsg = NULL;
+
+	if (sqlite3_exec(H->db, sql, NULL, NULL, &errmsg) != SQLITE_OK) {
+		pdo_sqlite_error(dbh);
+		if (errmsg)
+			sqlite3_free(errmsg);
+
+		return -1;
+	} else {
+		return sqlite3_changes(H->db);
+	}
+}
+
+static char *pdo_sqlite_last_insert_id(pdo_dbh_t *dbh, const char *name, unsigned int *len TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	char *id;
+	
+	id = php_pdo_int64_to_str(sqlite3_last_insert_rowid(H->db) TSRMLS_CC);
+	*len = strlen(id);
+	return id;
+}
+
+/* NB: doesn't handle binary strings... use prepared stmts for that */
+static int sqlite_handle_quoter(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype  TSRMLS_DC)
+{
+	*quoted = safe_emalloc(2, unquotedlen, 3);
+	sqlite3_snprintf(2*unquotedlen + 3, *quoted, "'%q'", unquoted);
+	*quotedlen = strlen(*quoted);
+	return 1;
+}
+
+static int sqlite_handle_begin(pdo_dbh_t *dbh TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	char *errmsg = NULL;
+
+	if (sqlite3_exec(H->db, "BEGIN", NULL, NULL, &errmsg) != SQLITE_OK) {
+		pdo_sqlite_error(dbh);
+		if (errmsg)
+			sqlite3_free(errmsg);
+		return 0;
+	}
+	return 1;
+}
+
+static int sqlite_handle_commit(pdo_dbh_t *dbh TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	char *errmsg = NULL;
+
+	if (sqlite3_exec(H->db, "COMMIT", NULL, NULL, &errmsg) != SQLITE_OK) {
+		pdo_sqlite_error(dbh);
+		if (errmsg)
+			sqlite3_free(errmsg);
+		return 0;
+	}
+	return 1;
+}
+
+static int sqlite_handle_rollback(pdo_dbh_t *dbh TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	char *errmsg = NULL;
+
+	if (sqlite3_exec(H->db, "ROLLBACK", NULL, NULL, &errmsg) != SQLITE_OK) {
+		pdo_sqlite_error(dbh);
+		if (errmsg)
+			sqlite3_free(errmsg);
+		return 0;
+	}
+	return 1;
+}
+
+static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value TSRMLS_DC)
+{
+	switch (attr) {
+		case PDO_ATTR_CLIENT_VERSION:
+		case PDO_ATTR_SERVER_VERSION:
+			ZVAL_STRING(return_value, (char *)sqlite3_libversion(), 1);
+			break;
+		
+		default:
+			return 0;	
+	}
+
+	return 1;
+}
+
+static int pdo_sqlite_set_attr(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+
+	switch (attr) {
+		case PDO_ATTR_TIMEOUT:
+			convert_to_long(val);
+			sqlite3_busy_timeout(H->db, Z_LVAL_P(val) * 1000);
+			return 1;
+	}
+	return 0;
+}
+
+static int do_callback(struct pdo_sqlite_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_ptr = 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]);
+
+		/* get the value */
+		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:
+				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 (zargs) {
+		for (i = is_agg; i < fake_argc; 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:
+					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_func_callback(sqlite3_context *context, int argc,
+	sqlite3_value **argv)
+{
+	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
+	TSRMLS_FETCH();
+
+	do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
+}
+
+static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
+	sqlite3_value **argv)
+{
+	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
+	TSRMLS_FETCH();
+
+	do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
+}
+
+static void php_sqlite3_func_final_callback(sqlite3_context *context)
+{
+	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
+	TSRMLS_FETCH();
+
+	do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
+}
+
+static int php_sqlite3_collation_callback(void *context,
+	int string1_len, const void *string1,
+	int string2_len, const void *string2)
+{
+	int ret;
+	zval *zstring1, *zstring2;
+	zval **zargs[2];
+	zval *retval = NULL;
+	struct pdo_sqlite_collation *collation = (struct pdo_sqlite_collation*) context;
+	TSRMLS_FETCH();
+
+	collation->fc.fci.size = sizeof(collation->fc.fci);
+	collation->fc.fci.function_table = EG(function_table);
+	collation->fc.fci.function_name = collation->callback;
+	collation->fc.fci.symbol_table = NULL;
+	collation->fc.fci.object_ptr = NULL;
+	collation->fc.fci.retval_ptr_ptr = &retval;
+
+	// Prepare the arguments.
+	MAKE_STD_ZVAL(zstring1);
+	ZVAL_STRINGL(zstring1, (char *) string1, string1_len, 1);
+	zargs[0] = &zstring1;
+	MAKE_STD_ZVAL(zstring2);
+	ZVAL_STRINGL(zstring2, (char *) string2, string2_len, 1);
+	zargs[1] = &zstring2;
+	collation->fc.fci.param_count = 2;
+	collation->fc.fci.params = zargs;
+
+	if ((ret = zend_call_function(&collation->fc.fci, &collation->fc.fcc TSRMLS_CC)) == FAILURE) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
+	}
+	else if (retval) {
+		if (Z_TYPE_P(retval) != IS_LONG) {
+			convert_to_long_ex(&retval);
+		}
+		ret = 0;
+		if (Z_LVAL_P(retval) > 0) {
+			ret = 1;
+		}
+		else if (Z_LVAL_P(retval) < 0) {
+			ret = -1;
+		}
+		zval_ptr_dtor(&retval);
+	}
+
+	zval_ptr_dtor(zargs[0]);
+	zval_ptr_dtor(zargs[1]);
+
+	return ret;
+}
+
+/* {{{ bool SQLite::sqliteCreateFunction(string name, mixed callback [, int argcount])
+   Registers a UDF with the sqlite db handle */
+static PHP_METHOD(SQLite, sqliteCreateFunction)
+{
+	struct pdo_sqlite_func *func;
+	zval *callback;
+	char *func_name;
+	int func_name_len;
+	long argc = -1;
+	char *cbname = NULL;
+	pdo_dbh_t *dbh;
+	pdo_sqlite_db_handle *H;
+	int ret;
+
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l",
+			&func_name, &func_name_len, &callback, &argc)) {
+		RETURN_FALSE;
+	}
+	
+	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	PDO_CONSTRUCT_CHECK;
+
+	if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
+		efree(cbname);
+		RETURN_FALSE;
+	}
+	efree(cbname);
+	
+	H = (pdo_sqlite_db_handle *)dbh->driver_data;
+
+	func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
+
+	ret = sqlite3_create_function(H->db, func_name, argc, SQLITE_UTF8,
+			func, php_sqlite3_func_callback, NULL, NULL);
+	if (ret == SQLITE_OK) {
+		func->funcname = estrdup(func_name);
+		
+		MAKE_STD_ZVAL(func->func);
+		MAKE_COPY_ZVAL(&callback, func->func);
+		
+		func->argc = argc;
+
+		func->next = H->funcs;
+		H->funcs = func;
+
+		RETURN_TRUE;
+	}
+
+	efree(func);
+	RETURN_FALSE;
+}
+/* }}} */
+
+/* {{{ bool SQLite::sqliteCreateAggregate(string name, mixed step, mixed fini [, int argcount])
+   Registers a UDF with the sqlite db handle */
+
+/* The step function should have the prototype:
+   mixed step(mixed $context, int $rownumber, $value [, $value2 [, ...]])
+
+   $context will be null for the first row; on subsequent rows it will have
+   the value that was previously returned from the step function; you should
+   use this to maintain state for the aggregate.
+
+   The fini function should have the prototype:
+   mixed fini(mixed $context, int $rownumber)
+
+   $context will hold the return value from the very last call to the step function.
+   rownumber will hold the number of rows over which the aggregate was performed.
+   The return value of this function will be used as the return value for this
+   aggregate UDF.
+*/
+   
+static PHP_METHOD(SQLite, sqliteCreateAggregate)
+{
+	struct pdo_sqlite_func *func;
+	zval *step_callback, *fini_callback;
+	char *func_name;
+	int func_name_len;
+	long argc = -1;
+	char *cbname = NULL;
+	pdo_dbh_t *dbh;
+	pdo_sqlite_db_handle *H;
+	int ret;
+
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "szz|l",
+			&func_name, &func_name_len, &step_callback, &fini_callback, &argc)) {
+		RETURN_FALSE;
+	}
+	
+	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	PDO_CONSTRUCT_CHECK;
+
+	if (!zend_is_callable(step_callback, 0, &cbname TSRMLS_CC)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
+		efree(cbname);
+		RETURN_FALSE;
+	}
+	efree(cbname);
+	if (!zend_is_callable(fini_callback, 0, &cbname TSRMLS_CC)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
+		efree(cbname);
+		RETURN_FALSE;
+	}
+	efree(cbname);
+	
+	H = (pdo_sqlite_db_handle *)dbh->driver_data;
+
+	func = (struct pdo_sqlite_func*)ecalloc(1, sizeof(*func));
+
+	ret = sqlite3_create_function(H->db, func_name, argc, SQLITE_UTF8,
+			func, NULL, php_sqlite3_func_step_callback, php_sqlite3_func_final_callback);
+	if (ret == SQLITE_OK) {
+		func->funcname = estrdup(func_name);
+		
+		MAKE_STD_ZVAL(func->step);
+		MAKE_COPY_ZVAL(&step_callback, func->step);
+
+		MAKE_STD_ZVAL(func->fini);
+		MAKE_COPY_ZVAL(&fini_callback, func->fini);
+		
+		func->argc = argc;
+
+		func->next = H->funcs;
+		H->funcs = func;
+
+		RETURN_TRUE;
+	}
+
+	efree(func);
+	RETURN_FALSE;
+}
+/* }}} */
+
+/* {{{ bool SQLite::sqliteCreateCollation(string name, mixed callback)
+   Registers a collation with the sqlite db handle */
+static PHP_METHOD(SQLite, sqliteCreateCollation)
+{
+	struct pdo_sqlite_collation *collation;
+	zval *callback;
+	char *collation_name;
+	int collation_name_len;
+	char *cbname = NULL;
+	pdo_dbh_t *dbh;
+	pdo_sqlite_db_handle *H;
+	int ret;
+
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz",
+		&collation_name, &collation_name_len, &callback)) {
+		RETURN_FALSE;
+	}
+
+	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	PDO_CONSTRUCT_CHECK;
+
+	if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
+		efree(cbname);
+		RETURN_FALSE;
+	}
+	efree(cbname);
+
+	H = (pdo_sqlite_db_handle *)dbh->driver_data;
+
+	collation = (struct pdo_sqlite_collation*)ecalloc(1, sizeof(*collation));
+
+	ret = sqlite3_create_collation(H->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_collation_callback);
+	if (ret == SQLITE_OK) {
+		collation->name = estrdup(collation_name);
+
+		MAKE_STD_ZVAL(collation->callback);
+		MAKE_COPY_ZVAL(&callback, collation->callback);
+
+		collation->next = H->collations;
+		H->collations = collation;
+
+		RETURN_TRUE;
+	}
+
+	efree(collation);
+	RETURN_FALSE;
+}
+/* }}} */
+
+static const zend_function_entry dbh_methods[] = {
+	PHP_ME(SQLite, sqliteCreateFunction, NULL, ZEND_ACC_PUBLIC)
+	PHP_ME(SQLite, sqliteCreateAggregate, NULL, ZEND_ACC_PUBLIC)
+	PHP_ME(SQLite, sqliteCreateCollation, NULL, ZEND_ACC_PUBLIC)
+	PHP_FE_END
+};
+
+static const zend_function_entry *get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
+{
+	switch (kind) {
+		case PDO_DBH_DRIVER_METHOD_KIND_DBH:
+			return dbh_methods;
+
+		default:
+			return NULL;
+	}
+}
+
+static void pdo_sqlite_request_shutdown(pdo_dbh_t *dbh TSRMLS_DC)
+{
+	pdo_sqlite_db_handle *H = (pdo_sqlite_db_handle *)dbh->driver_data;
+	/* unregister functions, so that they don't linger for the next
+	 * request */
+	if (H) {
+		pdo_sqlite_cleanup_callbacks(H TSRMLS_CC);
+	}
+}
+
+static struct pdo_dbh_methods sqlite_methods = {
+	sqlite_handle_closer,
+	sqlite_handle_preparer,
+	sqlite_handle_doer,
+	sqlite_handle_quoter,
+	sqlite_handle_begin,
+	sqlite_handle_commit,
+	sqlite_handle_rollback,
+	pdo_sqlite_set_attr,
+	pdo_sqlite_last_insert_id,
+	pdo_sqlite_fetch_error_func,
+	pdo_sqlite_get_attribute,
+	NULL,	/* check_liveness: not needed */
+	get_driver_methods,
+	pdo_sqlite_request_shutdown
+};
+
+static char *make_filename_safe(const char *filename TSRMLS_DC)
+{
+	if (*filename && memcmp(filename, ":memory:", sizeof(":memory:"))) {
+		char *fullpath = expand_filepath(filename, NULL TSRMLS_CC);
+
+		if (!fullpath) {
+			return NULL;
+		}
+
+		if (php_check_open_basedir(fullpath TSRMLS_CC)) {
+			efree(fullpath);
+			return NULL;
+		}
+		return fullpath;
+	}
+	return estrdup(filename);
+}
+
+static int authorizer(void *autharg, int access_type, const char *arg3, const char *arg4,
+		const char *arg5, const char *arg6)
+{
+	char *filename;
+	switch (access_type) {
+		case SQLITE_COPY: {
+			TSRMLS_FETCH();
+			filename = make_filename_safe(arg4 TSRMLS_CC);
+			if (!filename) {
+				return SQLITE_DENY;
+			}
+			efree(filename);
+			return SQLITE_OK;
+		}
+
+		case SQLITE_ATTACH: {
+			TSRMLS_FETCH();
+			filename = make_filename_safe(arg3 TSRMLS_CC);
+			if (!filename) {
+				return SQLITE_DENY;
+			}
+			efree(filename);
+			return SQLITE_OK;
+		}
+
+		default:
+			/* access allowed */
+			return SQLITE_OK;
+	}
+}
+
+static int pdo_sqlite_handle_factory(pdo_dbh_t *dbh, zval *driver_options TSRMLS_DC) /* {{{ */
+{
+	pdo_sqlite_db_handle *H;
+	int i, ret = 0;
+	long timeout = 60;
+	char *filename;
+
+	H = pecalloc(1, sizeof(pdo_sqlite_db_handle), dbh->is_persistent);
+	
+	H->einfo.errcode = 0;
+	H->einfo.errmsg = NULL;
+	dbh->driver_data = H;
+
+	filename = make_filename_safe(dbh->data_source TSRMLS_CC);
+
+	if (!filename) {
+		zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC,
+			"open_basedir prohibits opening %s",
+			dbh->data_source);
+		goto cleanup;
+	}
+
+	i = sqlite3_open(filename, &H->db);
+	efree(filename);
+
+	if (i != SQLITE_OK) {
+		pdo_sqlite_error(dbh);
+		goto cleanup;
+	}
+
+	if (PG(open_basedir) && *PG(open_basedir)) {
+		sqlite3_set_authorizer(H->db, authorizer, NULL);
+	}
+
+	if (driver_options) {
+		timeout = pdo_attr_lval(driver_options, PDO_ATTR_TIMEOUT, timeout TSRMLS_CC);
+	}
+	sqlite3_busy_timeout(H->db, timeout * 1000);
+
+	dbh->alloc_own_columns = 1;
+	dbh->max_escaped_char_length = 2;
+
+	ret = 1;
+	
+cleanup:
+	dbh->methods = &sqlite_methods;
+	
+	return ret;
+}
+/* }}} */
+
+pdo_driver_t pdo_sqlite_driver = {
+	PDO_DRIVER_HEADER(sqlite),
+	pdo_sqlite_handle_factory
+};
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
diff --git a/ext/pdo_sqlite/sqlite_statement.c b/ext/pdo_sqlite/sqlite_statement.c
new file mode 100644
index 0000000..e970ad3
--- /dev/null
+++ b/ext/pdo_sqlite/sqlite_statement.c
@@ -0,0 +1,362 @@
+/*
+  +----------------------------------------------------------------------+
+  | PHP Version 5                                                        |
+  +----------------------------------------------------------------------+
+  | Copyright (c) 1997-2013 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.               |
+  +----------------------------------------------------------------------+
+  | Author: Wez Furlong <wez@php.net>                                    |
+  +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_ini.h"
+#include "ext/standard/info.h"
+#include "pdo/php_pdo.h"
+#include "pdo/php_pdo_driver.h"
+#include "php_pdo_sqlite.h"
+#include "php_pdo_sqlite_int.h"
+
+
+static int pdo_sqlite_stmt_dtor(pdo_stmt_t *stmt TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+
+	if (S->stmt) {
+		sqlite3_finalize(S->stmt);
+		S->stmt = NULL;
+	}
+	efree(S);
+	return 1;
+}
+
+static int pdo_sqlite_stmt_execute(pdo_stmt_t *stmt TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+
+	if (stmt->executed && !S->done) {
+		sqlite3_reset(S->stmt);
+	}
+
+	S->done = 0;
+	switch (sqlite3_step(S->stmt)) {
+		case SQLITE_ROW:
+			S->pre_fetched = 1;
+			stmt->column_count = sqlite3_data_count(S->stmt);
+			return 1;
+
+		case SQLITE_DONE:
+			stmt->column_count = sqlite3_column_count(S->stmt);
+			stmt->row_count = sqlite3_changes(S->H->db);
+			sqlite3_reset(S->stmt);
+			S->done = 1;
+			return 1;
+
+		case SQLITE_ERROR:
+			sqlite3_reset(S->stmt);
+		case SQLITE_MISUSE:
+		case SQLITE_BUSY:
+		default:
+			pdo_sqlite_error_stmt(stmt);
+			return 0;
+	}
+}
+
+static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *param,
+		enum pdo_param_event event_type TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+
+	switch (event_type) {
+		case PDO_PARAM_EVT_EXEC_PRE:
+			if (stmt->executed && !S->done) {
+				sqlite3_reset(S->stmt);
+				S->done = 1;
+			}
+			
+			if (param->is_param) {
+				
+				if (param->paramno == -1) {
+					param->paramno = sqlite3_bind_parameter_index(S->stmt, param->name) - 1;
+				}
+
+				switch (PDO_PARAM_TYPE(param->param_type)) {
+					case PDO_PARAM_STMT:
+						return 0;
+
+					case PDO_PARAM_NULL:
+						if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
+							return 1;
+						}
+						pdo_sqlite_error_stmt(stmt);
+						return 0;
+					
+					case PDO_PARAM_INT:
+					case PDO_PARAM_BOOL:
+						if (Z_TYPE_P(param->parameter) == IS_NULL) {
+							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
+								return 1;
+							}
+						} else {
+							convert_to_long(param->parameter);
+#if LONG_MAX > 2147483647
+							if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+								return 1;
+							}
+#else
+							if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+								return 1;
+							}
+#endif
+						}
+						pdo_sqlite_error_stmt(stmt);
+						return 0;
+					
+					case PDO_PARAM_LOB:
+						if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
+							php_stream *stm;
+							php_stream_from_zval_no_verify(stm, &param->parameter);
+							if (stm) {
+								SEPARATE_ZVAL(&param->parameter);
+								Z_TYPE_P(param->parameter) = IS_STRING;
+								Z_STRLEN_P(param->parameter) = php_stream_copy_to_mem(stm,
+									&Z_STRVAL_P(param->parameter), PHP_STREAM_COPY_ALL, 0);
+							} else {
+								pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
+								return 0;
+							}
+						} else if (Z_TYPE_P(param->parameter) == IS_NULL) {
+							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
+								return 1;
+							}
+							pdo_sqlite_error_stmt(stmt);
+							return 0;
+						} else {
+							convert_to_string(param->parameter);
+						}
+						
+						if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,
+								Z_STRVAL_P(param->parameter),
+								Z_STRLEN_P(param->parameter),
+								SQLITE_STATIC)) {
+							return 1;	
+						}
+						pdo_sqlite_error_stmt(stmt);
+						return 0;
+							
+					case PDO_PARAM_STR:
+					default:
+						if (Z_TYPE_P(param->parameter) == IS_NULL) {
+							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
+								return 1;
+							}
+						} else {
+							convert_to_string(param->parameter);
+							if(SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
+									Z_STRVAL_P(param->parameter),
+									Z_STRLEN_P(param->parameter),
+									SQLITE_STATIC)) {
+								return 1;	
+							}
+						}
+						pdo_sqlite_error_stmt(stmt);
+						return 0;
+				}
+			}
+			break;
+
+		default:
+			;
+	}
+	return 1;
+}
+
+static int pdo_sqlite_stmt_fetch(pdo_stmt_t *stmt,
+	enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+	int i;
+	if (!S->stmt) {
+		return 0;	
+	}
+	if (S->pre_fetched) {
+		S->pre_fetched = 0;
+		return 1;
+	}
+	if (S->done) {
+		return 0;
+	}
+	i = sqlite3_step(S->stmt);
+	switch (i) {
+		case SQLITE_ROW:
+			return 1;
+
+		case SQLITE_DONE:
+			S->done = 1;
+			sqlite3_reset(S->stmt);
+			return 0;
+
+		case SQLITE_ERROR:
+			sqlite3_reset(S->stmt);
+		default:
+			pdo_sqlite_error_stmt(stmt);
+			return 0;
+	}
+}
+
+static int pdo_sqlite_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+
+	if(colno >= sqlite3_column_count(S->stmt)) {
+		/* error invalid column */
+		pdo_sqlite_error_stmt(stmt);
+		return 0;
+	}
+
+	stmt->columns[colno].name = estrdup(sqlite3_column_name(S->stmt, colno));
+	stmt->columns[colno].namelen = strlen(stmt->columns[colno].name);
+	stmt->columns[colno].maxlen = 0xffffffff;
+	stmt->columns[colno].precision = 0;
+	
+	switch (sqlite3_column_type(S->stmt, colno)) {
+		case SQLITE_INTEGER:
+		case SQLITE_FLOAT:
+		case SQLITE3_TEXT:
+		case SQLITE_BLOB:
+		case SQLITE_NULL:
+		default:
+			stmt->columns[colno].param_type = PDO_PARAM_STR;
+			break;
+	}
+
+	return 1;
+}
+
+static int pdo_sqlite_stmt_get_col(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+	if (!S->stmt) {
+		return 0;
+	}
+	if(colno >= sqlite3_data_count(S->stmt)) {
+		/* error invalid column */
+		pdo_sqlite_error_stmt(stmt);
+		return 0;
+	}
+	switch (sqlite3_column_type(S->stmt, colno)) {
+		case SQLITE_NULL:
+			*ptr = NULL;
+			*len = 0;
+			return 1;
+
+		case SQLITE_BLOB:
+			*ptr = (char*)sqlite3_column_blob(S->stmt, colno);
+			*len = sqlite3_column_bytes(S->stmt, colno);
+			return 1;
+
+		default:
+			*ptr = (char*)sqlite3_column_text(S->stmt, colno);
+			*len = sqlite3_column_bytes(S->stmt, colno);
+			return 1;
+	}
+}
+
+static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+	const char *str;
+	zval *flags;
+	
+	if (!S->stmt) {
+		return FAILURE;
+	}
+	if(colno >= sqlite3_data_count(S->stmt)) {
+		/* error invalid column */
+		pdo_sqlite_error_stmt(stmt);
+		return FAILURE;
+	}
+
+	array_init(return_value);
+	MAKE_STD_ZVAL(flags);
+	array_init(flags);
+
+	switch (sqlite3_column_type(S->stmt, colno)) {
+		case SQLITE_NULL:
+			add_assoc_string(return_value, "native_type", "null", 1);
+			break;
+
+		case SQLITE_FLOAT:
+			add_assoc_string(return_value, "native_type", "double", 1);
+			break;
+
+		case SQLITE_BLOB:
+			add_next_index_string(flags, "blob", 1);
+		case SQLITE_TEXT:
+			add_assoc_string(return_value, "native_type", "string", 1);
+			break;
+
+		case SQLITE_INTEGER:
+			add_assoc_string(return_value, "native_type", "integer", 1);
+			break;
+	}
+
+	str = sqlite3_column_decltype(S->stmt, colno);
+	if (str) {
+		add_assoc_string(return_value, "sqlite:decl_type", (char *)str, 1);
+	}
+
+#ifdef SQLITE_ENABLE_COLUMN_METADATA
+	str = sqlite3_column_table_name(S->stmt, colno);
+	if (str) {
+		add_assoc_string(return_value, "table", (char *)str, 1);
+	}
+#endif
+
+	add_assoc_zval(return_value, "flags", flags);
+
+	return SUCCESS;
+}
+
+static int pdo_sqlite_stmt_cursor_closer(pdo_stmt_t *stmt TSRMLS_DC)
+{
+	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+	sqlite3_reset(S->stmt);
+	return 1;
+}
+
+struct pdo_stmt_methods sqlite_stmt_methods = {
+	pdo_sqlite_stmt_dtor,
+	pdo_sqlite_stmt_execute,
+	pdo_sqlite_stmt_fetch,
+	pdo_sqlite_stmt_describe,
+	pdo_sqlite_stmt_get_col,
+	pdo_sqlite_stmt_param_hook,
+	NULL, /* set_attr */
+	NULL, /* get_attr */
+	pdo_sqlite_stmt_col_meta,
+	NULL, /* next_rowset */
+	pdo_sqlite_stmt_cursor_closer
+};
+
+/*
+ * Local variables:
+ * tab-width: 4
+ * c-basic-offset: 4
+ * End:
+ * vim600: noet sw=4 ts=4 fdm=marker
+ * vim<600: noet sw=4 ts=4
+ */
diff --git a/ext/pdo_sqlite/tests/bug33841.phpt b/ext/pdo_sqlite/tests/bug33841.phpt
new file mode 100644
index 0000000..d472af7
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug33841.phpt
@@ -0,0 +1,28 @@
+--TEST--
+PDO SQLite Bug #33841 (rowCount() does not work on prepared statements)
+--SKIPIF--
+<?php # vim:ft=php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+require dirname(__FILE__) . '/../../../ext/pdo/tests/pdo_test.inc';
+$db = PDOTest::test_factory(dirname(__FILE__) . '/common.phpt');
+
+$db->exec('CREATE TABLE test (text)');
+
+$stmt = $db->prepare("INSERT INTO test VALUES ( :text )");
+$stmt->bindParam(':text', $name);
+$name = 'test1';
+var_dump($stmt->execute(), $stmt->rowCount());
+
+$stmt = $db->prepare("UPDATE test SET text = :text ");
+$stmt->bindParam(':text', $name);
+$name = 'test2';
+var_dump($stmt->execute(), $stmt->rowCount());
+
+--EXPECT--
+bool(true)
+int(1)
+bool(true)
+int(1)
diff --git a/ext/pdo_sqlite/tests/bug35336.phpt b/ext/pdo_sqlite/tests/bug35336.phpt
new file mode 100644
index 0000000..59dbda3
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug35336.phpt
@@ -0,0 +1,26 @@
+--TEST--
+Bug #35336 (crash on PDO::FETCH_CLASS + __set())
+--SKIPIF--
+<?php # vim:ft=php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+class EEE {
+	function __set ($field, $value) {
+		echo "hello world\n";
+	}
+}
+
+$a = new PDO("sqlite::memory:");// pool ("sqlite::memory:");
+$a->query ("CREATE TABLE test (a integer primary key, b text)");
+$b = $a->prepare("insert into test (b) values (?)");
+$b->execute(array (5));
+$rez = $a->query ("SELECT * FROM test")->fetchAll(PDO::FETCH_CLASS, 'EEE');
+
+echo "Done\n";
+?>
+--EXPECTF--	
+hello world
+hello world
+Done
diff --git a/ext/pdo_sqlite/tests/bug43831.phpt b/ext/pdo_sqlite/tests/bug43831.phpt
new file mode 100644
index 0000000..2746e7c
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug43831.phpt
@@ -0,0 +1,53 @@
+--TEST--
+Bug #43831 ($this gets mangled when extending PDO with persistent connection)
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+
+class Foo extends PDO {
+	function __construct($dsn) {
+		parent::__construct($dsn, null, null, array(PDO::ATTR_PERSISTENT => true));
+	}
+}
+
+class Baz extends PDO {
+	function __construct($dsn) {
+		parent::__construct($dsn, null, null, array(PDO::ATTR_PERSISTENT => true));
+	}
+}
+
+class Bar extends Baz {
+	function quux() {
+		echo get_class($this), "\n";
+		$foo = new Foo("sqlite::memory:");
+		echo get_class($this), "\n";
+	}
+}
+
+$bar = new Bar("sqlite::memory:");
+$bar->quux();
+
+
+class MyPDO extends PDO {}
+
+$bar = new PDO("sqlite::memory:", null, null, array(PDO::ATTR_PERSISTENT => true));
+$baz = new MyPDO("sqlite::memory:", null, null, array(PDO::ATTR_PERSISTENT => true));
+
+var_dump($bar);
+unset($bar);
+var_dump($baz);
+var_dump($bar);
+
+
+?>
+--EXPECTF--
+Bar
+Bar
+object(MyPDO)#%d (0) {
+}
+object(MyPDO)#%d (0) {
+}
+
+Notice: Undefined variable: bar in %s on line %d
+NULL
diff --git a/ext/pdo_sqlite/tests/bug44327_2.phpt b/ext/pdo_sqlite/tests/bug44327_2.phpt
new file mode 100644
index 0000000..4add073
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug44327_2.phpt
@@ -0,0 +1,50 @@
+--TEST--
+Bug #44327.2 (PDORow::queryString property & numeric offsets / Crash)
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+
+$x = $db->query('select 1 as queryString');
+var_dump($x, $x->queryString);
+
+$y = $x->fetch();
+var_dump($y, @$y->queryString);
+
+print "--------------------------------------------\n";
+
+$x = $db->query('select 1 as queryString');
+var_dump($x, $x->queryString);
+
+$y = $x->fetch(PDO::FETCH_LAZY);
+var_dump($y, $y->queryString);
+
+?>
+--EXPECTF--
+object(PDOStatement)#%d (1) {
+  ["queryString"]=>
+  string(23) "select 1 as queryString"
+}
+string(23) "select 1 as queryString"
+array(2) {
+  ["queryString"]=>
+  string(1) "1"
+  [0]=>
+  string(1) "1"
+}
+NULL
+--------------------------------------------
+object(PDOStatement)#%d (1) {
+  ["queryString"]=>
+  string(23) "select 1 as queryString"
+}
+string(23) "select 1 as queryString"
+object(PDORow)#%d (1) {
+  ["queryString"]=>
+  string(1) "1"
+}
+string(1) "1"
diff --git a/ext/pdo_sqlite/tests/bug44327_3.phpt b/ext/pdo_sqlite/tests/bug44327_3.phpt
new file mode 100644
index 0000000..86f5642
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug44327_3.phpt
@@ -0,0 +1,33 @@
+--TEST--
+Bug #44327.3 (PDORow::queryString property & numeric offsets / Crash)
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+
+$x = $db->query('select 1 as queryStringxx');
+$y = $x->fetch(PDO::FETCH_LAZY);
+var_dump($y, $y->queryString, $y->queryStringzz, $y->queryStringxx);
+
+print "---\n";
+
+var_dump($y[5], $y->{3});
+
+?>
+--EXPECTF--
+object(PDORow)#%d (2) {
+  ["queryString"]=>
+  string(25) "select 1 as queryStringxx"
+  ["queryStringxx"]=>
+  string(1) "1"
+}
+string(25) "select 1 as queryStringxx"
+NULL
+string(1) "1"
+---
+NULL
+NULL
diff --git a/ext/pdo_sqlite/tests/bug46139.phpt b/ext/pdo_sqlite/tests/bug46139.phpt
new file mode 100644
index 0000000..c361d7a
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug46139.phpt
@@ -0,0 +1,42 @@
+--TEST--
+Bug #46139 (PDOStatement->setFetchMode() forgets FETCH_PROPS_LATE)
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+
+require dirname(__FILE__) . '/../../../ext/pdo/tests/pdo_test.inc';
+$db = PDOTest::test_factory(dirname(__FILE__) . '/common.phpt');
+
+class Person {
+    public $test = NULL;
+    public function __construct() {
+        var_dump($this->test);
+    }
+}
+
+$stmt = $db->query("SELECT 'foo' test, 1");
+$stmt->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, 'Person');
+$r1 = $stmt->fetch();
+printf("'%s'\n", $r1->test);
+
+$stmt = $db->query("SELECT 'foo' test, 1");
+$stmt->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, 'Person');
+$r1 = $stmt->fetchAll();
+printf("'%s'\n", $r1[0]->test);
+
+$stmt = $db->query("SELECT 'foo' test, 1");
+$stmt->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, 'Person');
+$r1 = $stmt->fetch(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE);
+printf("'%s'\n", $r1->test);
+
+?>
+--EXPECT--
+NULL
+'foo'
+NULL
+'foo'
+NULL
+'foo'
diff --git a/ext/pdo_sqlite/tests/bug46542.phpt b/ext/pdo_sqlite/tests/bug46542.phpt
new file mode 100644
index 0000000..2de0c05
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug46542.phpt
@@ -0,0 +1,24 @@
+--TEST--
+Bug #46542 Extending PDO class with a __call() function
+--SKIPIF--
+<?php # vim:ft=php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+class A extends PDO
+{ function __call($m, $p) {print __CLASS__."::$m\n";} }
+
+$a = new A('sqlite:' . __DIR__ . '/dummy.db');
+
+$a->truc();
+$a->TRUC();
+
+?>
+--CLEAN--
+<?php
+unlink(__DIR__ . '/dummy.db');
+?>
+--EXPECT--
+A::truc
+A::TRUC
diff --git a/ext/pdo_sqlite/tests/bug48773.phpt b/ext/pdo_sqlite/tests/bug48773.phpt
new file mode 100644
index 0000000..b8bdea9
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug48773.phpt
@@ -0,0 +1,34 @@
+--TEST--
+Bug #48773 (Incorrect error when setting PDO::ATTR_STATEMENT_CLASS with ctor_args)
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+
+class bar extends PDOStatement {
+	private function __construct() {
+	}
+}
+
+class foo extends PDO {
+	public $statementClass = 'bar';
+	function __construct($dsn, $username, $password, $driver_options = array()) {
+		$driver_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION;
+		parent::__construct($dsn, $username, $password, $driver_options);
+
+		$this->setAttribute(PDO::ATTR_STATEMENT_CLASS, array($this->statementClass, array($this)));
+	}
+}
+
+$db = new foo('sqlite::memory:', '', '');
+$stmt = $db->query('SELECT 1');
+var_dump($stmt);
+
+?>
+--EXPECTF--
+object(bar)#%d (1) {
+  [%u|b%"queryString"]=>
+  %unicode|string%(8) "SELECT 1"
+}
diff --git a/ext/pdo_sqlite/tests/bug50728.phpt b/ext/pdo_sqlite/tests/bug50728.phpt
new file mode 100644
index 0000000..3dbbb1f
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug50728.phpt
@@ -0,0 +1,16 @@
+--TEST--
+Bug #50728 (All PDOExceptions hardcode 'code' property to 0)
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+try {
+	$a = new PDO("sqlite:/this/path/should/not/exist.db");
+} catch (PDOException $e) {
+	var_dump($e->getCode());
+}
+?>
+--EXPECTF--
+int(14)
diff --git a/ext/pdo_sqlite/tests/bug52487.phpt b/ext/pdo_sqlite/tests/bug52487.phpt
new file mode 100644
index 0000000..fc65bd3
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug52487.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Bug #52487 (PDO::FETCH_INTO leaks memory)
+--SKIPIF--
+<?php # vim:ft=php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+require dirname(__FILE__) . '/../../../ext/pdo/tests/pdo_test.inc';
+$db = PDOTest::test_factory(dirname(__FILE__) . '/common.phpt');
+
+$stmt = $db->prepare("select 1 as attr");
+for ($i = 0; $i < 10; $i++) {
+	$stmt->setFetchMode(PDO::FETCH_INTO, new stdClass);
+}
+
+print "ok\n";
+
+?>
+--EXPECT--
+ok
diff --git a/ext/pdo_sqlite/tests/bug60104.phpt b/ext/pdo_sqlite/tests/bug60104.phpt
new file mode 100644
index 0000000..fd36b57
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug60104.phpt
@@ -0,0 +1,21 @@
+--TEST--
+Bug #60104 (Segmentation Fault in pdo_sqlite when using sqliteCreateFunction())
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+function setUp()
+{
+    $handler = new PDO( "sqlite::memory:" );
+    $handler->sqliteCreateFunction( "md5", "md5", 1 );
+    unset( $handler );
+}
+
+setUp();
+setUp();
+echo "done";
+?>
+--EXPECTF--
+done
diff --git a/ext/pdo_sqlite/tests/bug_42589.phpt b/ext/pdo_sqlite/tests/bug_42589.phpt
new file mode 100644
index 0000000..abd5e8c
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug_42589.phpt
@@ -0,0 +1,23 @@
+--TEST--
+PDO SQLite Feature Request #42589 (getColumnMeta() should also return table name)
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo') || !extension_loaded('pdo_sqlite')) die('skip not loaded');
+?>
+--FILE--
+<?php
+$db = new PDO("sqlite::memory:");
+
+$db->exec('CREATE TABLE test (field1 VARCHAR(10))');
+$db->exec('INSERT INTO test VALUES("test")');
+
+$result = $db->query('SELECT * FROM test t1 LEFT JOIN test t2 ON t1.field1 = t2.field1');
+$meta1 = $result->getColumnMeta(0);
+$meta2 = $result->getColumnMeta(1);
+
+var_dump(!empty($meta1['table']) && $meta1['table'] == 'test');
+var_dump(!empty($meta2['table']) && $meta2['table'] == 'test');
+?>
+--EXPECTF--
+bool(true)
+bool(true)
diff --git a/ext/pdo_sqlite/tests/bug_63916-2.phpt b/ext/pdo_sqlite/tests/bug_63916-2.phpt
new file mode 100644
index 0000000..bc9bfc9
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug_63916-2.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Bug #63916 PDO::PARAM_INT casts to 32bit int internally even on 64bit builds in pdo_sqlite
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) die('skip');
+if (PHP_INT_SIZE > 4) die('skip');
+?>
+--FILE--
+<?php
+$num = PHP_INT_MAX; // 32 bits
+$conn = new PDO('sqlite::memory:');
+$conn->query('CREATE TABLE users (id INTEGER NOT NULL, num INTEGER NOT NULL, PRIMARY KEY(id))');
+
+$stmt = $conn->prepare('insert into users (id, num) values (:id, :num)');
+$stmt->bindValue(':id', 1, PDO::PARAM_INT);
+$stmt->bindValue(':num', $num, PDO::PARAM_INT);
+$stmt->execute();
+
+$stmt = $conn->query('SELECT num FROM users');
+$result = $stmt->fetchAll(PDO::FETCH_COLUMN);
+
+var_dump($num,$result[0]);
+
+?>
+--EXPECT--
+int(2147483647)
+string(10) "2147483647"
diff --git a/ext/pdo_sqlite/tests/bug_63916.phpt b/ext/pdo_sqlite/tests/bug_63916.phpt
new file mode 100644
index 0000000..582413d
--- /dev/null
+++ b/ext/pdo_sqlite/tests/bug_63916.phpt
@@ -0,0 +1,27 @@
+--TEST--
+Bug #63916 PDO::PARAM_INT casts to 32bit int internally even on 64bit builds in pdo_sqlite
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) die('skip');
+if (PHP_INT_SIZE < 8) die('skip');
+?>
+--FILE--
+<?php
+$num = 100004313234244; // exceeds 32 bits
+$conn = new PDO('sqlite::memory:');
+$conn->query('CREATE TABLE users (id INTEGER NOT NULL, num INTEGER NOT NULL, PRIMARY KEY(id))');
+
+$stmt = $conn->prepare('insert into users (id, num) values (:id, :num)');
+$stmt->bindValue(':id', 1, PDO::PARAM_INT);
+$stmt->bindValue(':num', $num, PDO::PARAM_INT);
+$stmt->execute();
+
+$stmt = $conn->query('SELECT num FROM users');
+$result = $stmt->fetchAll(PDO::FETCH_COLUMN);
+
+var_dump($num,$result[0]);
+
+?>
+--EXPECT--
+int(100004313234244)
+string(15) "100004313234244"
diff --git a/ext/pdo_sqlite/tests/common.phpt b/ext/pdo_sqlite/tests/common.phpt
new file mode 100644
index 0000000..65ea0c9
--- /dev/null
+++ b/ext/pdo_sqlite/tests/common.phpt
@@ -0,0 +1,12 @@
+--TEST--
+SQLite
+--SKIPIF--
+<?php # vim:ft=php
+if (!extension_loaded('pdo_sqlite')) print 'skip'; ?>
+--REDIRECTTEST--
+return array(
+	'ENV' => array(
+			'PDOTEST_DSN' => 'sqlite::memory:'
+		),
+	'TESTS' => 'ext/pdo/tests'
+	);
diff --git a/ext/pdo_sqlite/tests/debugdumpparams_001.phpt b/ext/pdo_sqlite/tests/debugdumpparams_001.phpt
new file mode 100644
index 0000000..3e51b53
--- /dev/null
+++ b/ext/pdo_sqlite/tests/debugdumpparams_001.phpt
@@ -0,0 +1,37 @@
+--TEST--
+Testing PDOStatement::debugDumpParams() with bound params
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+
+$x= $db->prepare('select :a, :b, ?');
+$x->bindValue(':a', 1, PDO::PARAM_INT);
+$x->bindValue(':b', 'foo');
+$x->bindValue(3, 1313);
+var_dump($x->debugDumpParams());
+
+?>
+--EXPECT--
+SQL: [16] select :a, :b, ?
+Params:  3
+Key: Name: [2] :a
+paramno=-1
+name=[2] ":a"
+is_param=1
+param_type=1
+Key: Name: [2] :b
+paramno=-1
+name=[2] ":b"
+is_param=1
+param_type=2
+Key: Position #2:
+paramno=2
+name=[0] ""
+is_param=1
+param_type=2
+NULL
diff --git a/ext/pdo_sqlite/tests/pdo_fetch_func_001.phpt b/ext/pdo_sqlite/tests/pdo_fetch_func_001.phpt
new file mode 100644
index 0000000..efcb2e7
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_fetch_func_001.phpt
@@ -0,0 +1,130 @@
+--TEST--
+Testing several callbacks using PDO::FETCH_FUNC
+--SKIPIF--
+<?php
+if (!extension_loaded('pdo_sqlite')) print 'skip not loaded';
+?>
+--FILE--
+<?php
+
+$db = new PDO('sqlite::memory:');
+$db->exec('CREATE TABLE testing (id INTEGER , name VARCHAR)');
+$db->exec('INSERT INTO testing VALUES(1, "php")');
+$db->exec('INSERT INTO testing VALUES(2, "")');
+
+$st = $db->query('SELECT * FROM testing');
+$st->fetchAll(PDO::FETCH_FUNC, function($x, $y) use ($st) { var_dump($st); print "data: $x, $y\n"; });
+
+$st = $db->query('SELECT name FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, 'strtoupper'));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, 'nothing'));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, ''));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, NULL));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, 1));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, array('self', 'foo')));
+
+class foo { 
+	public function foo($x) {
+		return "--- $x ---";
+	}
+}
+class bar extends foo {
+	public function __construct($db) {
+		$st = $db->query('SELECT * FROM testing');
+		var_dump($st->fetchAll(PDO::FETCH_FUNC, array($this, 'parent::foo')));
+	}
+	
+	static public function test($x, $y) {
+		return $x .'---'. $y;
+	}
+	
+	private function test2($x, $y) {
+		return $x;
+	}
+	
+	public function test3($x, $y) {
+		return $x .'==='. $y;
+	}
+}
+
+new bar($db);
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, array('bar', 'test')));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, array('bar', 'test2')));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, array('bar', 'test3')));
+
+$st = $db->query('SELECT * FROM testing');
+var_dump($st->fetchAll(PDO::FETCH_FUNC, array('bar', 'inexistent')));
+
+?>
+--EXPECTF--
+object(PDOStatement)#%d (1) {
+  [%u|b%"queryString"]=>
+  %string|unicode%(21) "SELECT * FROM testing"
+}
+data: 1, php
+object(PDOStatement)#%d (1) {
+  [%u|b%"queryString"]=>
+  %string|unicode%(21) "SELECT * FROM testing"
+}
+data: 2, 
+array(2) {
+  [0]=>
+  %string|unicode%(3) "PHP"
+  [1]=>
+  %string|unicode%(0) ""
+}
+
+Warning: PDOStatement::fetchAll(): SQLSTATE[HY000]: General error: function 'nothing' not found or invalid function name in %s on line %d
+bool(false)
+
+Warning: PDOStatement::fetchAll(): SQLSTATE[HY000]: General error: function '' not found or invalid function name in %s on line %d
+bool(false)
+
+Warning: PDOStatement::fetchAll(): SQLSTATE[HY000]: General error: no array or string given in %s on line %d
+bool(false)
+
+Warning: PDOStatement::fetchAll(): SQLSTATE[HY000]: General error: no array or string given in %s on line %d
+bool(false)
+
+Warning: PDOStatement::fetchAll(): SQLSTATE[HY000]: General error: cannot access self:: when no class scope is active in %s on line %d
+bool(false)
+array(2) {
+  [0]=>
+  %string|unicode%(9) "--- 1 ---"
+  [1]=>
+  %string|unicode%(9) "--- 2 ---"
+}
+array(2) {
+  [0]=>
+  %string|unicode%(7) "1---php"
+  [1]=>
+  %string|unicode%(4) "2---"
+}
+
+Warning: PDOStatement::fetchAll(): SQLSTATE[HY000]: General error: cannot access private method bar::test2() in %s on line %d
+bool(false)
+array(2) {
+  [0]=>
+  %string|unicode%(7) "1===php"
+  [1]=>
+  %string|unicode%(4) "2==="
+}
+
+Warning: PDOStatement::fetchAll(): SQLSTATE[HY000]: General error: class 'bar' does not have a method 'inexistent' in %s on line %d
+bool(false)
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_createaggregate.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_createaggregate.phpt
new file mode 100644
index 0000000..975dcd9
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_createaggregate.phpt
@@ -0,0 +1,31 @@
+--TEST--
+PDO_sqlite: Testing sqliteCreateAggregate()
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+
+$db->query('CREATE TABLE IF NOT EXISTS foobar (id INT AUTO INCREMENT, name TEXT)');
+
+$db->query('INSERT INTO foobar VALUES (NULL, "PHP")');
+$db->query('INSERT INTO foobar VALUES (NULL, "PHP6")');
+
+$db->sqliteCreateAggregate('testing', function(&$a, $b) { $a .= $b; return $a; }, function(&$v) { return $v; });
+
+
+foreach ($db->query('SELECT testing(name) FROM foobar') as $row) {
+	var_dump($row);
+}
+
+$db->query('DROP TABLE foobar');
+
+?>
+--EXPECTF--
+array(2) {
+  ["testing(name)"]=>
+  %string|unicode%(2) "12"
+  [0]=>
+  %string|unicode%(2) "12"
+}
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_createaggregate_002.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_createaggregate_002.phpt
new file mode 100644
index 0000000..671e4b3
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_createaggregate_002.phpt
@@ -0,0 +1,17 @@
+--TEST--
+PDO_sqlite: Testing invalid callback for sqliteCreateAggregate()
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+
+$pdo = new PDO('sqlite::memory:');
+
+$pdo->sqliteCreateAggregate('foo', 'a', '');
+$pdo->sqliteCreateAggregate('foo', 'strlen', '');
+
+?>
+--EXPECTF--
+Warning: PDO::sqliteCreateAggregate(): function 'a' is not callable in %s on line %d
+
+Warning: PDO::sqliteCreateAggregate(): function '' is not callable in %s on line %d
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_createcollation.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_createcollation.phpt
new file mode 100644
index 0000000..c35e363
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_createcollation.phpt
@@ -0,0 +1,38 @@
+--TEST--
+PDO_sqlite: Testing sqliteCreateCollation()
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+$db->query('CREATE TABLE IF NOT EXISTS foobar (id INT AUTO INCREMENT, name TEXT)');
+
+$db->query('INSERT INTO foobar VALUES (NULL, "1")');
+$db->query('INSERT INTO foobar VALUES (NULL, "2")');
+$db->query('INSERT INTO foobar VALUES (NULL, "10")');
+
+$db->sqliteCreateCollation('MYCOLLATE', function($a, $b) { return strnatcmp($a, $b); });
+
+$result = $db->query('SELECT name FROM foobar ORDER BY name COLLATE MYCOLLATE');
+foreach ($result as $row) {
+	echo $row['name'] . "\n";
+}
+
+$result = $db->query('SELECT name FROM foobar ORDER BY name');
+foreach ($result as $row) {
+  echo $row['name'] . "\n";
+}
+
+$db->query('DROP TABLE foobar');
+
+?>
+--EXPECTF--
+1
+2
+10
+1
+10
+2
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_createfunction.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_createfunction.phpt
new file mode 100644
index 0000000..b675879
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_createfunction.phpt
@@ -0,0 +1,38 @@
+--TEST--
+PDO_sqlite: Testing sqliteCreateFunction()
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+
+$db->query('CREATE TABLE IF NOT EXISTS foobar (id INT AUTO INCREMENT, name TEXT)');
+
+$db->query('INSERT INTO foobar VALUES (NULL, "PHP")');
+$db->query('INSERT INTO foobar VALUES (NULL, "PHP6")');
+
+
+$db->sqliteCreateFunction('testing', function($v) { return strtolower($v); });
+
+
+foreach ($db->query('SELECT testing(name) FROM foobar') as $row) {
+	var_dump($row);
+}
+
+$db->query('DROP TABLE foobar');
+
+?>
+--EXPECTF--
+array(2) {
+  ["testing(name)"]=>
+  %string|unicode%(3) "php"
+  [0]=>
+  %string|unicode%(3) "php"
+}
+array(2) {
+  ["testing(name)"]=>
+  %string|unicode%(4) "php6"
+  [0]=>
+  %string|unicode%(4) "php6"
+}
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_get_attribute.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_get_attribute.phpt
new file mode 100644
index 0000000..d6e095d
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_get_attribute.phpt
@@ -0,0 +1,15 @@
+--TEST--
+PDO_sqlite: Testing getAttribute()
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+ 
+$pdo = new PDO('sqlite::memory:');
+var_dump($pdo->getAttribute(PDO::ATTR_SERVER_VERSION));
+var_dump($pdo->getAttribute(PDO::ATTR_CLIENT_VERSION));
+
+?>
+--EXPECTF--
+string(%d) "%s"
+string(%d) "%s"
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_lastinsertid.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_lastinsertid.phpt
new file mode 100644
index 0000000..2ff0acd
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_lastinsertid.phpt
@@ -0,0 +1,32 @@
+--TEST--
+PDO_sqlite: Testing lastInsertId()
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+$db->query('CREATE TABLE IF NOT EXISTS foo (id INT AUTO INCREMENT, name TEXT)');
+$db->query('INSERT INTO foo VALUES (NULL, "PHP")');
+$db->query('INSERT INTO foo VALUES (NULL, "PHP6")');
+var_dump($db->query('SELECT * FROM foo'));
+var_dump($db->errorInfo());
+var_dump($db->lastInsertId());
+
+$db->query('DROP TABLE foo');
+
+?>
+--EXPECTF--
+object(PDOStatement)#2 (1) {
+  ["queryString"]=>
+  %string|unicode%(17) "SELECT * FROM foo"
+}
+array(3) {
+  [0]=>
+  %string|unicode%(5) "00000"
+  [1]=>
+  NULL
+  [2]=>
+  NULL
+}
+%string|unicode%(1) "2"
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_transaction.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_transaction.phpt
new file mode 100644
index 0000000..101cc73
--- /dev/null
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_transaction.phpt
@@ -0,0 +1,28 @@
+--TEST--
+PDO_sqlite: Testing transaction
+--SKIPIF--
+<?php if (!extension_loaded('pdo_sqlite')) print 'skip not loaded'; ?>
+--FILE--
+<?php
+
+$db = new pdo('sqlite::memory:');
+
+$db->beginTransaction();
+
+$db->query('CREATE TABLE IF NOT EXISTS foobar (id INT AUTO INCREMENT, name TEXT)');
+$db->commit();
+
+$db->beginTransaction();
+$db->query('INSERT INTO foobar VALUES (NULL, "PHP")');
+$db->query('INSERT INTO foobar VALUES (NULL, "PHP6")');
+$db->rollback();
+
+$r = $db->query('SELECT COUNT(*) FROM foobar');
+var_dump($r->rowCount());
+
+
+$db->query('DROP TABLE foobar');
+
+?>
+--EXPECTF--
+int(0)