Pdo subclassing

ext/pdo/pdo.c

@@ -31,7 +31,8 @@
 #include "ext/spl/spl_exceptions.h"
 #include "pdo_arginfo.h"
 
-zend_class_entry *pdo_dbh_ce, *pdo_dbstmt_ce, *pdo_row_ce;
+ZEND_API zend_class_entry *pdo_dbh_ce;
+zend_class_entry *pdo_dbstmt_ce, *pdo_row_ce;
 
 /* for exceptional circumstances */
 zend_class_entry *pdo_exception_ce;

ext/pdo/pdo_dbh.c

@@ -221,10 +221,51 @@ static char *dsn_from_uri(char *uri, char *buf, size_t buflen) /* {{{ */
 }
 /* }}} */
 
-/* {{{ */
-PHP_METHOD(PDO, __construct)
+
+#define MAX_PDO_SUB_CLASSES 64
+static unsigned 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
+zend_result pdo_register_driver_specific_class(pdo_driver_class_entry *driver_class_entry)
+{
+	if (number_of_pdo_driver_class_entries >= MAX_PDO_SUB_CLASSES) {
+		php_error_docref(NULL, E_ERROR, "Too many PDO driver subclasses.");
+		return FAILURE;
+	}
+
+	for (unsigned int i=0; i<number_of_pdo_driver_class_entries; i+=1) {
+		if (strcmp(pdo_driver_class_entries[i]->driver_name, driver_class_entry->driver_name) == 0) {
+			php_error_docref(NULL, E_ERROR, "Cannot register duplicate PDO subclass name.");
+			return FAILURE;
+		}
+	}
+
+	pdo_driver_class_entries[number_of_pdo_driver_class_entries] = driver_class_entry;
+	number_of_pdo_driver_class_entries += 1;
+
+	return SUCCESS;
+}
+
+
+static void create_specific_pdo_object(zval *new_object, const char *driver_name)
+{
+	for (unsigned 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;
@@ -291,7 +332,19 @@ PHP_METHOD(PDO, __construct)
 		RETURN_THROWS();
 	}
 
-	dbh = Z_PDO_DBH_P(object);
+	if (object == NULL) {
+		ZEND_ASSERT((driver->driver_name != NULL) && "PDO driver name is null");
+		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) {
@@ -432,8 +485,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)) {
@@ -1344,6 +1413,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(int module_number)
@@ -1359,6 +1430,13 @@ void pdo_dbh_init(int module_number)
 	pdo_dbh_object_handlers.get_method = dbh_method_get;
 	pdo_dbh_object_handlers.compare = zend_objects_not_comparable;
 	pdo_dbh_object_handlers.get_gc = dbh_get_gc;
+
+	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.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

@@ -388,6 +388,13 @@ class PDO
 
     public function __construct(string $dsn, ?string $username = null, #[\SensitiveParameter] ?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/php_pdo.h

@@ -22,6 +22,9 @@
 extern zend_module_entry pdo_module_entry;
 #define phpext_pdo_ptr &pdo_module_entry
 
+extern ZEND_API zend_class_entry *pdo_dbh_ce;
+extern ZEND_API 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;
+
+extern ZEND_API zend_result 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(int module_number);
 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/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.