Pdo sub classing rough WIP

ext/pdo/pdo_dbh.c

@@ -218,10 +218,42 @@ static char *dsn_from_uri(char *uri, char *buf, size_t buflen) /* {{{ */
 }
 /* }}} */
 
-/* {{{ */
-PHP_METHOD(PDO, __construct)
+
+#define MAX_PDO_SUB_CLASSES 64
+static int number_of_pdo_driver_class_entries = 0;
+static pdo_driver_class_entry *pdo_driver_class_entries[MAX_PDO_SUB_CLASSES];
+
+// It would be possible remove this and roll it into the standard driver class entries
+// I chose not to do it at this time, as that would break existing PDO extensions
+void pdo_register_driver_specific_class(pdo_driver_class_entry *driver_class_entry)
+{
+	if (number_of_pdo_driver_class_entries >= MAX_PDO_SUB_CLASSES) {
+
+	}
+
+	pdo_driver_class_entries[number_of_pdo_driver_class_entries] = driver_class_entry;
+	number_of_pdo_driver_class_entries += 1;
+}
+
+
+static
+void create_specific_pdo_object(zval *new_object, const char *driver_name)
+{
+	for (int i=0; i < number_of_pdo_driver_class_entries; i += 1) {
+		pdo_driver_class_entry *driver_class_entry = pdo_driver_class_entries[i];
+		if (strcmp(driver_class_entry->driver_name, driver_name) == 0) {
+			object_init_ex(new_object, driver_class_entry->driver_ce);
+			return;
+		}
+	}
+
+	// No specific DB implementation found
+	object_init_ex(new_object, pdo_dbh_ce);
+}
+
+static
+void internal_construct(INTERNAL_FUNCTION_PARAMETERS, zval *object, zval *new_zval_object)
 {
-	zval *object = ZEND_THIS;
 	pdo_dbh_t *dbh = NULL;
 	bool is_persistent = 0;
 	char *data_source;
@@ -288,7 +320,25 @@ PHP_METHOD(PDO, __construct)
 		RETURN_THROWS();
 	}
 
-	dbh = Z_PDO_DBH_P(object);
+	if (object == NULL) {
+		// could this ever happen?
+		if (driver->driver_name == NULL) {
+			zend_throw_exception_ex(php_pdo_get_exception(), 0, "Driver name is NULL");
+			RETURN_THROWS();
+		}
+
+		create_specific_pdo_object(new_zval_object, driver->driver_name);
+
+		if (new_zval_object == NULL) {
+			zend_throw_exception_ex(php_pdo_get_exception(), 0, "Failed to create specific PDO class");
+			RETURN_THROWS();
+		}
+
+		dbh = Z_PDO_DBH_P(new_zval_object);
+	}
+	else {
+		dbh = Z_PDO_DBH_P(object);
+	}
 
 	/* is this supposed to be a persistent connection ? */
 	if (options) {
@@ -429,8 +479,24 @@ PHP_METHOD(PDO, __construct)
 		zend_throw_exception(pdo_exception_ce, "Constructor failed", 0);
 	}
 }
+
+/* {{{ */
+PHP_METHOD(PDO, __construct)
+{
+	zval *object = ZEND_THIS;
+	internal_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, object, NULL);
+}
 /* }}} */
 
+
+/* {{{ */
+PHP_METHOD(PDO, connect)
+{
+	internal_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, NULL, return_value);
+}
+/* }}} */
+
+
 static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args) /* {{{ */
 {
 	if (!Z_ISUNDEF_P(ctor_args)) {
@@ -1323,6 +1389,8 @@ static HashTable *dbh_get_gc(zend_object *object, zval **gc_data, int *gc_count)
 }
 
 static zend_object_handlers pdo_dbh_object_handlers;
+static zend_object_handlers pdosqlite_dbh_object_handlers;
+
 static void pdo_dbh_free_storage(zend_object *std);
 
 void pdo_dbh_init(void)
@@ -1423,6 +1491,15 @@ void pdo_dbh_init(void)
 
 	REGISTER_PDO_CLASS_CONST_LONG("CURSOR_FWDONLY", (zend_long)PDO_CURSOR_FWDONLY);
 	REGISTER_PDO_CLASS_CONST_LONG("CURSOR_SCROLL", (zend_long)PDO_CURSOR_SCROLL);
+
+
+	memcpy(&pdosqlite_dbh_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+	pdosqlite_dbh_object_handlers.offset = XtOffsetOf(pdo_dbh_object_t, std);
+	pdosqlite_dbh_object_handlers.free_obj = pdo_dbh_free_storage;
+	pdosqlite_dbh_object_handlers.clone_obj = NULL;
+	pdosqlite_dbh_object_handlers.get_method = dbh_method_get;
+	pdosqlite_dbh_object_handlers.compare = zend_objects_not_comparable;
+	pdosqlite_dbh_object_handlers.get_gc = dbh_get_gc;
 }
 
 static void dbh_free(pdo_dbh_t *dbh, bool free_persistent)

ext/pdo/pdo_dbh.stub.php

@@ -7,6 +7,13 @@ class PDO
 {
     public function __construct(string $dsn, ?string $username = null, ?string $password = null, ?array $options = null) {}
 
+    public static function connect(
+        string $dsn,
+        ?string $username = null,
+        ?string $password = null,
+        ?array $options = null
+    ): PDO|PDOSqlite {}
+
     /** @tentative-return-type */
     public function beginTransaction(): bool {}
 

ext/pdo/pdo_dbh_arginfo.h

@@ -1,5 +1,5 @@
 /* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 7d10dbdfd55eb4a4dc779cbf4fa000cdf4fb3539 */
+ * Stub hash: 9ad9db0f01bb0f36d1ff11c15428799d38a1a22f */
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_class_PDO___construct, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO(0, dsn, IS_STRING, 0)
@@ -8,6 +8,13 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_class_PDO___construct, 0, 0, 1)
 	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_ARRAY, 1, "null")
 ZEND_END_ARG_INFO()
 
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_class_PDO_connect, 0, 1, PDO|PDOSqlite, 0)
+	ZEND_ARG_TYPE_INFO(0, dsn, IS_STRING, 0)
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, username, IS_STRING, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, password, IS_STRING, 1, "null")
+	ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, options, IS_ARRAY, 1, "null")
+ZEND_END_ARG_INFO()
+
 ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(arginfo_class_PDO_beginTransaction, 0, 0, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
@@ -60,6 +67,7 @@ ZEND_END_ARG_INFO()
 
 
 ZEND_METHOD(PDO, __construct);
+ZEND_METHOD(PDO, connect);
 ZEND_METHOD(PDO, beginTransaction);
 ZEND_METHOD(PDO, commit);
 ZEND_METHOD(PDO, errorCode);
@@ -78,6 +86,7 @@ ZEND_METHOD(PDO, setAttribute);
 
 static const zend_function_entry class_PDO_methods[] = {
 	ZEND_ME(PDO, __construct, arginfo_class_PDO___construct, ZEND_ACC_PUBLIC)
+	ZEND_ME(PDO, connect, arginfo_class_PDO_connect, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_ME(PDO, beginTransaction, arginfo_class_PDO_beginTransaction, ZEND_ACC_PUBLIC)
 	ZEND_ME(PDO, commit, arginfo_class_PDO_commit, ZEND_ACC_PUBLIC)
 	ZEND_ME(PDO, errorCode, arginfo_class_PDO_errorCode, ZEND_ACC_PUBLIC)

ext/pdo/php_pdo.h

@@ -22,6 +22,9 @@
 extern zend_module_entry pdo_module_entry;
 #define phpext_pdo_ptr &pdo_module_entry
 
+extern zend_class_entry *pdo_dbh_ce;
+extern zend_object *pdo_dbh_new(zend_class_entry *ce);
+
 #include "php_version.h"
 #define PHP_PDO_VERSION PHP_VERSION
 

ext/pdo/php_pdo_driver.h

@@ -215,6 +215,16 @@ typedef struct {
 
 } pdo_driver_t;
 
+// NOTE - This separate struct, could be rolled it into pdo_driver_t
+// I chose not to, as that would cause BC break and require a lot of
+// downstream work.
+typedef struct {
+	char *driver_name;
+	zend_class_entry *driver_ce;
+} pdo_driver_class_entry;
+
+void pdo_register_driver_specific_class(pdo_driver_class_entry *driver_class_entry);
+
 /* {{{ methods for a database handle */
 
 /* close or otherwise disconnect the database */

ext/pdo/php_pdo_int.h

@@ -28,9 +28,7 @@ int php_pdo_list_entry(void);
 void pdo_dbh_init(void);
 void pdo_stmt_init(void);
 
-extern zend_object *pdo_dbh_new(zend_class_entry *ce);
 extern const zend_function_entry pdo_dbh_functions[];
-extern zend_class_entry *pdo_dbh_ce;
 extern ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor);
 
 extern zend_object *pdo_dbstmt_new(zend_class_entry *ce);

ext/pdo_dblib/pdo_dblib.c

@@ -27,10 +27,14 @@
 #include "php_pdo_dblib.h"
 #include "php_pdo_dblib_int.h"
 #include "zend_exceptions.h"
+#include "pdo_dblib_arginfo.h"
 
 ZEND_DECLARE_MODULE_GLOBALS(dblib)
 static PHP_GINIT_FUNCTION(dblib);
 
+zend_class_entry *PdoDblib_ce;
+static pdo_driver_class_entry PdoDblib_pdo_driver_class_entry;
+
 static const zend_module_dep pdo_dblib_deps[] = {
 	ZEND_MOD_REQUIRED("pdo")
 	ZEND_MOD_END
@@ -201,6 +205,13 @@ PHP_MINIT_FUNCTION(pdo_dblib)
 		return FAILURE;
 	}
 
+	PdoDblib_ce = register_class_PdoDblib(pdo_dbh_ce);
+	PdoDblib_ce->create_object = pdo_dbh_new;
+
+	PdoDblib_pdo_driver_class_entry.driver_name = "dblib";
+	PdoDblib_pdo_driver_class_entry.driver_ce = PdoDblib_ce;
+	pdo_register_driver_specific_class(&PdoDblib_pdo_driver_class_entry);
+
 	if (FAILURE == php_pdo_register_driver(&pdo_dblib_driver)) {
 		return FAILURE;
 	}

ext/pdo_dblib/pdo_dblib.stub.php

@@ -0,0 +1,9 @@
+<?php
+
+/** @generate-class-entries */
+
+/** @not-serializable */
+class PdoDblib extends PDO
+{
+
+}

ext/pdo_dblib/pdo_dblib_arginfo.h

@@ -0,0 +1,20 @@
+/* This is a generated file, edit the .stub.php file instead.
+ * Stub hash: 06c2f52a638c1ca9c56bcbebdc00367bb3eb9b26 */
+
+
+
+
+static const zend_function_entry class_PdoDblib_methods[] = {
+	ZEND_FE_END
+};
+
+static zend_class_entry *register_class_PdoDblib(zend_class_entry *class_entry_PDO)
+{
+	zend_class_entry ce, *class_entry;
+
+	INIT_CLASS_ENTRY(ce, "PdoDblib", class_PdoDblib_methods);
+	class_entry = zend_register_internal_class_ex(&ce, class_entry_PDO);
+	class_entry->ce_flags |= ZEND_ACC_NOT_SERIALIZABLE;
+
+	return class_entry;
+}

ext/pdo_dblib/tests/config_functions.inc

@@ -0,0 +1,24 @@
+<?php
+
+function getDsnUserAndPassword()
+{
+
+    if (false !== getenv('PDO_DBLIB_TEST_DSN')) {
+        $dsn = getenv('PDO_DBLIB_TEST_DSN');
+    } else {
+        $dsn = 'dblib:host=localhost;dbname=test';
+    }
+
+    if (false !== getenv('PDO_DBLIB_TEST_USER')) {
+        $user = getenv('PDO_DBLIB_TEST_USER');
+    } else {
+        $user = 'php';
+    }
+
+    if (false !== getenv('PDO_DBLIB_TEST_PASS')) {
+        $pass = getenv('PDO_DBLIB_TEST_PASS');
+    } else {
+        $pass = 'password';
+    }
+    return [$dsn, $user, $pass];
+}

ext/pdo_dblib/tests/subclasses/pdodblib_001.phpt

@@ -0,0 +1,49 @@
+--TEST--
+PdoDblib basic
+--EXTENSIONS--
+pdo
+--FILE--
+<?php
+
+require_once __DIR__ . "/../config_functions.inc";
+
+if (class_exists(PdoDblib::class) === false) {
+    echo "PdoDblib class does not exist.\n";
+    exit(-1);
+}
+echo "PdoDblib class exists.\n";
+
+
+[$dsn, $user, $pass] = getDsnUserAndPassword();
+
+$db = new PdoDblib($dsn, $user, $pass);
+
+$db->query('drop table if exists #foobar;');
+
+$db->query("create table #foobar(name varchar(32)); ");
+$db->query("insert into #foobar values('PHP');");
+$db->query("insert into #foobar values('PHP6');");
+
+foreach ($db->query('SELECT name FROM #foobar') as $row) {
+    var_dump($row);
+}
+
+$db->query('drop table #foobar;');
+
+echo "Fin.";
+?>
+--EXPECT--
+PdoDblib class exists.
+array(2) {
+  ["name"]=>
+  string(3) "PHP"
+  [0]=>
+  string(3) "PHP"
+}
+array(2) {
+  ["name"]=>
+  string(4) "PHP6"
+  [0]=>
+  string(4) "PHP6"
+}
+Fin.

ext/pdo_dblib/tests/subclasses/pdodblib_002.phpt

@@ -0,0 +1,53 @@
+--TEST--
+PdoDblib create through PDO::connect
+--EXTENSIONS--
+pdo
+--FILE--
+<?php
+
+require_once __DIR__ . "/../config_functions.inc";
+
+if (class_exists(PdoDblib::class) === false) {
+    echo "PdoDblib class does not exist.\n";
+    exit(-1);
+}
+
+echo "PdoDblib class exists.\n";
+
+[$dsn, $user, $pass] = getDsnUserAndPassword();
+
+$db = Pdo::connect($dsn, $user, $pass);
+
+if (!$db instanceof PdoDblib) {
+    echo "Wrong class type. Should be PdoDblib but is [" . get_class($db) . "\n";
+}
+
+$db->query('drop table if exists #test;');
+
+$db->query("create table #test(name varchar(32)); ");
+$db->query("insert into #test values('PHP');");
+$db->query("insert into #test values('PHP6');");
+
+foreach ($db->query('SELECT name FROM #test') as $row) {
+    var_dump($row);
+}
+
+$db->query('drop table #test;');
+
+echo "Fin.";
+?>
+--EXPECT--
+PdoDblib class exists.
+array(2) {
+  ["name"]=>
+  string(3) "PHP"
+  [0]=>
+  string(3) "PHP"
+}
+array(2) {
+  ["name"]=>
+  string(4) "PHP6"
+  [0]=>
+  string(4) "PHP6"
+}
+Fin.