diff --git a/ext/mysqli/tests/bug77956.phpt b/ext/mysqli/tests/bug77956.phpt
index 28cf694a606a8..d5409f9527511 100644
--- a/ext/mysqli/tests/bug77956.phpt
+++ b/ext/mysqli/tests/bug77956.phpt
@@ -57,5 +57,5 @@ $link->close();
 unlink('bug77956.data');
 ?>
 --EXPECT--
-[006] [2000] LOAD DATA LOCAL INFILE is forbidden, check related settings like mysqli.allow_local_infile|mysqli.local_infile_directory or PDO::MYSQL_ATTR_LOCAL_INFILE|PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY
+[006] [2000] LOAD DATA LOCAL INFILE is forbidden, check related settings like mysqli.allow_local_infile|mysqli.local_infile_directory or Pdo\Mysql::ATTR_LOCAL_INFILE|Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY
 done
diff --git a/ext/mysqlnd/mysqlnd_loaddata.c b/ext/mysqlnd/mysqlnd_loaddata.c
index ba2dabf95a2c5..a1e04de270085 100644
--- a/ext/mysqlnd/mysqlnd_loaddata.c
+++ b/ext/mysqlnd/mysqlnd_loaddata.c
@@ -167,7 +167,7 @@ mysqlnd_handle_local_infile(MYSQLND_CONN_DATA * conn, const char * const filenam
 		SET_CLIENT_ERROR(conn->error_info, CR_LOAD_DATA_LOCAL_INFILE_REJECTED, UNKNOWN_SQLSTATE,
 						"LOAD DATA LOCAL INFILE is forbidden, check related settings like "
 						"mysqli.allow_local_infile|mysqli.local_infile_directory or "
-						"PDO::MYSQL_ATTR_LOCAL_INFILE|PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY");
+						"Pdo\\Mysql::ATTR_LOCAL_INFILE|Pdo\\Mysql::ATTR_LOCAL_INFILE_DIRECTORY");
 		prerequisities_ok = FALSE;
 	}
 
diff --git a/ext/pdo/php_pdo.h b/ext/pdo/php_pdo.h
index 1618c78d62284..59789a04c73f2 100644
--- a/ext/pdo/php_pdo.h
+++ b/ext/pdo/php_pdo.h
@@ -18,6 +18,9 @@
 #define PHP_PDO_H
 
 #include "zend.h"
+#include "Zend/zend_compile.h"
+#include "Zend/zend_API.h"
+#include "Zend/zend_attributes.h"
 
 PHPAPI extern zend_module_entry pdo_module_entry;
 #define phpext_pdo_ptr &pdo_module_entry
@@ -50,8 +53,47 @@ PHP_MINIT_FUNCTION(pdo);
 PHP_MSHUTDOWN_FUNCTION(pdo);
 PHP_MINFO_FUNCTION(pdo);
 
-#define REGISTER_PDO_CLASS_CONST_LONG(const_name, value) \
-	zend_declare_class_constant_long(php_pdo_get_dbh_ce(), const_name, sizeof(const_name)-1, (zend_long)value);
+static inline void pdo_declare_deprecated_class_constant_long(
+		zend_class_entry *ce, const char *name, zend_long value,
+		zend_string *since, const char *message) {
+
+	zval zvalue;
+	ZVAL_LONG(&zvalue, value);
+
+	zend_string *name_str = zend_string_init_interned(name, strlen(name), true);
+
+	zend_class_constant *constant = zend_declare_class_constant_ex(
+			ce, name_str, &zvalue,
+			ZEND_ACC_PUBLIC|ZEND_ACC_DEPRECATED, NULL);
+
+	zend_attribute *attr = zend_add_class_constant_attribute(ce, constant,
+			ZSTR_KNOWN(ZEND_STR_DEPRECATED_CAPITALIZED),
+			1 + (message != NULL));
+
+	attr->args[0].name = ZSTR_KNOWN(ZEND_STR_SINCE);
+	ZVAL_STR(&attr->args[0].value, since);
+
+	if (message) {
+		zend_string *message_str = zend_string_init_interned(message, strlen(message), true);
+
+		attr->args[1].name = ZSTR_KNOWN(ZEND_STR_MESSAGE);
+		ZVAL_STR(&attr->args[1].value, message_str);
+	}
+}
+
+/* Declare a constant deprecated in 8.5 */
+#define REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_85(const_name, value) 													\
+	pdo_declare_deprecated_class_constant_long(php_pdo_get_dbh_ce(), \
+			const_name, (zend_long)value, \
+			ZSTR_KNOWN(ZEND_STR_8_DOT_5), NULL)
+
+/* Declare one of the constants deprecated in https://wiki.php.net/rfc/deprecations_php_8_5
+ * "Deprecate driver specific PDO constants and methods" */
+#define REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(name, old_prefix, new_prefix, value) \
+	pdo_declare_deprecated_class_constant_long(php_pdo_get_dbh_ce(), \
+			old_prefix name, (zend_long)value, \
+			ZSTR_KNOWN(ZEND_STR_8_DOT_5), \
+			"use " new_prefix name " instead")
 
 #define LONG_CONST(c) (zend_long) c
 
diff --git a/ext/pdo/tests/pdo_016.phpt b/ext/pdo/tests/pdo_016.phpt
index 5b99930f2495c..2a5fa8d85f512 100644
--- a/ext/pdo/tests/pdo_016.phpt
+++ b/ext/pdo/tests/pdo_016.phpt
@@ -17,7 +17,7 @@ require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc';
 $db = PDOTest::factory();
 
 if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
-    $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+    $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
 }
 
 $db->exec('CREATE TABLE test016(idx int NOT NULL PRIMARY KEY, txt VARCHAR(20))');
diff --git a/ext/pdo/tests/pdo_016a.phpt b/ext/pdo/tests/pdo_016a.phpt
index d7dcb2c65430b..2c0590594a84f 100644
--- a/ext/pdo/tests/pdo_016a.phpt
+++ b/ext/pdo/tests/pdo_016a.phpt
@@ -17,7 +17,7 @@ require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc';
 $db = PDOTest::factory();
 
 if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
-    $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+    $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
 }
 
 $db->exec('CREATE TABLE test016a(idx int NOT NULL PRIMARY KEY, txt VARCHAR(20))');
diff --git a/ext/pdo/tests/pdo_021.phpt b/ext/pdo/tests/pdo_021.phpt
index 494ad3c39c50f..7ca3b075881f4 100644
--- a/ext/pdo/tests/pdo_021.phpt
+++ b/ext/pdo/tests/pdo_021.phpt
@@ -16,7 +16,7 @@ require_once getenv('REDIR_TEST_DIR') . 'pdo_test.inc';
 $db = PDOTest::factory();
 
 if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
-    $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+    $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
 }
 
 $db->exec('CREATE TABLE test021(id INT NOT NULL PRIMARY KEY, val VARCHAR(10), val2 VARCHAR(16))');
diff --git a/ext/pdo_dblib/pdo_dblib.c b/ext/pdo_dblib/pdo_dblib.c
index b16208fbd8e78..9c59ddbc61849 100644
--- a/ext/pdo_dblib/pdo_dblib.c
+++ b/ext/pdo_dblib/pdo_dblib.c
@@ -190,15 +190,18 @@ PHP_RSHUTDOWN_FUNCTION(pdo_dblib)
 	return SUCCESS;
 }
 
+#define REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, value) \
+		REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, "DBLIB_", "Pdo\\Dblib::", value)
+
 PHP_MINIT_FUNCTION(pdo_dblib)
 {
-	REGISTER_PDO_CLASS_CONST_LONG("DBLIB_ATTR_CONNECTION_TIMEOUT", (long) PDO_DBLIB_ATTR_CONNECTION_TIMEOUT);
-	REGISTER_PDO_CLASS_CONST_LONG("DBLIB_ATTR_QUERY_TIMEOUT", (long) PDO_DBLIB_ATTR_QUERY_TIMEOUT);
-	REGISTER_PDO_CLASS_CONST_LONG("DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER", (long) PDO_DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER);
-	REGISTER_PDO_CLASS_CONST_LONG("DBLIB_ATTR_VERSION", (long) PDO_DBLIB_ATTR_VERSION);
-	REGISTER_PDO_CLASS_CONST_LONG("DBLIB_ATTR_TDS_VERSION", (long) PDO_DBLIB_ATTR_TDS_VERSION);
-	REGISTER_PDO_CLASS_CONST_LONG("DBLIB_ATTR_SKIP_EMPTY_ROWSETS", (long) PDO_DBLIB_ATTR_SKIP_EMPTY_ROWSETS);
-	REGISTER_PDO_CLASS_CONST_LONG("DBLIB_ATTR_DATETIME_CONVERT", (long) PDO_DBLIB_ATTR_DATETIME_CONVERT);
+	REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_CONNECTION_TIMEOUT", (long) PDO_DBLIB_ATTR_CONNECTION_TIMEOUT);
+	REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_QUERY_TIMEOUT", (long) PDO_DBLIB_ATTR_QUERY_TIMEOUT);
+	REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_STRINGIFY_UNIQUEIDENTIFIER", (long) PDO_DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER);
+	REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_VERSION", (long) PDO_DBLIB_ATTR_VERSION);
+	REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_TDS_VERSION", (long) PDO_DBLIB_ATTR_TDS_VERSION);
+	REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SKIP_EMPTY_ROWSETS", (long) PDO_DBLIB_ATTR_SKIP_EMPTY_ROWSETS);
+	REGISTER_PDO_DBLIB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_DATETIME_CONVERT", (long) PDO_DBLIB_ATTR_DATETIME_CONVERT);
 
 	if (FAIL == dbinit()) {
 		return FAILURE;
diff --git a/ext/pdo_dblib/tests/bug_69592.phpt b/ext/pdo_dblib/tests/bug_69592.phpt
index d7114e8fa09d6..711713775c446 100644
--- a/ext/pdo_dblib/tests/bug_69592.phpt
+++ b/ext/pdo_dblib/tests/bug_69592.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO_DBLIB: PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS for skip junk resultsets on SET NOCOUNT expression
+PDO_DBLIB: Pdo\Dblib::ATTR_SKIP_EMPTY_ROWSETS for skip junk resultsets on SET NOCOUNT expression
 --EXTENSIONS--
 pdo_dblib
 --SKIPIF--
@@ -18,7 +18,7 @@ $sql = '
     SELECT 0 AS [result]
 ';
 
-var_dump($db->getAttribute(PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS));
+var_dump($db->getAttribute(Pdo\Dblib::ATTR_SKIP_EMPTY_ROWSETS));
 
 $stmt = $db->query($sql);
 var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
@@ -27,15 +27,15 @@ var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 $stmt->closeCursor();
 
 
-$db->setAttribute(PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS, true);
-var_dump($db->getAttribute(PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS));
+$db->setAttribute(Pdo\Dblib::ATTR_SKIP_EMPTY_ROWSETS, true);
+var_dump($db->getAttribute(Pdo\Dblib::ATTR_SKIP_EMPTY_ROWSETS));
 
 $stmt = $db->query($sql);
 var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 var_dump($stmt->nextRowset());
 var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 $stmt->closeCursor();
-var_dump($db->getAttribute(PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS));
+var_dump($db->getAttribute(Pdo\Dblib::ATTR_SKIP_EMPTY_ROWSETS));
 
 ?>
 --EXPECT--
diff --git a/ext/pdo_dblib/tests/bug_73396.phpt b/ext/pdo_dblib/tests/bug_73396.phpt
index b2f96f8ec1c98..93dc66778a16a 100644
--- a/ext/pdo_dblib/tests/bug_73396.phpt
+++ b/ext/pdo_dblib/tests/bug_73396.phpt
@@ -6,7 +6,7 @@ pdo_dblib
 <?php
 require __DIR__ . '/config.inc';
 $db = getDbConnection();
-if (in_array($db->getAttribute(PDO::DBLIB_ATTR_TDS_VERSION), ['4.2', '4.6', '5.0', '6.0', '7.0'])) die('skip bigint type is unsupported by active TDS version');
+if (in_array($db->getAttribute(Pdo\Dblib::ATTR_TDS_VERSION), ['4.2', '4.6', '5.0', '6.0', '7.0'])) die('skip bigint type is unsupported by active TDS version');
 ?>
 --FILE--
 <?php
diff --git a/ext/pdo_dblib/tests/config.inc b/ext/pdo_dblib/tests/config.inc
index de3daf0346d81..1612a80a93369 100644
--- a/ext/pdo_dblib/tests/config.inc
+++ b/ext/pdo_dblib/tests/config.inc
@@ -5,7 +5,7 @@
 // assume this bug isn't present if not using FreeTDS
 // otherwise require FreeTDS>=1.1
 function driver_supports_batch_statements_without_select($db) {
-    $version = $db->getAttribute(PDO::DBLIB_ATTR_VERSION);
+    $version = $db->getAttribute(Pdo\Dblib::ATTR_VERSION);
     return !strstartswith($version, 'freetds ') || !strstartswith($version, 'freetds v1.0');
 }
 
diff --git a/ext/pdo_dblib/tests/datetime2.phpt b/ext/pdo_dblib/tests/datetime2.phpt
index e4f65048dd897..2b54361a30e59 100644
--- a/ext/pdo_dblib/tests/datetime2.phpt
+++ b/ext/pdo_dblib/tests/datetime2.phpt
@@ -6,7 +6,7 @@ pdo_dblib
 <?php
 require __DIR__ . '/config.inc';
 $db = getDbConnection();
-if (in_array($db->getAttribute(PDO::DBLIB_ATTR_TDS_VERSION), ['4.2', '4.6', '5.0', '6.0', '7.0', '7.1', '7.2'])) die('skip feature unsupported by this TDS version');
+if (in_array($db->getAttribute(Pdo\Dblib::ATTR_TDS_VERSION), ['4.2', '4.6', '5.0', '6.0', '7.0', '7.1', '7.2'])) die('skip feature unsupported by this TDS version');
 ?>
 --FILE--
 <?php
@@ -16,13 +16,13 @@ $db = getDbConnection();
 
 $sql = "SELECT convert(datetime2, '10231017 10:22:44.1355318') AS [d]";
 
-var_dump($db->getAttribute(PDO::DBLIB_ATTR_DATETIME_CONVERT));
+var_dump($db->getAttribute(Pdo\Dblib::ATTR_DATETIME_CONVERT));
 
 $stmt = $db->query($sql);
 var_dump($stmt->fetch(PDO::FETCH_ASSOC));
 
-$db->setAttribute(PDO::DBLIB_ATTR_DATETIME_CONVERT, 1);
-var_dump($db->getAttribute(PDO::DBLIB_ATTR_DATETIME_CONVERT));
+$db->setAttribute(Pdo\Dblib::ATTR_DATETIME_CONVERT, 1);
+var_dump($db->getAttribute(Pdo\Dblib::ATTR_DATETIME_CONVERT));
 $stmt = $db->query($sql);
 var_dump($stmt->fetch(PDO::FETCH_ASSOC));
 
diff --git a/ext/pdo_dblib/tests/datetime_convert.phpt b/ext/pdo_dblib/tests/datetime_convert.phpt
index ec858cf351c57..0934dd7f83e76 100644
--- a/ext/pdo_dblib/tests/datetime_convert.phpt
+++ b/ext/pdo_dblib/tests/datetime_convert.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO_DBLIB: PDO::DBLIB_ATTR_DATETIME_CONVERT
+PDO_DBLIB: Pdo\Dblib::ATTR_DATETIME_CONVERT
 --EXTENSIONS--
 pdo_dblib
 --SKIPIF--
@@ -15,14 +15,14 @@ $db = getDbConnection();
 
 $sql = "SELECT convert(datetime, '20171027 10:22:44.135') AS [d]";
 
-var_dump($db->getAttribute(PDO::DBLIB_ATTR_DATETIME_CONVERT));
+var_dump($db->getAttribute(Pdo\Dblib::ATTR_DATETIME_CONVERT));
 
 $stmt = $db->query($sql);
 var_dump($stmt->fetch(PDO::FETCH_ASSOC));
 
 // assume default date format: %b %e %Y %I:%M:%S:%z%p
-$db->setAttribute(PDO::DBLIB_ATTR_DATETIME_CONVERT, 1);
-var_dump($db->getAttribute(PDO::DBLIB_ATTR_DATETIME_CONVERT));
+$db->setAttribute(Pdo\Dblib::ATTR_DATETIME_CONVERT, 1);
+var_dump($db->getAttribute(Pdo\Dblib::ATTR_DATETIME_CONVERT));
 $stmt = $db->query($sql);
 var_dump($stmt->fetch(PDO::FETCH_ASSOC));
 
diff --git a/ext/pdo_dblib/tests/dbtds.phpt b/ext/pdo_dblib/tests/dbtds.phpt
index aa05606a93269..fb2402eec080c 100644
--- a/ext/pdo_dblib/tests/dbtds.phpt
+++ b/ext/pdo_dblib/tests/dbtds.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO_DBLIB: \PDO::DBLIB_ATTR_TDS_VERSION exposes a string or false
+PDO_DBLIB: \Pdo\Dblib::ATTR_TDS_VERSION exposes a string or false
 --EXTENSIONS--
 pdo_dblib
 --SKIPIF--
@@ -13,7 +13,7 @@ require __DIR__ . '/config.inc';
 
 $db = getDbConnection();
 
-$version = $db->getAttribute(PDO::DBLIB_ATTR_TDS_VERSION);
+$version = $db->getAttribute(Pdo\Dblib::ATTR_TDS_VERSION);
 var_dump((is_string($version) && strlen($version)) || $version === false);
 
 ?>
diff --git a/ext/pdo_dblib/tests/dbversion.phpt b/ext/pdo_dblib/tests/dbversion.phpt
index 44dd8f4a86dc3..aa61a26beeb23 100644
--- a/ext/pdo_dblib/tests/dbversion.phpt
+++ b/ext/pdo_dblib/tests/dbversion.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO_DBLIB: \PDO::DBLIB_ATTR_VERSION exposes a string
+PDO_DBLIB: \Pdo\Dblib::ATTR_VERSION exposes a string
 --EXTENSIONS--
 pdo_dblib
 --SKIPIF--
@@ -13,7 +13,7 @@ require __DIR__ . '/config.inc';
 
 $db = getDbConnection();
 
-$version = $db->getAttribute(PDO::DBLIB_ATTR_VERSION);
+$version = $db->getAttribute(Pdo\Dblib::ATTR_VERSION);
 var_dump(is_string($version) && strlen($version));
 
 ?>
diff --git a/ext/pdo_dblib/tests/php_8.5_deprecations.phpt b/ext/pdo_dblib/tests/php_8.5_deprecations.phpt
new file mode 100644
index 0000000000000..bf0e84cb40800
--- /dev/null
+++ b/ext/pdo_dblib/tests/php_8.5_deprecations.phpt
@@ -0,0 +1,39 @@
+--TEST--
+PDO_dblib: PHP 8.5 deprecations
+--EXTENSIONS--
+pdo_dblib
+--FILE--
+<?php
+
+var_dump(
+    PDO::DBLIB_ATTR_CONNECTION_TIMEOUT,
+    PDO::DBLIB_ATTR_QUERY_TIMEOUT,
+    PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER,
+    PDO::DBLIB_ATTR_VERSION,
+    PDO::DBLIB_ATTR_TDS_VERSION,
+    PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS,
+    PDO::DBLIB_ATTR_DATETIME_CONVERT,
+);
+
+?>
+--EXPECTF--
+Deprecated: Constant PDO::DBLIB_ATTR_CONNECTION_TIMEOUT is deprecated since 8.5, use Pdo\Dblib::ATTR_CONNECTION_TIMEOUT instead in %s on line %d
+
+Deprecated: Constant PDO::DBLIB_ATTR_QUERY_TIMEOUT is deprecated since 8.5, use Pdo\Dblib::ATTR_QUERY_TIMEOUT instead in %s on line %d
+
+Deprecated: Constant PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER is deprecated since 8.5, use Pdo\Dblib::ATTR_STRINGIFY_UNIQUEIDENTIFIER instead in %s on line %d
+
+Deprecated: Constant PDO::DBLIB_ATTR_VERSION is deprecated since 8.5, use Pdo\Dblib::ATTR_VERSION instead in %s on line %d
+
+Deprecated: Constant PDO::DBLIB_ATTR_TDS_VERSION is deprecated since 8.5, use Pdo\Dblib::ATTR_TDS_VERSION instead in %s on line %d
+
+Deprecated: Constant PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS is deprecated since 8.5, use Pdo\Dblib::ATTR_SKIP_EMPTY_ROWSETS instead in %s on line %d
+
+Deprecated: Constant PDO::DBLIB_ATTR_DATETIME_CONVERT is deprecated since 8.5, use Pdo\Dblib::ATTR_DATETIME_CONVERT instead in %s on line %d
+int(1000)
+int(1001)
+int(1002)
+int(1003)
+int(1004)
+int(1005)
+int(1006)
diff --git a/ext/pdo_dblib/tests/stringify_uniqueidentifier.phpt b/ext/pdo_dblib/tests/stringify_uniqueidentifier.phpt
index 86c94877c63c1..3e87b4790ca9e 100644
--- a/ext/pdo_dblib/tests/stringify_uniqueidentifier.phpt
+++ b/ext/pdo_dblib/tests/stringify_uniqueidentifier.phpt
@@ -6,7 +6,7 @@ pdo_dblib
 <?php
 require __DIR__ . '/config.inc';
 $db = getDbConnection();
-if (in_array($db->getAttribute(PDO::DBLIB_ATTR_TDS_VERSION), ['4.2', '4.6'])) die('skip feature unsupported by this TDS version');
+if (in_array($db->getAttribute(Pdo\Dblib::ATTR_TDS_VERSION), ['4.2', '4.6'])) die('skip feature unsupported by this TDS version');
 ?>
 --FILE--
 <?php
@@ -22,10 +22,10 @@ $sql = "SELECT CAST('$testGUID' as uniqueidentifier) as [guid]";
 //--------------------------------------------------------------------------------
 // 1. Get and Set the attribute
 //--------------------------------------------------------------------------------
-$db->setAttribute(PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER, true);
-var_dump(true === $db->getAttribute(PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER));
-$db->setAttribute(PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER, false);
-var_dump(false === $db->getAttribute(PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER));
+$db->setAttribute(Pdo\Dblib::ATTR_STRINGIFY_UNIQUEIDENTIFIER, true);
+var_dump(true === $db->getAttribute(Pdo\Dblib::ATTR_STRINGIFY_UNIQUEIDENTIFIER));
+$db->setAttribute(Pdo\Dblib::ATTR_STRINGIFY_UNIQUEIDENTIFIER, false);
+var_dump(false === $db->getAttribute(Pdo\Dblib::ATTR_STRINGIFY_UNIQUEIDENTIFIER));
 
 
 //--------------------------------------------------------------------------------
@@ -54,7 +54,7 @@ var_dump($row['guid'] === $testGUIDBinary);
 // TODO: something from PDO::ATTR_SERVER_VERSION, PDO::ATTR_CLIENT_VERSION or PDO::ATTR_SERVER_INFO should be used
 // to get TDS version and skip this test in this case.
 //--------------------------------------------------------------------------------
-$db->setAttribute(PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER, true);
+$db->setAttribute(Pdo\Dblib::ATTR_STRINGIFY_UNIQUEIDENTIFIER, true);
 $stmt = $db->query($sql);
 $row = $stmt->fetch(PDO::FETCH_ASSOC);
 
diff --git a/ext/pdo_dblib/tests/timeout.phpt b/ext/pdo_dblib/tests/timeout.phpt
index 08e8ef54ecaba..5f935a3d01b89 100644
--- a/ext/pdo_dblib/tests/timeout.phpt
+++ b/ext/pdo_dblib/tests/timeout.phpt
@@ -33,7 +33,7 @@ if (!$stmt->execute()) {
 // pdo_dblib-specific timeout attribute, set after instance created, will control query timeout, causing this query to fail
 $db = getDbConnection();
 $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
-$db->setAttribute(PDO::DBLIB_ATTR_QUERY_TIMEOUT, 1);
+$db->setAttribute(Pdo\Dblib::ATTR_QUERY_TIMEOUT, 1);
 $stmt = $db->prepare($sql);
 if (!$stmt->execute()) {
     echo "OK\n";
@@ -57,7 +57,7 @@ if (!$stmt->execute()) {
 }
 
 // pdo_dblib-specific timeout attribute will control query timeout, causing this query to fail
-$db = getDbConnection(PDO::class, [PDO::ATTR_ERRMODE => PDO::ERRMODE_SILENT, PDO::DBLIB_ATTR_QUERY_TIMEOUT => 1]);
+$db = getDbConnection(PDO::class, [PDO::ATTR_ERRMODE => PDO::ERRMODE_SILENT, Pdo\Dblib::ATTR_QUERY_TIMEOUT => 1]);
 $stmt = $db->prepare($sql);
 if (!$stmt->execute()) {
     echo "OK\n";
diff --git a/ext/pdo_dblib/tests/types.phpt b/ext/pdo_dblib/tests/types.phpt
index a58a969c6f1b0..df04115fee9ee 100644
--- a/ext/pdo_dblib/tests/types.phpt
+++ b/ext/pdo_dblib/tests/types.phpt
@@ -16,7 +16,7 @@ $db = getDbConnection();
 function get_expected_float_string() {
     global $db;
 
-    switch ($db->getAttribute(PDO::DBLIB_ATTR_TDS_VERSION)) {
+    switch ($db->getAttribute(Pdo\Dblib::ATTR_TDS_VERSION)) {
         case '5.0':
         case '6.0':
         case '7.0':
diff --git a/ext/pdo_firebird/pdo_firebird.c b/ext/pdo_firebird/pdo_firebird.c
index 0fbdb7f8c97c5..abc43dd3ad587 100644
--- a/ext/pdo_firebird/pdo_firebird.c
+++ b/ext/pdo_firebird/pdo_firebird.c
@@ -55,11 +55,14 @@ zend_module_entry pdo_firebird_module_entry = { /* {{{ */
 ZEND_GET_MODULE(pdo_firebird)
 #endif
 
+#define REGISTER_PDO_FB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, value) \
+		REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, "FB_", "Pdo\\Firebird::", value)
+
 PHP_MINIT_FUNCTION(pdo_firebird) /* {{{ */
 {
-	REGISTER_PDO_CLASS_CONST_LONG("FB_ATTR_DATE_FORMAT", (zend_long) PDO_FB_ATTR_DATE_FORMAT);
-	REGISTER_PDO_CLASS_CONST_LONG("FB_ATTR_TIME_FORMAT", (zend_long) PDO_FB_ATTR_TIME_FORMAT);
-	REGISTER_PDO_CLASS_CONST_LONG("FB_ATTR_TIMESTAMP_FORMAT", (zend_long) PDO_FB_ATTR_TIMESTAMP_FORMAT);
+	REGISTER_PDO_FB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_DATE_FORMAT", (zend_long) PDO_FB_ATTR_DATE_FORMAT);
+	REGISTER_PDO_FB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_TIME_FORMAT", (zend_long) PDO_FB_ATTR_TIME_FORMAT);
+	REGISTER_PDO_FB_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_TIMESTAMP_FORMAT", (zend_long) PDO_FB_ATTR_TIMESTAMP_FORMAT);
 
 	if (FAILURE == php_pdo_register_driver(&pdo_firebird_driver)) {
 		return FAILURE;
diff --git a/ext/pdo_firebird/tests/dialect_1.phpt b/ext/pdo_firebird/tests/dialect_1.phpt
index c08b37bf552c1..9b934cd40ec0c 100644
--- a/ext/pdo_firebird/tests/dialect_1.phpt
+++ b/ext/pdo_firebird/tests/dialect_1.phpt
@@ -14,7 +14,7 @@ require("testdb.inc");
 
 $dbh = getDbConnection();
 $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
-$dbh->setAttribute(PDO::FB_ATTR_TIMESTAMP_FORMAT, '%Y-%m-%d %H:%M:%S');
+$dbh->setAttribute(Pdo\Firebird::ATTR_TIMESTAMP_FORMAT, '%Y-%m-%d %H:%M:%S');
 
 $sql =
 'SELECT
diff --git a/ext/pdo_firebird/tests/execute.phpt b/ext/pdo_firebird/tests/execute.phpt
index 464c8c29a9c44..cb749956ecfb1 100644
--- a/ext/pdo_firebird/tests/execute.phpt
+++ b/ext/pdo_firebird/tests/execute.phpt
@@ -12,7 +12,7 @@ $dbh = getDbConnection();
 var_dump($dbh->getAttribute(PDO::ATTR_CONNECTION_STATUS));
 
 $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
-$dbh->setAttribute(PDO::FB_ATTR_TIMESTAMP_FORMAT, '%Y-%m-%d %H:%M:%S');
+$dbh->setAttribute(Pdo\Firebird::ATTR_TIMESTAMP_FORMAT, '%Y-%m-%d %H:%M:%S');
 
 $dbh->exec("CREATE TABLE test_execute (id SMALLINT NOT NULL PRIMARY KEY, text VARCHAR(32),
     datetime TIMESTAMP DEFAULT '2000-02-12' NOT NULL)");
diff --git a/ext/pdo_firebird/tests/gh18276.phpt b/ext/pdo_firebird/tests/gh18276.phpt
index 610876166ccf7..5a1c4b4de295d 100644
--- a/ext/pdo_firebird/tests/gh18276.phpt
+++ b/ext/pdo_firebird/tests/gh18276.phpt
@@ -23,9 +23,9 @@ for ($i = 0; $i < 2; $i++) {
         ],
     );
     // Avoid interned
-    $dbh->setAttribute(PDO::FB_ATTR_DATE_FORMAT, str_repeat('Y----m----d', random_int(1, 1)));
-    $dbh->setAttribute(PDO::FB_ATTR_TIME_FORMAT, str_repeat('H::::i::::s', random_int(1, 1)));
-    $dbh->setAttribute(PDO::FB_ATTR_TIMESTAMP_FORMAT, str_repeat('Y----m----d....H::::i::::s', random_int(1, 1)));
+    $dbh->setAttribute(Pdo\Firebird::ATTR_DATE_FORMAT, str_repeat('Y----m----d', random_int(1, 1)));
+    $dbh->setAttribute(Pdo\Firebird::ATTR_TIME_FORMAT, str_repeat('H::::i::::s', random_int(1, 1)));
+    $dbh->setAttribute(Pdo\Firebird::ATTR_TIMESTAMP_FORMAT, str_repeat('Y----m----d....H::::i::::s', random_int(1, 1)));
     unset($dbh);
 }
 
diff --git a/ext/pdo_firebird/tests/php_8.5_deprecations.phpt b/ext/pdo_firebird/tests/php_8.5_deprecations.phpt
new file mode 100644
index 0000000000000..6919dda408fd3
--- /dev/null
+++ b/ext/pdo_firebird/tests/php_8.5_deprecations.phpt
@@ -0,0 +1,23 @@
+--TEST--
+PDO_firebird: PHP 8.5 deprecations
+--EXTENSIONS--
+pdo_firebird
+--FILE--
+<?php
+
+var_dump(
+    PDO::FB_ATTR_DATE_FORMAT,
+    PDO::FB_ATTR_TIME_FORMAT,
+    PDO::FB_ATTR_TIMESTAMP_FORMAT,
+);
+
+?>
+--EXPECTF--
+Deprecated: Constant PDO::FB_ATTR_DATE_FORMAT is deprecated since 8.5, use Pdo\Firebird::ATTR_DATE_FORMAT instead in %s on line %d
+
+Deprecated: Constant PDO::FB_ATTR_TIME_FORMAT is deprecated since 8.5, use Pdo\Firebird::ATTR_TIME_FORMAT instead in %s on line %d
+
+Deprecated: Constant PDO::FB_ATTR_TIMESTAMP_FORMAT is deprecated since 8.5, use Pdo\Firebird::ATTR_TIMESTAMP_FORMAT instead in %s on line %d
+int(1000)
+int(1001)
+int(1002)
diff --git a/ext/pdo_mysql/mysql_driver.c b/ext/pdo_mysql/mysql_driver.c
index f0a2a887a5c75..786bd9c606cd1 100644
--- a/ext/pdo_mysql/mysql_driver.c
+++ b/ext/pdo_mysql/mysql_driver.c
@@ -84,7 +84,7 @@ int _pdo_mysql_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int lin
 					"Cannot execute queries while other unbuffered queries are active.  "
 					"Consider using PDOStatement::fetchAll().  Alternatively, if your code "
 					"is only ever going to run against mysql, you may enable query "
-					"buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.",
+					"buffering by setting the Pdo\\Mysql::ATTR_USE_BUFFERED_QUERY attribute.",
 					dbh->is_persistent);
 			}
 		} else if (einfo->errcode == 2057) {
diff --git a/ext/pdo_mysql/pdo_mysql.c b/ext/pdo_mysql/pdo_mysql.c
index 772022cdbe937..b45dafbf5d986 100644
--- a/ext/pdo_mysql/pdo_mysql.c
+++ b/ext/pdo_mysql/pdo_mysql.c
@@ -112,37 +112,40 @@ PHP_INI_END()
 
 /* true global environment */
 
+#define REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, value) \
+		REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, "MYSQL_", "Pdo\\Mysql::", value)
+
 /* {{{ PHP_MINIT_FUNCTION */
 static PHP_MINIT_FUNCTION(pdo_mysql)
 {
 	REGISTER_INI_ENTRIES();
 
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_USE_BUFFERED_QUERY", (zend_long)PDO_MYSQL_ATTR_USE_BUFFERED_QUERY);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_LOCAL_INFILE", (zend_long)PDO_MYSQL_ATTR_LOCAL_INFILE);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_INIT_COMMAND", (zend_long)PDO_MYSQL_ATTR_INIT_COMMAND);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_USE_BUFFERED_QUERY", (zend_long)PDO_MYSQL_ATTR_USE_BUFFERED_QUERY);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_LOCAL_INFILE", (zend_long)PDO_MYSQL_ATTR_LOCAL_INFILE);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_INIT_COMMAND", (zend_long)PDO_MYSQL_ATTR_INIT_COMMAND);
 #ifndef PDO_USE_MYSQLND
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_MAX_BUFFER_SIZE", (zend_long)PDO_MYSQL_ATTR_MAX_BUFFER_SIZE);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_READ_DEFAULT_FILE", (zend_long)PDO_MYSQL_ATTR_READ_DEFAULT_FILE);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_READ_DEFAULT_GROUP", (zend_long)PDO_MYSQL_ATTR_READ_DEFAULT_GROUP);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_MAX_BUFFER_SIZE", (zend_long)PDO_MYSQL_ATTR_MAX_BUFFER_SIZE);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_READ_DEFAULT_FILE", (zend_long)PDO_MYSQL_ATTR_READ_DEFAULT_FILE);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_READ_DEFAULT_GROUP", (zend_long)PDO_MYSQL_ATTR_READ_DEFAULT_GROUP);
 #endif
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_COMPRESS", (zend_long)PDO_MYSQL_ATTR_COMPRESS);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_DIRECT_QUERY", (zend_long)PDO_ATTR_EMULATE_PREPARES);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_FOUND_ROWS", (zend_long)PDO_MYSQL_ATTR_FOUND_ROWS);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_IGNORE_SPACE", (zend_long)PDO_MYSQL_ATTR_IGNORE_SPACE);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_SSL_KEY", (zend_long)PDO_MYSQL_ATTR_SSL_KEY);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_SSL_CERT", (zend_long)PDO_MYSQL_ATTR_SSL_CERT);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_SSL_CA", (zend_long)PDO_MYSQL_ATTR_SSL_CA);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_SSL_CAPATH", (zend_long)PDO_MYSQL_ATTR_SSL_CAPATH);
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_SSL_CIPHER", (zend_long)PDO_MYSQL_ATTR_SSL_CIPHER);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_COMPRESS", (zend_long)PDO_MYSQL_ATTR_COMPRESS);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_DIRECT_QUERY", (zend_long)PDO_ATTR_EMULATE_PREPARES);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_FOUND_ROWS", (zend_long)PDO_MYSQL_ATTR_FOUND_ROWS);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_IGNORE_SPACE", (zend_long)PDO_MYSQL_ATTR_IGNORE_SPACE);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SSL_KEY", (zend_long)PDO_MYSQL_ATTR_SSL_KEY);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SSL_CERT", (zend_long)PDO_MYSQL_ATTR_SSL_CERT);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SSL_CA", (zend_long)PDO_MYSQL_ATTR_SSL_CA);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SSL_CAPATH", (zend_long)PDO_MYSQL_ATTR_SSL_CAPATH);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SSL_CIPHER", (zend_long)PDO_MYSQL_ATTR_SSL_CIPHER);
 #if MYSQL_VERSION_ID > 50605 || defined(PDO_USE_MYSQLND)
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_SERVER_PUBLIC_KEY", (zend_long)PDO_MYSQL_ATTR_SERVER_PUBLIC_KEY);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SERVER_PUBLIC_KEY", (zend_long)PDO_MYSQL_ATTR_SERVER_PUBLIC_KEY);
 #endif
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_MULTI_STATEMENTS", (zend_long)PDO_MYSQL_ATTR_MULTI_STATEMENTS);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_MULTI_STATEMENTS", (zend_long)PDO_MYSQL_ATTR_MULTI_STATEMENTS);
 #ifdef PDO_USE_MYSQLND
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_SSL_VERIFY_SERVER_CERT", (zend_long)PDO_MYSQL_ATTR_SSL_VERIFY_SERVER_CERT);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_SSL_VERIFY_SERVER_CERT", (zend_long)PDO_MYSQL_ATTR_SSL_VERIFY_SERVER_CERT);
 #endif
 #if MYSQL_VERSION_ID >= 80021 || defined(PDO_USE_MYSQLND)
-	REGISTER_PDO_CLASS_CONST_LONG("MYSQL_ATTR_LOCAL_INFILE_DIRECTORY", (zend_long)PDO_MYSQL_ATTR_LOCAL_INFILE_DIRECTORY);
+	REGISTER_PDO_MYSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_LOCAL_INFILE_DIRECTORY", (zend_long)PDO_MYSQL_ATTR_LOCAL_INFILE_DIRECTORY);
 #endif
 
 #ifdef PDO_USE_MYSQLND
diff --git a/ext/pdo_mysql/tests/bug66528.phpt b/ext/pdo_mysql/tests/bug66528.phpt
index 31ae2f42e3a9d..4bddfc9dfcf15 100644
--- a/ext/pdo_mysql/tests/bug66528.phpt
+++ b/ext/pdo_mysql/tests/bug66528.phpt
@@ -13,7 +13,7 @@ require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 $dbh = MySQLPDOTest::factory();
 
 $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
-$dbh->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+$dbh->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
 
 $dbh->exec('CREATE TABLE test_66528 (a INT) ENGINE=InnoDB');
 $dbh->beginTransaction();
@@ -46,6 +46,6 @@ $db = MySQLPDOTest::factory();
 $db->exec('DROP TABLE IF EXISTS test_66528');
 ?>
 --EXPECT--
-SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.
-SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.
-SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.
+SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute.
+SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute.
+SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute.
diff --git a/ext/pdo_mysql/tests/bug67004.phpt b/ext/pdo_mysql/tests/bug67004.phpt
index 019be3fec9dec..39e19a9ed22c4 100644
--- a/ext/pdo_mysql/tests/bug67004.phpt
+++ b/ext/pdo_mysql/tests/bug67004.phpt
@@ -14,7 +14,7 @@ $dbh = MySQLPDOTest::factory();
 
 $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 $dbh->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
-$dbh->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+$dbh->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
 $dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 $stmt = $dbh->prepare("SELECT ?");
 
diff --git a/ext/pdo_mysql/tests/bug68371.phpt b/ext/pdo_mysql/tests/bug68371.phpt
index 146b8e4684d26..5b5152dd054a9 100644
--- a/ext/pdo_mysql/tests/bug68371.phpt
+++ b/ext/pdo_mysql/tests/bug68371.phpt
@@ -16,7 +16,7 @@ $pdo->setAttribute (\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
 $attrs = [
     // Extensive test: default value and set+get values
     PDO::ATTR_EMULATE_PREPARES	    => array(null, true, false),
-    PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => array(null, false, true),
+    Pdo\Mysql::ATTR_USE_BUFFERED_QUERY => array(null, false, true),
 
     // Just test the default
     PDO::ATTR_AUTOCOMMIT			=> [null],
diff --git a/ext/pdo_mysql/tests/bug70389.phpt b/ext/pdo_mysql/tests/bug70389.phpt
index b4f6bf1afeb48..a8bbab8cc16e0 100644
--- a/ext/pdo_mysql/tests/bug70389.phpt
+++ b/ext/pdo_mysql/tests/bug70389.phpt
@@ -11,8 +11,8 @@ MySQLPDOTest::skip();
 <?php
 require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 $flags = [
-    PDO::MYSQL_ATTR_FOUND_ROWS	=> true,
-    PDO::MYSQL_ATTR_LOCAL_INFILE	=> true,
+    Pdo\Mysql::ATTR_FOUND_ROWS	=> true,
+    Pdo\Mysql::ATTR_LOCAL_INFILE	=> true,
     PDO::ATTR_PERSISTENT 		=> true,
 ];
 
diff --git a/ext/pdo_mysql/tests/bug71145.phpt b/ext/pdo_mysql/tests/bug71145.phpt
index 0c6f1a549dfb9..b25207152666f 100644
--- a/ext/pdo_mysql/tests/bug71145.phpt
+++ b/ext/pdo_mysql/tests/bug71145.phpt
@@ -13,7 +13,7 @@ require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 
 $attr = [
     PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
-    PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci; SET SESSION sql_mode=traditional',
+    Pdo\Mysql::ATTR_INIT_COMMAND => 'SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci; SET SESSION sql_mode=traditional',
     PDO::ATTR_STRINGIFY_FETCHES => true,
 ];
 
diff --git a/ext/pdo_mysql/tests/bug71569.phpt b/ext/pdo_mysql/tests/bug71569.phpt
index fe50b669d845b..975474dd55878 100644
--- a/ext/pdo_mysql/tests/bug71569.phpt
+++ b/ext/pdo_mysql/tests/bug71569.phpt
@@ -13,7 +13,7 @@ require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 
 try {
     new PDO(PDO_MYSQL_TEST_DSN, PDO_MYSQL_TEST_USER, PDO_MYSQL_TEST_PASS, [
-        PDO::MYSQL_ATTR_INIT_COMMAND => null,
+        Pdo\Mysql::ATTR_INIT_COMMAND => null,
     ]);
 } catch (PDOException $e) {
     echo $e->getMessage();
diff --git a/ext/pdo_mysql/tests/bug79375.phpt b/ext/pdo_mysql/tests/bug79375.phpt
index fb118f1db2d53..07ccd183d45f1 100644
--- a/ext/pdo_mysql/tests/bug79375.phpt
+++ b/ext/pdo_mysql/tests/bug79375.phpt
@@ -52,7 +52,7 @@ function testPrepareExecute(PDO $db, string $name) {
 }
 
 function testUnbuffered(PDO $db, string $name) {
-    $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+    $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
     $db->exec("SET innodb_lock_wait_timeout = 1");
     $db->exec("START TRANSACTION");
     $query = "SELECT first FROM test_79375 WHERE first = 1 FOR UPDATE";
diff --git a/ext/pdo_mysql/tests/bug80458.phpt b/ext/pdo_mysql/tests/bug80458.phpt
index aecdca6674ccb..a425c69658e15 100644
--- a/ext/pdo_mysql/tests/bug80458.phpt
+++ b/ext/pdo_mysql/tests/bug80458.phpt
@@ -97,7 +97,7 @@ var_dump($stmt5->fetchAll());
 $db->exec("DROP PROCEDURE IF EXISTS {$procedure_ret}");
 
 $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
-$db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+$db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
 
 $stmt = $db->prepare('DELETE FROM test_80458 WHERE first=15');
 $stmt->execute();
diff --git a/ext/pdo_mysql/tests/bug80908.phpt b/ext/pdo_mysql/tests/bug80908.phpt
index 52b7a40dbb3cc..c00c196d9a668 100644
--- a/ext/pdo_mysql/tests/bug80908.phpt
+++ b/ext/pdo_mysql/tests/bug80908.phpt
@@ -23,7 +23,7 @@ $db->exec('CREATE TABLE test_80908 (`id` BIGINT(20) UNSIGNED AUTO_INCREMENT, `na
 
 function testLastInsertId(PDO $db) {
     echo "Running test lastInsertId\n";
-    $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+    $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
     try {
         $db->exec("INSERT INTO test_80908 (`name`) VALUES ('bar')");
         $id = $db->lastInsertId();
diff --git a/ext/pdo_mysql/tests/bug_42499.phpt b/ext/pdo_mysql/tests/bug_42499.phpt
index 6f1534859a0ca..b0c009259e00b 100644
--- a/ext/pdo_mysql/tests/bug_42499.phpt
+++ b/ext/pdo_mysql/tests/bug_42499.phpt
@@ -28,13 +28,13 @@ function bug_42499($db) {
 print "Emulated Prepared Statements...\n";
 $db = MySQLPDOTest::factory();
 $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 1);
-$db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
+$db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 1);
 bug_42499($db);
 
 print "Native Prepared Statements...\n";
 $db = MySQLPDOTest::factory();
 $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
-$db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
+$db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 1);
 bug_42499($db);
 
 print "done!";
@@ -55,7 +55,7 @@ array(1) {
   }
 }
 
-Warning: PDO::exec(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
+Warning: PDO::exec(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
 Native Prepared Statements...
 array(1) {
   [0]=>
@@ -65,5 +65,5 @@ array(1) {
   }
 }
 
-Warning: PDO::exec(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
+Warning: PDO::exec(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
 done!
diff --git a/ext/pdo_mysql/tests/pdo_mysql___construct_options.phpt b/ext/pdo_mysql/tests/pdo_mysql___construct_options.phpt
index ba3054247c2b6..2437e7ca12d16 100644
--- a/ext/pdo_mysql/tests/pdo_mysql___construct_options.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql___construct_options.phpt
@@ -44,11 +44,11 @@ MySQLPDOTest::skip();
             PDO::ATTR_TIMEOUT                  => 'PDO::ATTR_TIMEOUT',
             PDO::ATTR_EMULATE_PREPARES         => 'PDO::ATTR_EMULATE_PREPARES',
 
-            PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => 'PDO::MYSQL_ATTR_USE_BUFFERED_QUERY',
-            PDO::MYSQL_ATTR_LOCAL_INFILE       => 'PDO::MYSQL_ATTR_LOCAL_INFILE',
-            PDO::MYSQL_ATTR_DIRECT_QUERY       => 'PDO::MYSQL_ATTR_DIRECT_QUERY',
+            Pdo\Mysql::ATTR_USE_BUFFERED_QUERY => 'Pdo\Mysql::ATTR_USE_BUFFERED_QUERY',
+            Pdo\Mysql::ATTR_LOCAL_INFILE       => 'Pdo\Mysql::ATTR_LOCAL_INFILE',
+            Pdo\Mysql::ATTR_DIRECT_QUERY       => 'Pdo\Mysql::ATTR_DIRECT_QUERY',
 
-            PDO::MYSQL_ATTR_INIT_COMMAND       => 'PDO::MYSQL_ATTR_INIT_COMMAND',
+            Pdo\Mysql::ATTR_INIT_COMMAND       => 'Pdo\Mysql::ATTR_INIT_COMMAND',
             PDO::ATTR_EMULATE_PREPARES         => 'PDO::ATTR_EMULATE_PREPARES',
         ];
 
@@ -58,12 +58,12 @@ MySQLPDOTest::skip();
             /* TODO - why is this a valid option if getAttribute() does not support it?! */
             PDO::ATTR_TIMEOUT                  => false,
             PDO::ATTR_EMULATE_PREPARES         => true,
-            PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true,
+            Pdo\Mysql::ATTR_USE_BUFFERED_QUERY => true,
             /* TODO getAttribute() does not handle it */
-            PDO::MYSQL_ATTR_LOCAL_INFILE       => false,
+            Pdo\Mysql::ATTR_LOCAL_INFILE       => false,
             /* TODO getAttribute() does not handle it */
-            PDO::MYSQL_ATTR_DIRECT_QUERY       => true,
-            PDO::MYSQL_ATTR_INIT_COMMAND       => '',
+            Pdo\Mysql::ATTR_DIRECT_QUERY       => true,
+            Pdo\Mysql::ATTR_INIT_COMMAND       => '',
         ];
 
         try {
@@ -108,56 +108,56 @@ MySQLPDOTest::skip();
         if (!is_object($db = new PDO($dsn, $user, $pass, array(PDO::ATTR_TIMEOUT => -PHP_INT_MAX))))
             printf("[008] ATTR_TIMEOUT should be accepted\n");
 
-        /* TODO: Its ugly that PDO::ATTR_EMULATE_PREPARES == PDO::MYSQL_ATTR_DIRECT_QUERY */
+        /* TODO: Its ugly that PDO::ATTR_EMULATE_PREPARES == Pdo\Mysql::ATTR_DIRECT_QUERY */
         $db = new PDO($dsn, $user, $pass, array(PDO::ATTR_EMULATE_PREPARES => true));
         if (!is_object($db))
             printf("[009] ATTR_EMULATE_PREPARES should be accepted and on\n");
         if (!$db->getAttribute(PDO::ATTR_EMULATE_PREPARES))
             printf("[010] [TODO][CHANGEREQUEST] ATTR_EMULATE_PREPARES should be on\n");
-        if (!$db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
-            printf("[011] As PDO::MYSQL_ATTR_DIRECT_QUERY == PDO::ATTR_EMULATE_PREPARES
-                and PDO::ATTR_EMULATE_PREPARES overrules the other, PDO::MYSQL_ATTR_DIRECT_QUERY should be on\n");
+        if (!$db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
+            printf("[011] As Pdo\Mysql::ATTR_DIRECT_QUERY == PDO::ATTR_EMULATE_PREPARES
+                and PDO::ATTR_EMULATE_PREPARES overrules the other, Pdo\Mysql::ATTR_DIRECT_QUERY should be on\n");
 
         $db = new PDO($dsn, $user, $pass, array(PDO::ATTR_EMULATE_PREPARES => false));
         if (!is_object($db))
             printf("[012] ATTR_EMULATE_PREPARES should be accepted and on\n");
         if ($db->getAttribute(PDO::ATTR_EMULATE_PREPARES))
             printf("[013] [TODO][CHANGEREQUEST] ATTR_EMULATE_PREPARES should be off\n");
-        if ($db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
-            printf("[014] As PDO::MYSQL_ATTR_DIRECT_QUERY == PDO::ATTR_EMULATE_PREPARES
-                and PDO::ATTR_EMULATE_PREPARES overrules the other, PDO::MYSQL_ATTR_DIRECT_QUERY should be off\n");
+        if ($db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
+            printf("[014] As Pdo\Mysql::ATTR_DIRECT_QUERY == PDO::ATTR_EMULATE_PREPARES
+                and PDO::ATTR_EMULATE_PREPARES overrules the other, Pdo\Mysql::ATTR_DIRECT_QUERY should be off\n");
 
-        // PDO::ATTR_EMULATE_PREPARES overrules PDO::MYSQL_ATTR_DIRECT_QUERY
+        // PDO::ATTR_EMULATE_PREPARES overrules Pdo\Mysql::ATTR_DIRECT_QUERY
         // TODO: is it clever that a generic setting overrules a specific setting?
-        $db = new PDO($dsn, $user, $pass, array(PDO::ATTR_EMULATE_PREPARES => true, PDO::MYSQL_ATTR_DIRECT_QUERY => false));
+        $db = new PDO($dsn, $user, $pass, array(PDO::ATTR_EMULATE_PREPARES => true, Pdo\Mysql::ATTR_DIRECT_QUERY => false));
         if (!$db->getAttribute(PDO::ATTR_EMULATE_PREPARES))
             printf("[015] PDO::ATTR_EMULATE_PREPARES should be on\n");
-        if (!$db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
-            printf("[016] PDO::MYSQL_ATTR_DIRECT_QUERY should be on\n");
+        if (!$db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
+            printf("[016] Pdo\Mysql::ATTR_DIRECT_QUERY should be on\n");
 
-        $db = new PDO($dsn, $user, $pass, array(PDO::ATTR_EMULATE_PREPARES => false, PDO::MYSQL_ATTR_DIRECT_QUERY => true));
+        $db = new PDO($dsn, $user, $pass, array(PDO::ATTR_EMULATE_PREPARES => false, Pdo\Mysql::ATTR_DIRECT_QUERY => true));
         if ($db->getAttribute(PDO::ATTR_EMULATE_PREPARES))
             printf("[017] PDO::ATTR_EMULATE_PREPARES should be off\n");
-        if ($db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
-            printf("[018] PDO::MYSQL_ATTR_DIRECT_QUERY should be off\n");
+        if ($db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
+            printf("[018] Pdo\Mysql::ATTR_DIRECT_QUERY should be off\n");
 
-        set_option_and_check(19, PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true, 'PDO::MYSQL_ATTR_USE_BUFFERED_QUERY');
-        set_option_and_check(20, PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false, 'PDO::MYSQL_ATTR_USE_BUFFERED_QUERY');
+        set_option_and_check(19, Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true, 'Pdo\Mysql::ATTR_USE_BUFFERED_QUERY');
+        set_option_and_check(20, Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false, 'Pdo\Mysql::ATTR_USE_BUFFERED_QUERY');
 
-        set_option_and_check(21, PDO::MYSQL_ATTR_LOCAL_INFILE, true, 'PDO::MYSQL_ATTR_LOCAL_INFILE');
-        set_option_and_check(22, PDO::MYSQL_ATTR_LOCAL_INFILE, false, 'PDO::MYSQL_ATTR_LOCAL_INFILE');
+        set_option_and_check(21, Pdo\Mysql::ATTR_LOCAL_INFILE, true, 'Pdo\Mysql::ATTR_LOCAL_INFILE');
+        set_option_and_check(22, Pdo\Mysql::ATTR_LOCAL_INFILE, false, 'Pdo\Mysql::ATTR_LOCAL_INFILE');
 
-        set_option_and_check(23, PDO::MYSQL_ATTR_INIT_COMMAND, 'SET @a=1', 'PDO::MYSQL_ATTR_INIT_COMMAND');
-        set_option_and_check(24, PDO::MYSQL_ATTR_INIT_COMMAND, '', 'PDO::MYSQL_ATTR_INIT_COMMAND');
-        set_option_and_check(25, PDO::MYSQL_ATTR_INIT_COMMAND, 'INSERT INTO nonexistent(invalid) VALUES (1)', 'PDO::MYSQL_ATTR_INIT_COMMAND');
+        set_option_and_check(23, Pdo\Mysql::ATTR_INIT_COMMAND, 'SET @a=1', 'Pdo\Mysql::ATTR_INIT_COMMAND');
+        set_option_and_check(24, Pdo\Mysql::ATTR_INIT_COMMAND, '', 'Pdo\Mysql::ATTR_INIT_COMMAND');
+        set_option_and_check(25, Pdo\Mysql::ATTR_INIT_COMMAND, 'INSERT INTO nonexistent(invalid) VALUES (1)', 'Pdo\Mysql::ATTR_INIT_COMMAND');
 
-        set_option_and_check(33, PDO::MYSQL_ATTR_DIRECT_QUERY, true, 'PDO::MYSQL_ATTR_DIRECT_QUERY');
-        set_option_and_check(34, PDO::MYSQL_ATTR_DIRECT_QUERY, false, 'PDO::MYSQL_ATTR_DIRECT_QUERY');
+        set_option_and_check(33, Pdo\Mysql::ATTR_DIRECT_QUERY, true, 'Pdo\Mysql::ATTR_DIRECT_QUERY');
+        set_option_and_check(34, Pdo\Mysql::ATTR_DIRECT_QUERY, false, 'Pdo\Mysql::ATTR_DIRECT_QUERY');
 
-        if (defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
-            set_option_and_check(35, PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY, null, 'PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY');
+        if (defined('Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY')) {
+            set_option_and_check(35, Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY, null, 'Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY');
             // libmysqlclient returns the directory with a trailing slash.
-            // set_option_and_check(36, PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY, __DIR__, 'PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY');
+            // set_option_and_check(36, Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY, __DIR__, 'Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY');
         }
     } catch (PDOException $e) {
         printf("[001] %s, [%s] %s Line: %s\n",
@@ -171,12 +171,12 @@ MySQLPDOTest::skip();
 ?>
 --EXPECTF--
 [003] [TODO][CHANGEREQUEST] Please, lets not ignore invalid options and bail out!
-[003a] Expecting default value for 'PDO::MYSQL_ATTR_INIT_COMMAND' of ''/string, getAttribute() reports setting ''/boolean
+[003a] Expecting default value for 'Pdo\Mysql::ATTR_INIT_COMMAND' of ''/string, getAttribute() reports setting ''/boolean
 [015] PDO::ATTR_EMULATE_PREPARES should be on
-[016] PDO::MYSQL_ATTR_DIRECT_QUERY should be on
+[016] Pdo\Mysql::ATTR_DIRECT_QUERY should be on
 [017] PDO::ATTR_EMULATE_PREPARES should be off
-[018] PDO::MYSQL_ATTR_DIRECT_QUERY should be off
-[023] Expecting 'SET @a=1'/string got ''/boolean' for options 'PDO::MYSQL_ATTR_INIT_COMMAND'
+[018] Pdo\Mysql::ATTR_DIRECT_QUERY should be off
+[023] Expecting 'SET @a=1'/string got ''/boolean' for options 'Pdo\Mysql::ATTR_INIT_COMMAND'
 [024] SQLSTATE[42000] [1065] Query was empty
 [025] SQLSTATE[42S02] [1146] Table '%s.nonexistent' doesn't exist
 done!
diff --git a/ext/pdo_mysql/tests/pdo_mysql___construct_options_libmysql.phpt b/ext/pdo_mysql/tests/pdo_mysql___construct_options_libmysql.phpt
index e3d8ee2db6583..c56ee9e5d1e98 100644
--- a/ext/pdo_mysql/tests/pdo_mysql___construct_options_libmysql.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql___construct_options_libmysql.phpt
@@ -36,16 +36,16 @@ if (MySQLPDOTest::isPDOMySQLnd())
     $pass = PDO_MYSQL_TEST_PASS;
 
     $valid_options = [];
-    $valid_options[PDO::MYSQL_ATTR_MAX_BUFFER_SIZE] = 'PDO::MYSQL_ATTR_MAX_BUFFER_SIZE';
-    $valid_options[PDO::MYSQL_ATTR_INIT_COMMAND] = 'PDO::MYSQL_ATTR_INIT_COMMAND';
-    $valid_options[PDO::MYSQL_ATTR_READ_DEFAULT_FILE] = 'PDO::MYSQL_ATTR_READ_DEFAULT_FILE';
-    $valid_options[PDO::MYSQL_ATTR_READ_DEFAULT_GROUP] = 'PDO::MYSQL_ATTR_READ_DEFAULT_GROUP';
+    $valid_options[Pdo\Mysql::ATTR_MAX_BUFFER_SIZE] = 'Pdo\Mysql::ATTR_MAX_BUFFER_SIZE';
+    $valid_options[Pdo\Mysql::ATTR_INIT_COMMAND] = 'Pdo\Mysql::ATTR_INIT_COMMAND';
+    $valid_options[Pdo\Mysql::ATTR_READ_DEFAULT_FILE] = 'Pdo\Mysql::ATTR_READ_DEFAULT_FILE';
+    $valid_options[Pdo\Mysql::ATTR_READ_DEFAULT_GROUP] = 'Pdo\Mysql::ATTR_READ_DEFAULT_GROUP';
 
-    $defaults[PDO::MYSQL_ATTR_MAX_BUFFER_SIZE] = 1048576;
+    $defaults[Pdo\Mysql::ATTR_MAX_BUFFER_SIZE] = 1048576;
     /* TODO getAttribute() does not handle it */
-    $defaults[PDO::MYSQL_ATTR_INIT_COMMAND] = '';
-    $defaults[PDO::MYSQL_ATTR_READ_DEFAULT_FILE] = false;
-    $defaults[PDO::MYSQL_ATTR_READ_DEFAULT_GROUP] = false;
+    $defaults[Pdo\Mysql::ATTR_INIT_COMMAND] = '';
+    $defaults[Pdo\Mysql::ATTR_READ_DEFAULT_FILE] = false;
+    $defaults[Pdo\Mysql::ATTR_READ_DEFAULT_GROUP] = false;
 
     $db = new PDO($dsn, $user, $pass);
     foreach ($valid_options as $option => $name) {
@@ -60,19 +60,19 @@ if (MySQLPDOTest::isPDOMySQLnd())
         }
     }
 
-    set_option_and_check(26, PDO::MYSQL_ATTR_READ_DEFAULT_FILE, true, 'PDO::MYSQL_ATTR_READ_DEFAULT_FILE');
-    set_option_and_check(27, PDO::MYSQL_ATTR_READ_DEFAULT_FILE, false, 'PDO::MYSQL_ATTR_READ_DEFAULT_FILE');
+    set_option_and_check(26, Pdo\Mysql::ATTR_READ_DEFAULT_FILE, true, 'Pdo\Mysql::ATTR_READ_DEFAULT_FILE');
+    set_option_and_check(27, Pdo\Mysql::ATTR_READ_DEFAULT_FILE, false, 'Pdo\Mysql::ATTR_READ_DEFAULT_FILE');
 
-    set_option_and_check(30, PDO::MYSQL_ATTR_MAX_BUFFER_SIZE, -1, 'PDO::MYSQL_ATTR_MAX_BUFFER_SIZE', true);
-    set_option_and_check(31, PDO::MYSQL_ATTR_MAX_BUFFER_SIZE, PHP_INT_MAX, 'PDO::MYSQL_ATTR_MAX_BUFFER_SIZE');
-    set_option_and_check(32, PDO::MYSQL_ATTR_MAX_BUFFER_SIZE, 1, 'PDO::MYSQL_ATTR_MAX_BUFFER_SIZE');
+    set_option_and_check(30, Pdo\Mysql::ATTR_MAX_BUFFER_SIZE, -1, 'Pdo\Mysql::ATTR_MAX_BUFFER_SIZE', true);
+    set_option_and_check(31, Pdo\Mysql::ATTR_MAX_BUFFER_SIZE, PHP_INT_MAX, 'Pdo\Mysql::ATTR_MAX_BUFFER_SIZE');
+    set_option_and_check(32, Pdo\Mysql::ATTR_MAX_BUFFER_SIZE, 1, 'Pdo\Mysql::ATTR_MAX_BUFFER_SIZE');
 
     print "done!\n";
 ?>
 --EXPECT--
-Failed to getAttribute() for PDO::MYSQL_ATTR_INIT_COMMAND
-Failed to getAttribute() for PDO::MYSQL_ATTR_READ_DEFAULT_FILE
-Failed to getAttribute() for PDO::MYSQL_ATTR_READ_DEFAULT_GROUP
-Failed to getAttribute() for PDO::MYSQL_ATTR_READ_DEFAULT_FILE
-Failed to getAttribute() for PDO::MYSQL_ATTR_READ_DEFAULT_FILE
+Failed to getAttribute() for Pdo\Mysql::ATTR_INIT_COMMAND
+Failed to getAttribute() for Pdo\Mysql::ATTR_READ_DEFAULT_FILE
+Failed to getAttribute() for Pdo\Mysql::ATTR_READ_DEFAULT_GROUP
+Failed to getAttribute() for Pdo\Mysql::ATTR_READ_DEFAULT_FILE
+Failed to getAttribute() for Pdo\Mysql::ATTR_READ_DEFAULT_FILE
 done!
diff --git a/ext/pdo_mysql/tests/pdo_mysql_attr_init_command.phpt b/ext/pdo_mysql/tests/pdo_mysql_attr_init_command.phpt
index 94db61e00ded4..b9562247af863 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_attr_init_command.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_attr_init_command.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO::MYSQL_ATTR_INIT_COMMAND
+Pdo\Mysql::ATTR_INIT_COMMAND
 --EXTENSIONS--
 pdo_mysql
 --SKIPIF--
@@ -22,7 +22,7 @@ error_reporting=E_ALL
 
     $create = sprintf('CREATE TABLE %s(id INT)', $table);
     var_dump($create);
-    $db = new PDO($dsn, $user, $pass, array(PDO::MYSQL_ATTR_INIT_COMMAND => $create));
+    $db = new PDO($dsn, $user, $pass, array(Pdo\Mysql::ATTR_INIT_COMMAND => $create));
     $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
 
     $info = $db->errorInfo();
diff --git a/ext/pdo_mysql/tests/pdo_mysql_attr_max_buffer_size.phpt b/ext/pdo_mysql/tests/pdo_mysql_attr_max_buffer_size.phpt
index 293eb71ca0a02..00a0eb0edc105 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_attr_max_buffer_size.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_attr_max_buffer_size.phpt
@@ -1,5 +1,5 @@
 --TEST--
-MySQL PDO->__construct(), PDO::MYSQL_ATTR_MAX_BUFFER_SIZE
+MySQL PDO->__construct(), Pdo\Mysql::ATTR_MAX_BUFFER_SIZE
 --EXTENSIONS--
 pdo_mysql
 --SKIPIF--
@@ -7,7 +7,7 @@ pdo_mysql
 require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 MySQLPDOTest::skip();
 if (MySQLPDOTest::isPDOMySQLnd())
-    die("skip PDO::MYSQL_ATTR_MAX_BUFFER_SIZE not supported with mysqlnd");
+    die("skip Pdo\Mysql::ATTR_MAX_BUFFER_SIZE not supported with mysqlnd");
 ?>
 --FILE--
 <?php
@@ -17,9 +17,9 @@ function try_buffer_size($offset, $buffer_size)
 {
     /* unsigned overflow possible ? */
     $db = new PDO(MySQLPDOTest::getDSN(), PDO_MYSQL_TEST_USER, PDO_MYSQL_TEST_PASS, [
-        PDO::MYSQL_ATTR_MAX_BUFFER_SIZE => $buffer_size,
+        Pdo\Mysql::ATTR_MAX_BUFFER_SIZE => $buffer_size,
         /* buffer is only relevant with native PS */
-        PDO::MYSQL_ATTR_DIRECT_QUERY => 0,
+        Pdo\Mysql::ATTR_DIRECT_QUERY => 0,
         PDO::ATTR_EMULATE_PREPARES => 0,
     ]);
 
diff --git a/ext/pdo_mysql/tests/pdo_mysql_attr_multi_statements.phpt b/ext/pdo_mysql/tests/pdo_mysql_attr_multi_statements.phpt
index 7d0256500f555..16f19da7d1b05 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_attr_multi_statements.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_attr_multi_statements.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO::MYSQL_ATTR_MULTI_STATEMENTS
+Pdo\Mysql::ATTR_MULTI_STATEMENTS
 --EXTENSIONS--
 pdo_mysql
 --SKIPIF--
@@ -37,7 +37,7 @@ error_reporting=E_ALL
     var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 
     // New connection, does not allow multiple statements.
-    $db = new PDO($dsn, $user, $pass, array(PDO::MYSQL_ATTR_MULTI_STATEMENTS => false));
+    $db = new PDO($dsn, $user, $pass, array(Pdo\Mysql::ATTR_MULTI_STATEMENTS => false));
     $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
     $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
     $stmt = $db->query(sprintf('SELECT * FROM %s; INSERT INTO %s(id) VALUES (3)', $table, $table));
diff --git a/ext/pdo_mysql/tests/pdo_mysql_attr_oracle_nulls.phpt b/ext/pdo_mysql/tests/pdo_mysql_attr_oracle_nulls.phpt
index f308f3384f854..d116aa701a142 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_attr_oracle_nulls.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_attr_oracle_nulls.phpt
@@ -47,7 +47,7 @@ MySQLPDOTest::skip();
         $have_procedures = false;
 
     $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
-    $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+    $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
 
     if ($have_procedures && (false !== $db->exec("DROP PROCEDURE IF EXISTS {$procedure}")) &&
         (false !== $db->exec("CREATE PROCEDURE {$procedure}() BEGIN SELECT NULL as z, '' AS a, ' ' AS b, TRIM(' ') as c, ' d' AS d, ' e' AS e; END;"))) {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_exec_load_data.phpt b/ext/pdo_mysql/tests/pdo_mysql_exec_load_data.phpt
index 9876ae0759f33..066843fa71f65 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_exec_load_data.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_exec_load_data.phpt
@@ -55,7 +55,7 @@ function exec_and_count($offset, &$db, $sql, $exp) {
 }
 
 require_once __DIR__ . '/inc/mysql_pdo_test.inc';
-$db = MySQLPDOTest::factoryWithAttr([PDO::MYSQL_ATTR_LOCAL_INFILE=>true]);
+$db = MySQLPDOTest::factoryWithAttr([Pdo\Mysql::ATTR_LOCAL_INFILE=>true]);
 
 /* affected rows related */
 
diff --git a/ext/pdo_mysql/tests/pdo_mysql_exec_select.phpt b/ext/pdo_mysql/tests/pdo_mysql_exec_select.phpt
index fe1550776dc55..fc52a20f21720 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_exec_select.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_exec_select.phpt
@@ -38,7 +38,7 @@ MySQLPDOTest::skip();
         exec_and_count(4, $db, "INSERT INTO test_mysql_exec_select(id, col1) VALUES (1, 'a')", 1);
         // question is: will the result set be cleaned up, will it be possible to run more queries on the line?
         // buffered or unbuffered does not matter!
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
         exec_and_count(5, $db, 'SELECT id FROM test_mysql_exec_select', 0);
         exec_and_count(6, $db, "INSERT INTO test_mysql_exec_select(id, col1) VALUES (2, 'b')", 1);
 
@@ -57,6 +57,6 @@ $db = MySQLPDOTest::factory();
 $db->query('DROP TABLE IF EXISTS test_mysql_exec_select');
 ?>
 --EXPECTF--
-Warning: PDO::exec(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
-[006] Expecting '1'/integer got ''/boolean when running 'INSERT INTO test_mysql_exec_select(id, col1) VALUES (2, 'b')', [HY000] HY000 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.
+Warning: PDO::exec(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
+[006] Expecting '1'/integer got ''/boolean when running 'INSERT INTO test_mysql_exec_select(id, col1) VALUES (2, 'b')', [HY000] HY000 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute.
 done!
diff --git a/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt b/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt
index 6e83be8e1a8f9..ba4aeb7051ef4 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt
@@ -50,27 +50,27 @@ MySQLPDOTest::skipNotTransactionalEngine();
     $obj = new stdClass();
     set_and_get(4, $db, PDO::ATTR_AUTOCOMMIT, $obj);
 
-    set_and_get(5, $db, PDO::MYSQL_ATTR_LOCAL_INFILE, 1);
-    set_and_get(6, $db, PDO::MYSQL_ATTR_LOCAL_INFILE, 0);
-    set_and_get(7, $db, PDO::MYSQL_ATTR_LOCAL_INFILE, -1);
+    set_and_get(5, $db, Pdo\Mysql::ATTR_LOCAL_INFILE, 1);
+    set_and_get(6, $db, Pdo\Mysql::ATTR_LOCAL_INFILE, 0);
+    set_and_get(7, $db, Pdo\Mysql::ATTR_LOCAL_INFILE, -1);
     $tmp = array();
-    set_and_get(8, $db, PDO::MYSQL_ATTR_LOCAL_INFILE, $tmp);
+    set_and_get(8, $db, Pdo\Mysql::ATTR_LOCAL_INFILE, $tmp);
 
-    set_and_get(9, $db, PPDO::MYSQL_ATTR_INIT_COMMAND, '');
-    set_and_get(10, $db, PPDO::MYSQL_ATTR_INIT_COMMAND, 'SOME SQL');
-    set_and_get(11, $db, PPDO::MYSQL_ATTR_INIT_COMMAND, -1);
+    set_and_get(9, $db, PPdo\Mysql::ATTR_INIT_COMMAND, '');
+    set_and_get(10, $db, PPdo\Mysql::ATTR_INIT_COMMAND, 'SOME SQL');
+    set_and_get(11, $db, PPdo\Mysql::ATTR_INIT_COMMAND, -1);
     */
     /*
-    PDO::MYSQL_ATTR_READ_DEFAULT_FILE (integer)
+    Pdo\Mysql::ATTR_READ_DEFAULT_FILE (integer)
 
     Read options from the named option file instead of from my.cnf.
-    PDO::MYSQL_ATTR_READ_DEFAULT_GROUP (integer)
+    Pdo\Mysql::ATTR_READ_DEFAULT_GROUP (integer)
 
     Read options from the named group from my.cnf or the file specified with MYSQL_READ_DEFAULT_FILE.
-    PDO::MYSQL_ATTR_MAX_BUFFER_SIZE (integer)
+    Pdo\Mysql::ATTR_MAX_BUFFER_SIZE (integer)
 
     Maximum buffer size. Defaults to 1 MiB.
-    PDO::MYSQL_ATTR_DIRECT_QUERY (integer)
+    Pdo\Mysql::ATTR_DIRECT_QUERY (integer)
 
     Perform direct queries, don't use prepared statements.
     */
diff --git a/ext/pdo_mysql/tests/pdo_mysql_local_infile_default_off.phpt b/ext/pdo_mysql/tests/pdo_mysql_local_infile_default_off.phpt
index 91a67260f0397..af065bd7d9075 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_local_infile_default_off.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_local_infile_default_off.phpt
@@ -6,7 +6,7 @@ pdo_mysql
 <?php
 require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 MySQLPDOTest::skip();
-if (!defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
+if (!defined('Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY')) {
     die("skip No MYSQL_ATTR_LOCAL_INFILE_DIRECTORY support");
 }
 ?>
@@ -19,8 +19,8 @@ $user = PDO_MYSQL_TEST_USER;
 $pass = PDO_MYSQL_TEST_PASS;
 
 $db = new PDO($dsn, $user, $pass);
-echo var_export($db->getAttribute(PDO::MYSQL_ATTR_LOCAL_INFILE)), "\n";
-echo var_export($db->getAttribute(PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY)), "\n";
+echo var_export($db->getAttribute(Pdo\Mysql::ATTR_LOCAL_INFILE)), "\n";
+echo var_export($db->getAttribute(Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY)), "\n";
 echo "done!\n";
 ?>
 --EXPECT--
diff --git a/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_allowed.phpt b/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_allowed.phpt
index 2b7f4673ddaf3..7c910e2ba80c6 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_allowed.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_allowed.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY vs access allowed
+Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY vs access allowed
 --EXTENSIONS--
 pdo_mysql
 --SKIPIF--
@@ -7,7 +7,7 @@ pdo_mysql
 require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 MySQLPDOTest::skip();
 MySQLPDOTest::skipInfileNotAllowed();
-if (!defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
+if (!defined('Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY')) {
     die("skip No MYSQL_ATTR_LOCAL_INFILE_DIRECTORY support");
 }
 ?>
@@ -33,8 +33,8 @@ if (!defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
 
 	require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 	$db = MySQLPDOTest::factoryWithAttr([
-		PDO::MYSQL_ATTR_LOCAL_INFILE=>false,
-		PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY=>__DIR__."/foo",
+		Pdo\Mysql::ATTR_LOCAL_INFILE=>false,
+		Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY=>__DIR__."/foo",
 	]);
 
 	try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_denied.phpt b/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_denied.phpt
index ccf2abd4a86d9..58bac57748eaa 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_denied.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_denied.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY vs access denied
+Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY vs access denied
 --EXTENSIONS--
 pdo_mysql
 --SKIPIF--
@@ -7,7 +7,7 @@ pdo_mysql
 require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 MySQLPDOTest::skip();
 MySQLPDOTest::skipInfileNotAllowed();
-if (!defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
+if (!defined('Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY')) {
     die("skip No MYSQL_ATTR_LOCAL_INFILE_DIRECTORY support");
 }
 ?>
@@ -33,8 +33,8 @@ if (!defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
 
 	require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 	$db = MySQLPDOTest::factoryWithAttr([
-		PDO::MYSQL_ATTR_LOCAL_INFILE=>false,
-		PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY=>__DIR__."/foo/bar",
+		Pdo\Mysql::ATTR_LOCAL_INFILE=>false,
+		Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY=>__DIR__."/foo/bar",
 	]);
 
 	try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_local_infile_overrides_local_infile_directory.phpt b/ext/pdo_mysql/tests/pdo_mysql_local_infile_overrides_local_infile_directory.phpt
index b99375c37b6ee..d454694ef2c30 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_local_infile_overrides_local_infile_directory.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_local_infile_overrides_local_infile_directory.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO::MYSQL_ATTR_LOCAL_INFILE overrides PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY
+Pdo\Mysql::ATTR_LOCAL_INFILE overrides Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY
 --EXTENSIONS--
 pdo_mysql
 --SKIPIF--
@@ -7,7 +7,7 @@ pdo_mysql
 require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 MySQLPDOTest::skip();
 MySQLPDOTest::skipInfileNotAllowed();
-if (!defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
+if (!defined('Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY')) {
     die("skip No MYSQL_ATTR_LOCAL_INFILE_DIRECTORY support");
 }
 ?>
@@ -33,8 +33,8 @@ if (!defined('PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY')) {
 
 	require_once __DIR__ . '/inc/mysql_pdo_test.inc';
 	$db = MySQLPDOTest::factoryWithAttr([
-		PDO::MYSQL_ATTR_LOCAL_INFILE=>true,
-		PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY=>__DIR__."/foo/bar",
+		Pdo\Mysql::ATTR_LOCAL_INFILE=>true,
+		Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY=>__DIR__."/foo/bar",
 	]);
 
 	try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_local_infile_set_on.phpt b/ext/pdo_mysql/tests/pdo_mysql_local_infile_set_on.phpt
index cbdbc063dd8a1..e5176b44f158b 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_local_infile_set_on.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_local_infile_set_on.phpt
@@ -15,8 +15,8 @@ $dsn = MySQLPDOTest::getDSN();
 $user = PDO_MYSQL_TEST_USER;
 $pass = PDO_MYSQL_TEST_PASS;
 
-$db = new PDO($dsn, $user, $pass, [PDO::MYSQL_ATTR_LOCAL_INFILE => true]);
-echo var_export($db->getAttribute(PDO::MYSQL_ATTR_LOCAL_INFILE)), "\n";
+$db = new PDO($dsn, $user, $pass, [Pdo\Mysql::ATTR_LOCAL_INFILE => true]);
+echo var_export($db->getAttribute(Pdo\Mysql::ATTR_LOCAL_INFILE)), "\n";
 echo "done!\n";
 ?>
 --EXPECT--
diff --git a/ext/pdo_mysql/tests/pdo_mysql_multi_stmt_nextrowset.phpt b/ext/pdo_mysql/tests/pdo_mysql_multi_stmt_nextrowset.phpt
index b699dbdaa5719..75abb0ca39d5f 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_multi_stmt_nextrowset.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_multi_stmt_nextrowset.phpt
@@ -1,5 +1,5 @@
 --TEST--
-MySQL PDOStatement->nextRowSet() with PDO::MYSQL_ATTR_MULTI_STATEMENTS either true or false
+MySQL PDOStatement->nextRowSet() with Pdo\Mysql::ATTR_MULTI_STATEMENTS either true or false
 --EXTENSIONS--
 pdo_mysql
 --SKIPIF--
@@ -35,21 +35,21 @@ MySQLPDOTest::skip();
         printf("Native PS...\n");
         foreach (array(false, true) as $multi) {
             $value = $multi ? 'true' : 'false';
-            echo "\nTesting with PDO::MYSQL_ATTR_MULTI_STATEMENTS set to {$value}\n";
+            echo "\nTesting with Pdo\Mysql::ATTR_MULTI_STATEMENTS set to {$value}\n";
             $dsn = MySQLPDOTest::getDSN();
             $user = PDO_MYSQL_TEST_USER;
             $pass = PDO_MYSQL_TEST_PASS;
-            $db = new PDO($dsn, $user, $pass, array(PDO::MYSQL_ATTR_MULTI_STATEMENTS => $multi));
+            $db = new PDO($dsn, $user, $pass, array(Pdo\Mysql::ATTR_MULTI_STATEMENTS => $multi));
             $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
             $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
-            $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
+            $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 1);
             $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
             test_proc($db);
 
-            $db = new PDO($dsn, $user, $pass, array(PDO::MYSQL_ATTR_MULTI_STATEMENTS => $multi));
+            $db = new PDO($dsn, $user, $pass, array(Pdo\Mysql::ATTR_MULTI_STATEMENTS => $multi));
             $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
             $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
-            $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 0);
+            $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 0);
             $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
 
             test_proc($db);
@@ -81,7 +81,7 @@ $db->exec('DROP PROCEDURE IF EXISTS pdo_mysql_multi_stmt_nextrowset_p');
 --EXPECTF--
 Native PS...
 
-Testing with PDO::MYSQL_ATTR_MULTI_STATEMENTS set to false
+Testing with Pdo\Mysql::ATTR_MULTI_STATEMENTS set to false
 array(3) {
   [0]=>
   array(1) {
@@ -172,7 +172,7 @@ bool(false)
 Warning: PDO::query(): SQLSTATE[42000]: Syntax error or access violation: 1064 You have an error in your SQL syntax; check the manual that corresponds to your %s server version for the right syntax to use near 'INSERT INTO pdo_mysql_multi_stmt_nextrowset (id, label) VALUES (99, 'x')' at line 1 in %s on line %d
 string(5) "42000"
 
-Testing with PDO::MYSQL_ATTR_MULTI_STATEMENTS set to true
+Testing with Pdo\Mysql::ATTR_MULTI_STATEMENTS set to true
 array(3) {
   [0]=>
   array(1) {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated.phpt
index 29074fb5505f5..e8ff3781b350b 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated.phpt
@@ -82,8 +82,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to switch to emulated prepared statements, test will fail\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous.phpt
index f16f9078758ff..f8196bcd61add 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous.phpt
@@ -13,8 +13,8 @@ MySQLPDOTest::skip();
     $db = MySQLPDOTest::factory();
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to switch to emulated prepared statements, test will fail\n");
 
         $db->exec(sprintf('CREATE TABLE test_prepare_emulated_anonymous(id INT, label CHAR(255)) ENGINE=%s', PDO_MYSQL_TEST_ENGINE));
@@ -33,8 +33,8 @@ MySQLPDOTest::skip();
 
         // now the same with native PS
         printf("now the same with native PS\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to switch off emulated prepared statements, test will fail\n");
 
         $db->exec('DELETE FROM test_prepare_emulated_anonymous');
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous_placeholders.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous_placeholders.phpt
index ac4f85949bb17..409d9b1f86c0a 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous_placeholders.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous_placeholders.phpt
@@ -83,8 +83,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to switch to emulated prepared statements, test will fail\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam.phpt
index 8406be4db6d76..fdc82d5ab34bc 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam.phpt
@@ -82,8 +82,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to switch to emulated prepared statements, test will fail\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam_index.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam_index.phpt
index 1acc055e12a0c..a94014a183a55 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam_index.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam_index.phpt
@@ -85,8 +85,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to switch to emulated prepared statements, test will fail\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_placeholder_everywhere.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_placeholder_everywhere.phpt
index 92f14a5b2e9bb..3b356cad3dfc8 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_placeholder_everywhere.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_placeholder_everywhere.phpt
@@ -15,8 +15,8 @@ MySQLPDOTest::skip();
 
     try {
         // native PS
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to switch off emulated prepared statements, test will fail\n");
 
         $db->exec(sprintf('CREATE TABLE test_prepare_emulated_placeholder_everywhere(id INT, label CHAR(255)) ENGINE=%s', PDO_MYSQL_TEST_ENGINE));
@@ -35,8 +35,8 @@ MySQLPDOTest::skip();
 
         // now the same with emulated PS
         printf("now the same with emulated PS\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to switch on emulated prepared statements, test will fail\n");
 
         $stmt = $db->prepare('SELECT ? FROM test_prepare_emulated_placeholder_everywhere WHERE ? > ?');
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native.phpt
index 02690d4164c69..7db84207f19cc 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native.phpt
@@ -91,8 +91,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_anonymous_placeholder.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_anonymous_placeholder.phpt
index db7844b1e6fbf..2ac60de4ae624 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_anonymous_placeholder.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_anonymous_placeholder.phpt
@@ -91,8 +91,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_clear_error.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_clear_error.phpt
index 5d40bc826233f..68cfa4203cfe7 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_clear_error.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_clear_error.phpt
@@ -17,8 +17,8 @@ MySQLPDOTest::skip();
         $db->exec(sprintf('CREATE TABLE test_prepare_native_clear_error(id INT, label CHAR(255)) ENGINE=%s', PDO_MYSQL_TEST_ENGINE));
 
         // We need to run the emulated version first. Native version will cause a fatal error
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         // INSERT a single row
@@ -40,8 +40,8 @@ MySQLPDOTest::skip();
         var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 
         // Native PS
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[005] Unable to turn off emulated prepared statements\n");
 
         $stmt = $db->prepare('SELECT unknown_column FROM test_prepare_native_clear_error WHERE id > :placeholder ORDER BY id ASC');
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_column.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_column.phpt
index 5786b009500aa..ec63d4a4b7501 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_column.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_column.phpt
@@ -15,8 +15,8 @@ MySQLPDOTest::skip();
     $table = 'pdo_mysql_prepare_native_column';
     MySQLPDOTest::createTestTable($table, $db);
 
-    $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-    if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+    $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+    if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
         printf("[002] Unable to turn off emulated prepared statements\n");
 
     $stmt = $db->prepare("SELECT :param FROM {$table} ORDER BY id ASC LIMIT 1");
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_dup_named_placeholder.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_dup_named_placeholder.phpt
index 21bbe8728ed8b..ef38604c449b6 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_dup_named_placeholder.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_dup_named_placeholder.phpt
@@ -16,8 +16,8 @@ MySQLPDOTest::skip();
     try {
         $db->exec(sprintf('CREATE TABLE test_prepare_native_dup_named(id INT, label1 CHAR(255), label2 CHAR(255)) ENGINE=%s', PDO_MYSQL_TEST_ENGINE));
 
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
         printf("Native...\n");
 
@@ -36,8 +36,8 @@ MySQLPDOTest::skip();
         var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 
         // Now the same with emulated PS.
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to turn on emulated prepared statements\n");
         printf("Emulated...\n");
 
@@ -72,8 +72,8 @@ MySQLPDOTest::skip();
         var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 
         // native...
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[007] Unable to turn off emulated prepared statements\n");
         printf("Native...\n");
 
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_mixed_style.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_mixed_style.phpt
index 9e5607fa4cefd..adca8ecfc233d 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_mixed_style.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_mixed_style.phpt
@@ -15,8 +15,8 @@ MySQLPDOTest::skip();
     $table = 'pdo_mysql_prepare_native_mixed_style';
     MySQLPDOTest::createTestTable($table, $db);
 
-    $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-    if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+    $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+    if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
         printf("[002] Unable to turn off emulated prepared statements\n");
 
     $stmt = $db->query("DELETE FROM {$table}");
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam.phpt
index c8ede104016a3..c4a4f7c6f3832 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam.phpt
@@ -91,8 +91,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam_index.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam_index.phpt
index f1547281438ec..e84dd18b957c2 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam_index.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam_index.phpt
@@ -91,8 +91,8 @@ MySQLPDOTest::skip();
     }
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         try {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_named_placeholder.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_named_placeholder.phpt
index 2e23def163345..93bedbe9de74a 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_named_placeholder.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_named_placeholder.phpt
@@ -16,8 +16,8 @@ MySQLPDOTest::skip();
 
         $db->exec(sprintf('CREATE TABLE test_prepare_native_named_placeholder(id INT, label CHAR(255)) ENGINE=%s', PDO_MYSQL_TEST_ENGINE));
 
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         // INSERT a single row
@@ -39,8 +39,8 @@ MySQLPDOTest::skip();
         var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 
         // Now the same with emulated PS.
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to turn on emulated prepared statements\n");
 
         // Note that the "named placeholder" is enclosed by double quotes.
diff --git a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_placeholder_everywhere.phpt b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_placeholder_everywhere.phpt
index 575af4a8f2c8f..4afccdc9e2987 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_prepare_native_placeholder_everywhere.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_prepare_native_placeholder_everywhere.phpt
@@ -14,8 +14,8 @@ MySQLPDOTest::skip();
     $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to switch on emulated prepared statements, test will fail\n");
 
         $db->exec(sprintf('CREATE TABLE test_prepare_native_named_placeholder_everywhere(id INT, label CHAR(255)) ENGINE=%s', PDO_MYSQL_TEST_ENGINE));
@@ -31,8 +31,8 @@ MySQLPDOTest::skip();
 
         // now the same with native PS
         printf("now the same with native PS\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to switch off emulated prepared statements, test_prepare_native_named_placeholder_everywhere will fail\n");
 
         $stmt = $db->prepare('SELECT ?, id, label FROM test_prepare_native_named_placeholder_everywhere WHERE ? = ? ORDER BY id ASC');
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindcolumn.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindcolumn.phpt
index cce3dc9393a37..8f144b611df76 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindcolumn.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindcolumn.phpt
@@ -16,8 +16,8 @@ MySQLPDOTest::skip();
     MySQLPDOTest::createTestTable($table, $db);
 
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         $stmt = $db->prepare("SELECT id, label FROM {$table} ORDER BY id ASC LIMIT 2");
@@ -56,8 +56,8 @@ MySQLPDOTest::skip();
             $index++;
         }
 
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[007] Unable to turn off emulated prepared statements\n");
 
         $stmt = $db->prepare("SELECT id, label FROM {$table} ORDER BY id ASC LIMIT 2, 2");
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam.phpt
index b0bbad59d8e92..92e6f446e1b36 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam.phpt
@@ -84,32 +84,32 @@ MySQLPDOTest::skip();
 
     try {
         printf("Emulated PS...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         printf("Buffered...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
         pdo_mysql_stmt_bindparam($db, 3);
 
         printf("Unbuffered...\n");
         MySQLPDOTest::createTestTable($table, $db);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
         pdo_mysql_stmt_bindparam($db, 4);
 
         printf("Native PS...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to turn off emulated prepared statements\n");
 
         printf("Buffered...\n");
         MySQLPDOTest::createTestTable($table, $db);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
         pdo_mysql_stmt_bindparam($db, 5);
 
         printf("Unbuffered...\n");
         MySQLPDOTest::createTestTable($table, $db);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
         pdo_mysql_stmt_bindparam($db, 6);
 
     } catch (PDOException $e) {
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam_types.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam_types.phpt
index b315c97b91203..fde08dfa6932a 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam_types.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam_types.phpt
@@ -14,9 +14,9 @@ MySQLPDOTest::skip();
 
     function pdo_mysql_stmt_bindparam_types_do($db, $offset, $native, $sql_type, $value) {
             if ($native)
-                $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
+                $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
             else
-                $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
+                $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
 
             $sql = sprintf('CREATE TABLE test_stmt_bindparam_types(id INT, label %s) ENGINE=%s', $sql_type, MySQLPDOTest::getTableEngine());
             if ((!$stmt = $db->prepare($sql)) || (!$stmt->execute()))
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindvalue.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindvalue.phpt
index c558eb6f81dad..7d214e0c7e239 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_bindvalue.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_bindvalue.phpt
@@ -17,8 +17,8 @@ MySQLPDOTest::skip();
 
     printf("Testing native PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         printf("Binding variable...\n");
@@ -157,8 +157,8 @@ MySQLPDOTest::skip();
 
     printf("Testing emulated PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         printf("Binding variable...\n");
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor.phpt
index af052a02423ff..65dfbb660bc3a 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor.phpt
@@ -21,7 +21,7 @@ MySQLPDOTest::skip();
         // This one should fail. I let it fail to prove that closeCursor() makes a difference.
         // If no error messages gets printed do not know if proper usage of closeCursor() makes any
         // difference or not. That's why we need to cause an error here.
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
         $stmt1 = $db->query("SELECT id, label FROM {$table} ORDER BY id ASC");
         // query() shall fail!
         $stmt2 = $db->query("SELECT id, label FROM {$table} ORDER BY id ASC");
@@ -46,7 +46,7 @@ MySQLPDOTest::skip();
         $stmt2->execute();
         $stmt2->closeCursor();
 
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
         // check if changing the fetch mode from unbuffered to buffered will
         // cause any harm to a statement created prior to the change
         $stmt1->execute();
@@ -110,33 +110,33 @@ MySQLPDOTest::skip();
 
     try {
         printf("Testing emulated PS...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         printf("Buffered...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
         MySQLPDOTest::createTestTable($table, $db);
         pdo_mysql_stmt_closecursor($db);
 
         printf("Unbuffered...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
         MySQLPDOTest::createTestTable($table, $db);
         pdo_mysql_stmt_closecursor($db);
 
         printf("Testing native PS...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         printf("Buffered...\n");
         MySQLPDOTest::createTestTable($table, $db);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
         pdo_mysql_stmt_closecursor($db);
 
         printf("Unbuffered...\n");
         MySQLPDOTest::createTestTable($table, $db);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
         pdo_mysql_stmt_closecursor($db);
 
     } catch (PDOException $e) {
@@ -156,23 +156,23 @@ $db->exec('DROP TABLE IF EXISTS pdo_mysql_stmt_closecursor');
 Testing emulated PS...
 Buffered...
 
-Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
+Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
 in = 0 -> id = 1 (integer) / label = 'a' (string)
 in = 0 -> id = 2 (integer) / label = 'b' (string)
 Unbuffered...
 
-Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
+Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
 in = 0 -> id = 1 (integer) / label = 'a' (string)
 in = 0 -> id = 2 (integer) / label = 'b' (string)
 Testing native PS...
 Buffered...
 
-Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
+Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
 in = 0 -> id = 1 (integer) / label = 'a' (string)
 in = 0 -> id = 2 (integer) / label = 'b' (string)
 Unbuffered...
 
-Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
+Warning: PDO::query(): SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active.  Consider using PDOStatement::fetchAll().  Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the Pdo\Mysql::ATTR_USE_BUFFERED_QUERY attribute. in %s on line %d
 in = 0 -> id = 1 (integer) / label = 'a' (string)
 in = 0 -> id = 2 (integer) / label = 'b' (string)
 done!
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor_empty.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor_empty.phpt
index 33127f4ee242f..b0880f3548985 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor_empty.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor_empty.phpt
@@ -16,11 +16,11 @@ MySQLPDOTest::skip();
 
     try {
 
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
         MySQLPDOTest::createTestTable($table, $db);
 
         $stmt = $db->prepare("SELECT id, label FROM {$table} WHERE id > ? ORDER BY id ASC LIMIT 2");
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_columncount.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_columncount.phpt
index b55725057e234..81d2bd6386e3a 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_columncount.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_columncount.phpt
@@ -20,8 +20,8 @@ MySQLPDOTest::skip();
     // Internal data structures should be the same in both cases.
     printf("Testing emulated PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         $stmt = $db->prepare("SELECT id, label, '?' as foo FROM {$table}");
@@ -38,8 +38,8 @@ MySQLPDOTest::skip();
 
     printf("Testing native PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to turn off emulated prepared statements\n");
 
         $stmt = $db->prepare("SELECT id, label, '?' as foo, 'TODO - Stored Procedure' as bar FROM {$table}");
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_errorcode.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_errorcode.phpt
index de4cb8b97bfb6..8602fa7b36008 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_errorcode.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_errorcode.phpt
@@ -16,8 +16,8 @@ MySQLPDOTest::skip();
 
     printf("Testing emulated PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         $stmt = $db->prepare('SELECT id FROM pdo_mysql_stmt_errorcode_ihopeitdoesnotexist ORDER BY id ASC');
@@ -32,8 +32,8 @@ MySQLPDOTest::skip();
 
     printf("Testing native PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to turn off emulated prepared statements\n");
 
         $stmt = $db->prepare('SELECT id FROM pdo_mysql_stmt_errorcode_ihopeitdoesnotexist ORDER BY id ASC');
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_errorinfo.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_errorinfo.phpt
index 6b2a9281d9c21..04fb7d802e62b 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_errorinfo.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_errorinfo.phpt
@@ -17,8 +17,8 @@ MySQLPDOTest::skip();
 
     printf("Testing emulated PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         $stmt = $db->prepare('SELECT id FROM pdo_mysql_stmt_errorinfo_ihopeitdoesnotexist ORDER BY id ASC');
@@ -40,8 +40,8 @@ MySQLPDOTest::skip();
 
     printf("Testing native PS...\n");
     try {
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to turn off emulated prepared statements\n");
 
         $stmt = $db->prepare('SELECT id FROM pdo_mysql_stmt_errorinfo_ihopeitdoesnotexist ORDER BY id ASC');
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_class.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_class.phpt
index 4d5db44ea91b4..20259b8d49299 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_class.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_class.phpt
@@ -75,8 +75,8 @@ MySQLPDOTest::skip();
 
         }
 
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         $db->exec(sprintf('CREATE TABLE test_stmt_fetch_class(id INT, myobj BLOB) ENGINE=%s',
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_non_select.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_non_select.phpt
index 0027d1ea52ff9..421276c570d7f 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_non_select.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_non_select.phpt
@@ -18,8 +18,8 @@ MySQLPDOTest::skip();
     try {
 
         // Emulated PS first
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 1);
-        if (1 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 1);
+        if (1 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn on emulated prepared statements\n");
 
         if (!is_object($stmt = $db->query("DESCRIBE {$table} id")))
@@ -68,8 +68,8 @@ MySQLPDOTest::skip();
             printf("[010] Emulated PS, EXPLAIN returned no results\n");
 
         // And now native PS
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[011] Unable to turn off emulated prepared statements\n");
 
         $native_support = 'no';
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize.phpt
index 8aaf65f52d9ea..fd2b6cb5e4a77 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize.phpt
@@ -75,8 +75,8 @@ MySQLPDOTest::skip();
 
         }
 
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         $db->exec(sprintf('CREATE TABLE test_stmt_fetch_serialize(id INT, myobj BLOB) ENGINE=%s',
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize_fetch_class.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize_fetch_class.phpt
index f2f6c89ad3897..1d3c7f69fab96 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize_fetch_class.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize_fetch_class.phpt
@@ -75,8 +75,8 @@ MySQLPDOTest::skip();
 
         }
 
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[002] Unable to turn off emulated prepared statements\n");
 
         $db->exec(sprintf('CREATE TABLE test_stmt_fetchserialize_fetch_class(id INT, myobj BLOB) ENGINE=%s',
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_getcolumnmeta.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_getcolumnmeta.phpt
index 0552a87aa42d9..9b09491e0cbf7 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_getcolumnmeta.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_getcolumnmeta.phpt
@@ -37,8 +37,8 @@ try {
     $emulated =  $stmt->getColumnMeta(0);
 
     printf("Testing native PS...\n");
-    $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+    $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[007] Unable to turn off emulated prepared statements\n");
 
     $stmt = $db->prepare('SELECT id FROM test_stmt_getcolumnmeta ORDER BY id ASC');
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_nextrowset.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_nextrowset.phpt
index df2d3b402d83d..0415a04fdab6f 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_nextrowset.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_nextrowset.phpt
@@ -63,14 +63,14 @@ MySQLPDOTest::skipNotMySQLnd();
         printf("Emulated PS...\n");
         $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 1);
 
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 1);
         test_proc1($db);
         test_proc2($db);
 
         $db = MySQLPDOTest::factory();
         $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
         $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 1);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 0);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 0);
         test_proc1($db);
         test_proc2($db);
 
@@ -78,14 +78,14 @@ MySQLPDOTest::skipNotMySQLnd();
         printf("Native PS...\n");
         $db = MySQLPDOTest::factory();
         $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 1);
         $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
         test_proc1($db);
         test_proc2($db);
 
         $db = MySQLPDOTest::factory();
         $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 0);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 0);
         $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
 
         test_proc1($db);
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_unbuffered_2050.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_unbuffered_2050.phpt
index aca3e6a084cbd..fcba9e44e694c 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_unbuffered_2050.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_unbuffered_2050.phpt
@@ -18,13 +18,13 @@ if (MYSQLPDOTest::isPDOMySQLnd())
 
     try {
         printf("Native PS...\n");
-        $db->setAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY, 0);
-        if (0 != $db->getAttribute(PDO::MYSQL_ATTR_DIRECT_QUERY))
+        $db->setAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY, 0);
+        if (0 != $db->getAttribute(Pdo\Mysql::ATTR_DIRECT_QUERY))
             printf("[004] Unable to turn off emulated prepared statements\n");
 
         printf("Buffered...\n");
         MySQLPDOTest::createTestTable($table, $db);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, true);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, true);
         $stmt = $db->query("SELECT id, label FROM {$table} WHERE id = 1");
         var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
         $stmt = $db->query("SELECT id, label FROM {$table} WHERE id = 1");
@@ -32,7 +32,7 @@ if (MYSQLPDOTest::isPDOMySQLnd())
 
         printf("Unbuffered...\n");
         MySQLPDOTest::createTestTable($table, $db);
-        $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
+        $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
         $stmt = $db->query("SELECT id, label FROM {$table} WHERE id = 1");
         var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
         /*
diff --git a/ext/pdo_mysql/tests/pdo_mysql_stmt_variable_columncount.phpt b/ext/pdo_mysql/tests/pdo_mysql_stmt_variable_columncount.phpt
index fb35381769744..48353f4cbdb3c 100644
--- a/ext/pdo_mysql/tests/pdo_mysql_stmt_variable_columncount.phpt
+++ b/ext/pdo_mysql/tests/pdo_mysql_stmt_variable_columncount.phpt
@@ -57,7 +57,7 @@ MySQLPDOTest::skip();
             // Libmysql cannot handle such a stored procedure. You will see leaks with libmysql
             $db = MySQLPDOTest::factory();
             $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
-            $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
+            $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 1);
             $stmt = $db->prepare("CALL {$procedure}(?)");
             $stmt->bindParam(1, $columns);
             for ($i = 5; $i < 10; $i++) {
@@ -88,7 +88,7 @@ MySQLPDOTest::skip();
             // Libmysql cannot handle such a stored procedure. You will see leaks with libmysql
             $db = MySQLPDOTest::factory();
             $db->setAttribute(PDO::ATTR_EMULATE_PREPARES, 0);
-            $db->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, 1);
+            $db->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, 1);
             $db->exec('SET @numcols = 1');
             $stmt = $db->prepare("CALL {$procedure}()");
             $stmt->execute();
diff --git a/ext/pdo_mysql/tests/php_8.5_deprecations.phpt b/ext/pdo_mysql/tests/php_8.5_deprecations.phpt
new file mode 100644
index 0000000000000..4d163c2f48cdc
--- /dev/null
+++ b/ext/pdo_mysql/tests/php_8.5_deprecations.phpt
@@ -0,0 +1,81 @@
+--TEST--
+PDO_mysql: PHP 8.5 deprecations
+--EXTENSIONS--
+pdo_mysql
+--SKIPIF--
+<?php
+if (!defined('Pdo\\Mysql::ATTR_SSL_VERIFY_SERVER_CERT')) {
+    die('skip requires mysqlnd');
+}
+?>
+--FILE--
+<?php
+
+var_dump(
+     PDO::MYSQL_ATTR_USE_BUFFERED_QUERY,
+     PDO::MYSQL_ATTR_LOCAL_INFILE,
+     PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY,
+     PDO::MYSQL_ATTR_INIT_COMMAND,
+     PDO::MYSQL_ATTR_COMPRESS,
+     PDO::MYSQL_ATTR_DIRECT_QUERY,
+     PDO::MYSQL_ATTR_FOUND_ROWS,
+     PDO::MYSQL_ATTR_IGNORE_SPACE,
+     PDO::MYSQL_ATTR_SSL_KEY,
+     PDO::MYSQL_ATTR_SSL_CERT,
+     PDO::MYSQL_ATTR_SSL_CA,
+     PDO::MYSQL_ATTR_SSL_CAPATH,
+     PDO::MYSQL_ATTR_SSL_CIPHER,
+     PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT,
+     PDO::MYSQL_ATTR_SERVER_PUBLIC_KEY,
+     PDO::MYSQL_ATTR_MULTI_STATEMENTS,
+);
+
+?>
+--EXPECTF--
+Deprecated: Constant PDO::MYSQL_ATTR_USE_BUFFERED_QUERY is deprecated since 8.5, use Pdo\Mysql::ATTR_USE_BUFFERED_QUERY instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_LOCAL_INFILE is deprecated since 8.5, use Pdo\Mysql::ATTR_LOCAL_INFILE instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_LOCAL_INFILE_DIRECTORY is deprecated since 8.5, use Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_INIT_COMMAND is deprecated since 8.5, use Pdo\Mysql::ATTR_INIT_COMMAND instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_COMPRESS is deprecated since 8.5, use Pdo\Mysql::ATTR_COMPRESS instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_DIRECT_QUERY is deprecated since 8.5, use Pdo\Mysql::ATTR_DIRECT_QUERY instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_FOUND_ROWS is deprecated since 8.5, use Pdo\Mysql::ATTR_FOUND_ROWS instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_IGNORE_SPACE is deprecated since 8.5, use Pdo\Mysql::ATTR_IGNORE_SPACE instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_SSL_KEY is deprecated since 8.5, use Pdo\Mysql::ATTR_SSL_KEY instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_SSL_CERT is deprecated since 8.5, use Pdo\Mysql::ATTR_SSL_CERT instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_SSL_CA is deprecated since 8.5, use Pdo\Mysql::ATTR_SSL_CA instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_SSL_CAPATH is deprecated since 8.5, use Pdo\Mysql::ATTR_SSL_CAPATH instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_SSL_CIPHER is deprecated since 8.5, use Pdo\Mysql::ATTR_SSL_CIPHER instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT is deprecated since 8.5, use Pdo\Mysql::ATTR_SSL_VERIFY_SERVER_CERT instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_SERVER_PUBLIC_KEY is deprecated since 8.5, use Pdo\Mysql::ATTR_SERVER_PUBLIC_KEY instead in %s on line %d
+
+Deprecated: Constant PDO::MYSQL_ATTR_MULTI_STATEMENTS is deprecated since 8.5, use Pdo\Mysql::ATTR_MULTI_STATEMENTS instead in %s on line %d
+int(1000)
+int(1001)
+int(1014)
+int(1002)
+int(1003)
+int(20)
+int(1004)
+int(1005)
+int(1006)
+int(1007)
+int(1008)
+int(1009)
+int(1010)
+int(1013)
+int(1011)
+int(1012)
diff --git a/ext/pdo_odbc/pdo_odbc.c b/ext/pdo_odbc/pdo_odbc.c
index 1052322fe8cfe..1181e314c4d0d 100644
--- a/ext/pdo_odbc/pdo_odbc.c
+++ b/ext/pdo_odbc/pdo_odbc.c
@@ -61,6 +61,9 @@ zend_ulong pdo_odbc_pool_on = SQL_CP_OFF;
 zend_ulong pdo_odbc_pool_mode = SQL_CP_ONE_PER_HENV;
 #endif
 
+#define REGISTER_PDO_ODBC_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, value) \
+		REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, "ODBC_", "Pdo\\Odbc::", value)
+
 /* {{{ PHP_MINIT_FUNCTION */
 PHP_MINIT_FUNCTION(pdo_odbc)
 {
@@ -101,11 +104,11 @@ PHP_MINIT_FUNCTION(pdo_odbc)
 
 	register_pdo_odbc_symbols(module_number);
 
-	REGISTER_PDO_CLASS_CONST_LONG("ODBC_ATTR_USE_CURSOR_LIBRARY", PDO_ODBC_ATTR_USE_CURSOR_LIBRARY);
-	REGISTER_PDO_CLASS_CONST_LONG("ODBC_ATTR_ASSUME_UTF8", PDO_ODBC_ATTR_ASSUME_UTF8);
-	REGISTER_PDO_CLASS_CONST_LONG("ODBC_SQL_USE_IF_NEEDED", SQL_CUR_USE_IF_NEEDED);
-	REGISTER_PDO_CLASS_CONST_LONG("ODBC_SQL_USE_DRIVER", SQL_CUR_USE_DRIVER);
-	REGISTER_PDO_CLASS_CONST_LONG("ODBC_SQL_USE_ODBC", SQL_CUR_USE_ODBC);
+	REGISTER_PDO_ODBC_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_USE_CURSOR_LIBRARY", PDO_ODBC_ATTR_USE_CURSOR_LIBRARY);
+	REGISTER_PDO_ODBC_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_ASSUME_UTF8", PDO_ODBC_ATTR_ASSUME_UTF8);
+	REGISTER_PDO_ODBC_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("SQL_USE_IF_NEEDED", SQL_CUR_USE_IF_NEEDED);
+	REGISTER_PDO_ODBC_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("SQL_USE_DRIVER", SQL_CUR_USE_DRIVER);
+	REGISTER_PDO_ODBC_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("SQL_USE_ODBC", SQL_CUR_USE_ODBC);
 
 	pdo_odbc_ce = register_class_Pdo_Odbc(pdo_dbh_ce);
 	pdo_odbc_ce->create_object = pdo_dbh_new;
diff --git a/ext/pdo_odbc/tests/bug80783a.phpt b/ext/pdo_odbc/tests/bug80783a.phpt
index ab141588e1b4e..d8987cfd0ac3e 100644
--- a/ext/pdo_odbc/tests/bug80783a.phpt
+++ b/ext/pdo_odbc/tests/bug80783a.phpt
@@ -22,7 +22,7 @@ $string = str_repeat("0123456789", 50);
 $db->exec("INSERT INTO bug80783a VALUES('$string')");
 
 $stmt = $db->prepare("SELECT name FROM bug80783a");
-$stmt->setAttribute(PDO::ODBC_ATTR_ASSUME_UTF8, true);
+$stmt->setAttribute(Pdo\Odbc::ATTR_ASSUME_UTF8, true);
 $stmt->bindColumn(1, $data, PDO::PARAM_STR);
 $stmt->execute();
 $stmt->fetch(PDO::FETCH_BOUND);
diff --git a/ext/pdo_odbc/tests/php_8.5_deprecations.phpt b/ext/pdo_odbc/tests/php_8.5_deprecations.phpt
new file mode 100644
index 0000000000000..54be2339f6cf2
--- /dev/null
+++ b/ext/pdo_odbc/tests/php_8.5_deprecations.phpt
@@ -0,0 +1,31 @@
+--TEST--
+PDO_odbc: PHP 8.5 deprecations
+--EXTENSIONS--
+pdo_odbc
+--FILE--
+<?php
+
+var_dump(
+    PDO::ODBC_ATTR_USE_CURSOR_LIBRARY,
+    PDO::ODBC_ATTR_ASSUME_UTF8,
+    PDO::ODBC_SQL_USE_IF_NEEDED,
+    PDO::ODBC_SQL_USE_DRIVER,
+    PDO::ODBC_SQL_USE_ODBC,
+);
+
+?>
+--EXPECTF--
+Deprecated: Constant PDO::ODBC_ATTR_USE_CURSOR_LIBRARY is deprecated since 8.5, use Pdo\Odbc::ATTR_USE_CURSOR_LIBRARY instead in %s on line %d
+
+Deprecated: Constant PDO::ODBC_ATTR_ASSUME_UTF8 is deprecated since 8.5, use Pdo\Odbc::ATTR_ASSUME_UTF8 instead in %s on line %d
+
+Deprecated: Constant PDO::ODBC_SQL_USE_IF_NEEDED is deprecated since 8.5, use Pdo\Odbc::SQL_USE_IF_NEEDED instead in %s on line %d
+
+Deprecated: Constant PDO::ODBC_SQL_USE_DRIVER is deprecated since 8.5, use Pdo\Odbc::SQL_USE_DRIVER instead in %s on line %d
+
+Deprecated: Constant PDO::ODBC_SQL_USE_ODBC is deprecated since 8.5, use Pdo\Odbc::SQL_USE_ODBC instead in %s on line %d
+int(1000)
+int(1001)
+int(0)
+int(2)
+int(1)
diff --git a/ext/pdo_pgsql/pdo_pgsql.c b/ext/pdo_pgsql/pdo_pgsql.c
index 49efa0b238484..e6849aed1195e 100644
--- a/ext/pdo_pgsql/pdo_pgsql.c
+++ b/ext/pdo_pgsql/pdo_pgsql.c
@@ -175,15 +175,18 @@ PHP_METHOD(Pdo_Pgsql, setNoticeCallback)
 
 /* true global environment */
 
+#define REGISTER_PDO_PGSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, value) \
+		REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, "PGSQL_", "Pdo\\Pgsql::", value)
+
 /* {{{ PHP_MINIT_FUNCTION */
 PHP_MINIT_FUNCTION(pdo_pgsql)
 {
-	REGISTER_PDO_CLASS_CONST_LONG("PGSQL_ATTR_DISABLE_PREPARES", PDO_PGSQL_ATTR_DISABLE_PREPARES);
-	REGISTER_PDO_CLASS_CONST_LONG("PGSQL_TRANSACTION_IDLE", (zend_long)PGSQL_TRANSACTION_IDLE);
-	REGISTER_PDO_CLASS_CONST_LONG("PGSQL_TRANSACTION_ACTIVE", (zend_long)PGSQL_TRANSACTION_ACTIVE);
-	REGISTER_PDO_CLASS_CONST_LONG("PGSQL_TRANSACTION_INTRANS", (zend_long)PGSQL_TRANSACTION_INTRANS);
-	REGISTER_PDO_CLASS_CONST_LONG("PGSQL_TRANSACTION_INERROR", (zend_long)PGSQL_TRANSACTION_INERROR);
-	REGISTER_PDO_CLASS_CONST_LONG("PGSQL_TRANSACTION_UNKNOWN", (zend_long)PGSQL_TRANSACTION_UNKNOWN);
+	REGISTER_PDO_PGSQL_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_DISABLE_PREPARES", PDO_PGSQL_ATTR_DISABLE_PREPARES);
+	REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_85("PGSQL_TRANSACTION_IDLE", (zend_long)PGSQL_TRANSACTION_IDLE);
+	REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_85("PGSQL_TRANSACTION_ACTIVE", (zend_long)PGSQL_TRANSACTION_ACTIVE);
+	REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_85("PGSQL_TRANSACTION_INTRANS", (zend_long)PGSQL_TRANSACTION_INTRANS);
+	REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_85("PGSQL_TRANSACTION_INERROR", (zend_long)PGSQL_TRANSACTION_INERROR);
+	REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_85("PGSQL_TRANSACTION_UNKNOWN", (zend_long)PGSQL_TRANSACTION_UNKNOWN);
 
 	PdoPgsql_ce = register_class_Pdo_Pgsql(pdo_dbh_ce);
 	PdoPgsql_ce->create_object = pdo_dbh_new;
diff --git a/ext/pdo_pgsql/tests/bug68371.phpt b/ext/pdo_pgsql/tests/bug68371.phpt
index 6569abf3071fd..13fd1913274d5 100644
--- a/ext/pdo_pgsql/tests/bug68371.phpt
+++ b/ext/pdo_pgsql/tests/bug68371.phpt
@@ -18,7 +18,7 @@ $pdo->setAttribute (\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
 $attrs = array(
     // Extensive test: default value and set+get values
     PDO::ATTR_EMULATE_PREPARES			=> array(null, true, false),
-    PDO::PGSQL_ATTR_DISABLE_PREPARES	=> array(null, true, false),
+    Pdo\Pgsql::ATTR_DISABLE_PREPARES	=> array(null, true, false),
 
     // Just test the default
     PDO::ATTR_AUTOCOMMIT			=> array(null),
diff --git a/ext/pdo_pgsql/tests/bug73959.phpt b/ext/pdo_pgsql/tests/bug73959.phpt
index 34b68f9825c73..918743ff4383e 100644
--- a/ext/pdo_pgsql/tests/bug73959.phpt
+++ b/ext/pdo_pgsql/tests/bug73959.phpt
@@ -15,7 +15,7 @@ require __DIR__ . '/config.inc';
 $db = PDOTest::test_factory(__DIR__ . '/common.phpt');
 $db->setAttribute(PDO::ATTR_PERSISTENT, false);
 $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
-$db->setAttribute(PDO::PGSQL_ATTR_DISABLE_PREPARES, true);
+$db->setAttribute(Pdo\Pgsql::ATTR_DISABLE_PREPARES, true);
 
 try {
     $db->lastInsertId('nonexistent_seq');
diff --git a/ext/pdo_pgsql/tests/disable_prepares.phpt b/ext/pdo_pgsql/tests/disable_prepares.phpt
index 58f3a4b00c1fb..b184e9bc6db68 100644
--- a/ext/pdo_pgsql/tests/disable_prepares.phpt
+++ b/ext/pdo_pgsql/tests/disable_prepares.phpt
@@ -28,7 +28,7 @@ $stmt->execute();
 $first = $stmt->fetchAll();
 
 $stmt3 = $db->prepare("SELECT (?)::int4", array(
-    PDO::PGSQL_ATTR_DISABLE_PREPARES => true));
+    Pdo\Pgsql::ATTR_DISABLE_PREPARES => true));
 $stmt3->execute(array(3));
 var_dump($stmt3->fetch());
 $stmt3->execute(array(4));
diff --git a/ext/pdo_pgsql/tests/gh15287.phpt b/ext/pdo_pgsql/tests/gh15287.phpt
index 72bcc44b363b4..821c22a8f1c5a 100644
--- a/ext/pdo_pgsql/tests/gh15287.phpt
+++ b/ext/pdo_pgsql/tests/gh15287.phpt
@@ -75,8 +75,8 @@ for ($i = -1; ++$i < 5;) {
 	while (($re = $stmt->fetch())) {
 		$res[] = $re;
 		// Memory introspection relies on an optionally-compiled constant.
-		if (defined('PDO::PGSQL_ATTR_RESULT_MEMORY_SIZE')) {
-			$mem = $stmt->getAttribute(PDO::PGSQL_ATTR_RESULT_MEMORY_SIZE);
+		if (defined('Pdo\Pgsql::ATTR_RESULT_MEMORY_SIZE')) {
+			$mem = $stmt->getAttribute(Pdo\Pgsql::ATTR_RESULT_MEMORY_SIZE);
 		} else {
 			// If not there emulate a return value which validates our test.
 			$mem = $lazy ? 0 : 1;
diff --git a/ext/pdo_pgsql/tests/is_in_transaction.phpt b/ext/pdo_pgsql/tests/is_in_transaction.phpt
index 440044f66a578..982357db9210a 100644
--- a/ext/pdo_pgsql/tests/is_in_transaction.phpt
+++ b/ext/pdo_pgsql/tests/is_in_transaction.phpt
@@ -19,7 +19,7 @@ $db->exec('CREATE TABLE test_is_in_transaction (a integer not null primary key,
 
 $db->beginTransaction();
 try {
-echo "Test PDO::PGSQL_TRANSACTION_INTRANS\n";
+echo "Test Pdo\Pgsql::TRANSACTION_INTRANS\n";
 var_dump($db->inTransaction());
 
 $stmt = $db->prepare("INSERT INTO test_is_in_transaction (a, b) values (?, ?)");
@@ -29,7 +29,7 @@ $stmt->execute();
 
 $db->commit();
 
-echo "Test PDO::PGSQL_TRANSACTION_IDLE\n";
+echo "Test Pdo\Pgsql::TRANSACTION_IDLE\n";
 var_dump($db->inTransaction());
 
 $db->beginTransaction();
@@ -40,13 +40,13 @@ $stmt->bindValue(1, "error");
 $stmt->bindValue(2, "test insert");
 $stmt->execute();
 } catch (Exception $e) {
-    /* We catch the exception because the execute will give error and we must test the PDO::PGSQL_TRANSACTION_ERROR */
-    echo "Test PDO::PGSQL_TRANSACTION_INERROR\n";
+    /* We catch the exception because the execute will give error and we must test the Pdo\Pgsql::TRANSACTION_ERROR */
+    echo "Test Pdo\Pgsql::TRANSACTION_INERROR\n";
     var_dump($db->inTransaction());
     $db->rollBack();
 }
 
-echo "Test PDO::PGSQL_TRANSACTION_IDLE\n";
+echo "Test Pdo\Pgsql::TRANSACTION_IDLE\n";
 var_dump($db->inTransaction());
 
 } catch (Exception $e) {
@@ -62,11 +62,11 @@ $db = PDOTest::test_factory(__DIR__ . '/common.phpt');
 $db->exec('DROP TABLE test_is_in_transaction');
 ?>
 --EXPECT--
-Test PDO::PGSQL_TRANSACTION_INTRANS
+Test Pdo\Pgsql::TRANSACTION_INTRANS
 bool(true)
-Test PDO::PGSQL_TRANSACTION_IDLE
+Test Pdo\Pgsql::TRANSACTION_IDLE
 bool(false)
-Test PDO::PGSQL_TRANSACTION_INERROR
+Test Pdo\Pgsql::TRANSACTION_INERROR
 bool(true)
-Test PDO::PGSQL_TRANSACTION_IDLE
+Test Pdo\Pgsql::TRANSACTION_IDLE
 bool(false)
diff --git a/ext/pdo_pgsql/tests/php_8.5_deprecations.phpt b/ext/pdo_pgsql/tests/php_8.5_deprecations.phpt
new file mode 100644
index 0000000000000..816850853e144
--- /dev/null
+++ b/ext/pdo_pgsql/tests/php_8.5_deprecations.phpt
@@ -0,0 +1,15 @@
+--TEST--
+PDO_pgsql: PHP 8.5 deprecations
+--EXTENSIONS--
+pdo_pgsql
+--FILE--
+<?php
+
+var_dump(
+    PDO::PGSQL_ATTR_DISABLE_PREPARES,
+);
+
+?>
+--EXPECTF--
+Deprecated: Constant PDO::PGSQL_ATTR_DISABLE_PREPARES is deprecated since 8.5, use Pdo\Pgsql::ATTR_DISABLE_PREPARES instead in %s on line %d
+int(1000)
diff --git a/ext/pdo_sqlite/pdo_sqlite.c b/ext/pdo_sqlite/pdo_sqlite.c
index 023e35a2bc33c..667948fea9f1f 100644
--- a/ext/pdo_sqlite/pdo_sqlite.c
+++ b/ext/pdo_sqlite/pdo_sqlite.c
@@ -404,19 +404,22 @@ PHP_METHOD(Pdo_Sqlite, createCollation)
 	pdo_sqlite_create_collation_internal(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_sqlite_collation_callback);
 }
 
+#define REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, value) \
+		REGISTER_PDO_CLASS_CONST_LONG_DEPRECATED_ALIAS_85(base_name, "SQLITE_", "Pdo\\Sqlite::", value)
+
 /* {{{ PHP_MINIT_FUNCTION */
 PHP_MINIT_FUNCTION(pdo_sqlite)
 {
 #ifdef SQLITE_DETERMINISTIC
-	REGISTER_PDO_CLASS_CONST_LONG("SQLITE_DETERMINISTIC", (zend_long)SQLITE_DETERMINISTIC);
+	REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("DETERMINISTIC", (zend_long)SQLITE_DETERMINISTIC);
 #endif
 
-	REGISTER_PDO_CLASS_CONST_LONG("SQLITE_ATTR_OPEN_FLAGS", (zend_long)PDO_SQLITE_ATTR_OPEN_FLAGS);
-	REGISTER_PDO_CLASS_CONST_LONG("SQLITE_OPEN_READONLY", (zend_long)SQLITE_OPEN_READONLY);
-	REGISTER_PDO_CLASS_CONST_LONG("SQLITE_OPEN_READWRITE", (zend_long)SQLITE_OPEN_READWRITE);
-	REGISTER_PDO_CLASS_CONST_LONG("SQLITE_OPEN_CREATE", (zend_long)SQLITE_OPEN_CREATE);
-	REGISTER_PDO_CLASS_CONST_LONG("SQLITE_ATTR_READONLY_STATEMENT", (zend_long)PDO_SQLITE_ATTR_READONLY_STATEMENT);
-	REGISTER_PDO_CLASS_CONST_LONG("SQLITE_ATTR_EXTENDED_RESULT_CODES", (zend_long)PDO_SQLITE_ATTR_EXTENDED_RESULT_CODES);
+	REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_OPEN_FLAGS", (zend_long)PDO_SQLITE_ATTR_OPEN_FLAGS);
+	REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("OPEN_READONLY", (zend_long)SQLITE_OPEN_READONLY);
+	REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("OPEN_READWRITE", (zend_long)SQLITE_OPEN_READWRITE);
+	REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("OPEN_CREATE", (zend_long)SQLITE_OPEN_CREATE);
+	REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_READONLY_STATEMENT", (zend_long)PDO_SQLITE_ATTR_READONLY_STATEMENT);
+	REGISTER_PDO_SQLITE_CLASS_CONST_LONG_DEPRECATED_ALIAS_85("ATTR_EXTENDED_RESULT_CODES", (zend_long)PDO_SQLITE_ATTR_EXTENDED_RESULT_CODES);
 
 	pdosqlite_ce = register_class_Pdo_Sqlite(pdo_dbh_ce);
 	pdosqlite_ce->create_object = pdo_dbh_new;
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_createfunction_with_flags.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_createfunction_with_flags.phpt
index f9312bcee69e9..d1d31d6cad632 100644
--- a/ext/pdo_sqlite/tests/pdo_sqlite_createfunction_with_flags.phpt
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_createfunction_with_flags.phpt
@@ -4,7 +4,7 @@ PDO_sqlite: Testing sqliteCreateFunction() with flags
 pdo_sqlite
 --SKIPIF--
 <?php
-if (!defined('PDO::SQLITE_DETERMINISTIC')) die('skip system sqlite is too old');
+if (!defined('Pdo\Sqlite::DETERMINISTIC')) die('skip system sqlite is too old');
 ?>
 --FILE--
 <?php
@@ -16,7 +16,7 @@ $db->query('CREATE TABLE test_pdo_sqlite_createfunction_with_flags (id INT AUTO
 $db->query('INSERT INTO test_pdo_sqlite_createfunction_with_flags VALUES (NULL, "PHP"), (NULL, "PHP6")');
 
 
-$db->sqliteCreateFunction('testing', function($v) { return strtolower($v); }, 1, PDO::SQLITE_DETERMINISTIC);
+$db->sqliteCreateFunction('testing', function($v) { return strtolower($v); }, 1, Pdo\Sqlite::DETERMINISTIC);
 
 
 foreach ($db->query('SELECT testing(name) FROM test_pdo_sqlite_createfunction_with_flags') as $row) {
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_extendederror_attr.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_extendederror_attr.phpt
index 19f3bc1427bf7..bbdc65275558d 100644
--- a/ext/pdo_sqlite/tests/pdo_sqlite_extendederror_attr.phpt
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_extendederror_attr.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO_sqlite: Testing PDO_SQLITE_ATTR_EXTENDED_RESULT_CODES
+PDO_sqlite: Testing Pdo\Sqlite::ATTR_EXTENDED_RESULT_CODES
 --EXTENSIONS--
 pdo_sqlite
 --FILE--
@@ -23,7 +23,7 @@ echo sprintf("Second Error Info: SQLSTATE Error Code: (%s), Driver Specific Erro
 
 
 echo "Creating new PDO with Extended Result Codes turned on" . PHP_EOL;
-$db = new PDO('sqlite::memory:', '', '', [PDO::SQLITE_ATTR_EXTENDED_RESULT_CODES => TRUE]);
+$db = new PDO('sqlite::memory:', '', '', [Pdo\Sqlite::ATTR_EXTENDED_RESULT_CODES => TRUE]);
 $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
 
 $db->exec("CREATE TABLE dog ( id INTEGER PRIMARY KEY, name TEXT, annoying INTEGER )");
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_open_flags.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_open_flags.phpt
index 772b1d9a76b05..00e1153fa91a0 100644
--- a/ext/pdo_sqlite/tests/pdo_sqlite_open_flags.phpt
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_open_flags.phpt
@@ -12,7 +12,7 @@ $db = new PDO('sqlite:' . $filename, null, null, [PDO::ATTR_ERRMODE => PDO::ERRM
 
 var_dump($db->exec('CREATE TABLE test_sqlite_open_flags (id INT);'));
 
-$db = new PDO('sqlite:' . $filename, null, null, [PDO::SQLITE_ATTR_OPEN_FLAGS => PDO::SQLITE_OPEN_READONLY, PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);
+$db = new PDO('sqlite:' . $filename, null, null, [Pdo\Sqlite::ATTR_OPEN_FLAGS => Pdo\Sqlite::OPEN_READONLY, PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION]);
 
 var_dump($db->exec('CREATE TABLE test_sqlite_open_flags_2 (id INT);'));
 ?>
diff --git a/ext/pdo_sqlite/tests/pdo_sqlite_statement_getattribute.phpt b/ext/pdo_sqlite/tests/pdo_sqlite_statement_getattribute.phpt
index 21b19654977fe..af6f3ad024b71 100644
--- a/ext/pdo_sqlite/tests/pdo_sqlite_statement_getattribute.phpt
+++ b/ext/pdo_sqlite/tests/pdo_sqlite_statement_getattribute.phpt
@@ -9,11 +9,11 @@ $db = new PDO('sqlite::memory:');
 
 $st = $db->prepare('SELECT 1;');
 
-var_dump($st->getAttribute(PDO::SQLITE_ATTR_READONLY_STATEMENT));
+var_dump($st->getAttribute(Pdo\Sqlite::ATTR_READONLY_STATEMENT));
 
 $st = $db->prepare('CREATE TABLE test_sqlite_stmt_getattribute (a TEXT);');
 
-var_dump($st->getAttribute(PDO::SQLITE_ATTR_READONLY_STATEMENT));
+var_dump($st->getAttribute(Pdo\Sqlite::ATTR_READONLY_STATEMENT));
 ?>
 --EXPECT--
 bool(true)
diff --git a/ext/pdo_sqlite/tests/php_8.5_deprecations.phpt b/ext/pdo_sqlite/tests/php_8.5_deprecations.phpt
new file mode 100644
index 0000000000000..26aaa60894137
--- /dev/null
+++ b/ext/pdo_sqlite/tests/php_8.5_deprecations.phpt
@@ -0,0 +1,39 @@
+--TEST--
+PDO_sqlite: PHP 8.5 deprecations
+--EXTENSIONS--
+pdo_sqlite
+--FILE--
+<?php
+
+var_dump(
+     PDO::SQLITE_ATTR_EXTENDED_RESULT_CODES,
+     PDO::SQLITE_ATTR_OPEN_FLAGS,
+     PDO::SQLITE_ATTR_READONLY_STATEMENT,
+     PDO::SQLITE_DETERMINISTIC,
+     PDO::SQLITE_OPEN_READONLY,
+     PDO::SQLITE_OPEN_READWRITE,
+     PDO::SQLITE_OPEN_CREATE,
+);
+
+?>
+--EXPECTF--
+Deprecated: Constant PDO::SQLITE_ATTR_EXTENDED_RESULT_CODES is deprecated since 8.5, use Pdo\Sqlite::ATTR_EXTENDED_RESULT_CODES instead in %s on line %d
+
+Deprecated: Constant PDO::SQLITE_ATTR_OPEN_FLAGS is deprecated since 8.5, use Pdo\Sqlite::ATTR_OPEN_FLAGS instead in %s on line %d
+
+Deprecated: Constant PDO::SQLITE_ATTR_READONLY_STATEMENT is deprecated since 8.5, use Pdo\Sqlite::ATTR_READONLY_STATEMENT instead in %s on line %d
+
+Deprecated: Constant PDO::SQLITE_DETERMINISTIC is deprecated since 8.5, use Pdo\Sqlite::DETERMINISTIC instead in %s on line %d
+
+Deprecated: Constant PDO::SQLITE_OPEN_READONLY is deprecated since 8.5, use Pdo\Sqlite::OPEN_READONLY instead in %s on line %d
+
+Deprecated: Constant PDO::SQLITE_OPEN_READWRITE is deprecated since 8.5, use Pdo\Sqlite::OPEN_READWRITE instead in %s on line %d
+
+Deprecated: Constant PDO::SQLITE_OPEN_CREATE is deprecated since 8.5, use Pdo\Sqlite::OPEN_CREATE instead in %s on line %d
+int(1002)
+int(1000)
+int(1001)
+int(2048)
+int(1)
+int(2)
+int(4)
diff --git a/ext/pdo_sqlite/tests/subclasses/pdo_sqlite_createfunction_with_flags.phpt b/ext/pdo_sqlite/tests/subclasses/pdo_sqlite_createfunction_with_flags.phpt
index 838e2b9bd49b0..c828817d2c3ad 100644
--- a/ext/pdo_sqlite/tests/subclasses/pdo_sqlite_createfunction_with_flags.phpt
+++ b/ext/pdo_sqlite/tests/subclasses/pdo_sqlite_createfunction_with_flags.phpt
@@ -4,7 +4,7 @@ PDO_sqlite: Testing createFunction() with flags
 pdo_sqlite
 --SKIPIF--
 <?php
-if (!defined('PDO::SQLITE_DETERMINISTIC')) die('skip system sqlite is too old');
+if (!defined('Pdo\Sqlite::DETERMINISTIC')) die('skip system sqlite is too old');
 ?>
 --FILE--
 <?php