php/archived-php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2026-03-24 00:02:20 +01:00
Code Issues Packages Projects Releases Wiki Activity

Deprecate driver specific PDO constants

Browse Source 
RFC: https://wiki.php.net/rfc/deprecations_php_8_5.

Closes GH-19526
This commit is contained in:
Arnaud Le Blanc
2025-08-20 09:41:53 +02:00
parent 99068da2b1
commit 6f32e1c690
103 changed files with 684 additions and 348 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
NEWS
View File

@@ -48,6 +48,9 @@ PHP NEWS
. Implement #81724 (openssl_cms_encrypt only allows specific ciphers).
(Jakub Zelenka)
- PDO:
. Driver specific constants in the PDO class are now deprecated. (Arnaud)
- Phar:
. Fixed memory leaks when verifying OpenSSL signature. (Girgias)

45
UPGRADING
View File

@@ -427,6 +427,51 @@ PHP 8.5 UPGRADE NOTES
. The "uri:" DSN scheme has been deprecated due to security concerns with
DSNs coming from remote URIs.
RFC: https://wiki.php.net/rfc/deprecations_php_8_5#deprecate_pdo_s_urischeme
. Driver specific constants in the PDO class have been deprecated.
List of affected constants and their replacement:
PDO::DBLIB_ATTR_CONNECTION_TIMEOUT => Pdo\Dblib::ATTR_CONNECTION_TIMEOUT
PDO::DBLIB_ATTR_QUERY_TIMEOUT => Pdo\Dblib::ATTR_QUERY_TIMEOUT
PDO::DBLIB_ATTR_STRINGIFY_UNIQUEIDENTIFIER => Pdo\Dblib::ATTR_STRINGIFY_UNIQUEIDENTIFIER
PDO::DBLIB_ATTR_VERSION => Pdo\Dblib::ATTR_VERSION
PDO::DBLIB_ATTR_TDS_VERSION => Pdo\Dblib::ATTR_TDS_VERSION
PDO::DBLIB_ATTR_SKIP_EMPTY_ROWSETS => Pdo\Dblib::ATTR_SKIP_EMPTY_ROWSETS
PDO::DBLIB_ATTR_DATETIME_CONVERT => Pdo\Dblib::ATTR_DATETIME_CONVERT
PDO::FB_ATTR_DATE_FORMAT => Pdo\Firebird::ATTR_DATE_FORMAT
PDO::FB_ATTR_TIME_FORMAT => Pdo\Firebird::ATTR_TIME_FORMAT
PDO::FB_ATTR_TIMESTAMP_FORMAT => Pdo\Firebird::ATTR_TIMESTAMP_FORMAT
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_LOCAL_INFILE_DIRECTORY => Pdo\Mysql::ATTR_LOCAL_INFILE_DIRECTORY
PDO::MYSQL_ATTR_INIT_COMMAND => Pdo\Mysql::ATTR_INIT_COMMAND
PDO::MYSQL_ATTR_MAX_BUFFER_SIZE => Pdo\Mysql::ATTR_MAX_BUFFER_SIZE
PDO::MYSQL_ATTR_READ_DEFAULT_FILE => Pdo\Mysql::ATTR_READ_DEFAULT_FILE
PDO::MYSQL_ATTR_READ_DEFAULT_GROUP => Pdo\Mysql::ATTR_READ_DEFAULT_GROUP
PDO::MYSQL_ATTR_COMPRESS => Pdo\Mysql::ATTR_COMPRESS
PDO::MYSQL_ATTR_DIRECT_QUERY => Pdo\Mysql::ATTR_DIRECT_QUERY
PDO::MYSQL_ATTR_FOUND_ROWS => Pdo\Mysql::ATTR_FOUND_ROWS
PDO::MYSQL_ATTR_IGNORE_SPACE => Pdo\Mysql::ATTR_IGNORE_SPACE
PDO::MYSQL_ATTR_SSL_KEY => Pdo\Mysql::ATTR_SSL_KEY
PDO::MYSQL_ATTR_SSL_CERT => Pdo\Mysql::ATTR_SSL_CERT
PDO::MYSQL_ATTR_SSL_CA => Pdo\Mysql::ATTR_SSL_CA
PDO::MYSQL_ATTR_SSL_CAPATH => Pdo\Mysql::ATTR_SSL_CAPATH
PDO::MYSQL_ATTR_SSL_CIPHER => Pdo\Mysql::ATTR_SSL_CIPHER
PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => Pdo\Mysql::ATTR_SSL_VERIFY_SERVER_CERT
PDO::MYSQL_ATTR_SERVER_PUBLIC_KEY => Pdo\Mysql::ATTR_SERVER_PUBLIC_KEY
PDO::MYSQL_ATTR_MULTI_STATEMENTS => Pdo\Mysql::ATTR_MULTI_STATEMENTS
PDO::ODBC_ATTR_USE_CURSOR_LIBRARY => Pdo\Odbc::ATTR_USE_CURSOR_LIBRARY
PDO::ODBC_ATTR_ASSUME_UTF8 => Pdo\Odbc::ATTR_ASSUME_UTF8
PDO::ODBC_SQL_USE_IF_NEEDED => Pdo\Odbc::SQL_USE_IF_NEEDED
PDO::ODBC_SQL_USE_DRIVER => Pdo\Odbc::SQL_USE_DRIVER
PDO::ODBC_SQL_USE_ODBC => Pdo\Odbc::SQL_USE_ODBC
PDO::PGSQL_ATTR_DISABLE_PREPARES => Pdo\Pgsql::ATTR_DISABLE_PREPARES
PDO::SQLITE_ATTR_EXTENDED_RESULT_CODES => Pdo\Sqlite::ATTR_EXTENDED_RESULT_CODES
PDO::SQLITE_ATTR_OPEN_FLAGS => Pdo\Sqlite::OPEN_FLAGS
PDO::SQLITE_ATTR_READONLY_STATEMENT => Pdo\Sqlite::ATTR_READONLY_STATEMENT
PDO::SQLITE_DETERMINISTIC => Pdo\Sqlite::DETERMINISTIC
PDO::SQLITE_OPEN_READONLY => Pdo\Sqlite::OPEN_READONLY
PDO::SQLITE_OPEN_READWRITE => Pdo\Sqlite::OPEN_READWRITE
PDO::SQLITE_OPEN_CREATE => Pdo\Sqlite::OPEN_CREATE
RFC: https://wiki.php.net/rfc/deprecations_php_8_5#deprecate_driver_specific_pdo_constants_and_methods
- Reflection:
. The setAccessible() methods of various Reflection objects have been

2
ext/mysqli/tests/bug77956.phpt
View File

@@ -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

2
ext/mysqlnd/mysqlnd_loaddata.c
View File

@@ -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;
}

46
ext/pdo/php_pdo.h
View File

@@ -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

2
ext/pdo/tests/pdo_016.phpt
View File

@@ -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))');

2
ext/pdo/tests/pdo_016a.phpt
View File

@@ -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))');

2
ext/pdo/tests/pdo_021.phpt
View File

@@ -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))');

17
ext/pdo_dblib/pdo_dblib.c
View File

@@ -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;

10
ext/pdo_dblib/tests/bug_69592.phpt
View File

@@ -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--

2
ext/pdo_dblib/tests/bug_73396.phpt
View File

@@ -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

2
ext/pdo_dblib/tests/config.inc
View File

@@ -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');
}

8
ext/pdo_dblib/tests/datetime2.phpt
View File

@@ -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));

8
ext/pdo_dblib/tests/datetime_convert.phpt
View File

@@ -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));

4
ext/pdo_dblib/tests/dbtds.phpt
View File

@@ -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);
?>

4
ext/pdo_dblib/tests/dbversion.phpt
View File

@@ -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));
?>

39
ext/pdo_dblib/tests/php_8.5_deprecations.phpt Normal file
View File

@@ -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)

12
ext/pdo_dblib/tests/stringify_uniqueidentifier.phpt
View File

@@ -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);

4
ext/pdo_dblib/tests/timeout.phpt
View File

@@ -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";

2
ext/pdo_dblib/tests/types.phpt
View File

@@ -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':

9
ext/pdo_firebird/pdo_firebird.c
View File

@@ -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;

2
ext/pdo_firebird/tests/dialect_1.phpt
View File

@@ -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

2
ext/pdo_firebird/tests/execute.phpt
View File

@@ -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)");

6
ext/pdo_firebird/tests/gh18276.phpt
View File

@@ -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);
}

23
ext/pdo_firebird/tests/php_8.5_deprecations.phpt Normal file
View File

@@ -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)

2
ext/pdo_mysql/mysql_driver.c
View File

@@ -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) {

41
ext/pdo_mysql/pdo_mysql.c
View File

@@ -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

8
ext/pdo_mysql/tests/bug66528.phpt
View File

@@ -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.

2
ext/pdo_mysql/tests/bug67004.phpt
View File

@@ -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 ?");

2
ext/pdo_mysql/tests/bug68371.phpt
View File

@@ -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],

4
ext/pdo_mysql/tests/bug70389.phpt
View File

@@ -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,
];

2
ext/pdo_mysql/tests/bug71145.phpt
View File

@@ -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,
];

2
ext/pdo_mysql/tests/bug71569.phpt
View File

@@ -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();

2
ext/pdo_mysql/tests/bug79375.phpt
View File

@@ -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";

2
ext/pdo_mysql/tests/bug80458.phpt
View File

@@ -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();

2
ext/pdo_mysql/tests/bug80908.phpt
View File

@@ -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();

8
ext/pdo_mysql/tests/bug_42499.phpt
View File

@@ -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!

76
ext/pdo_mysql/tests/pdo_mysql___construct_options.phpt
View File

@@ -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!

36
ext/pdo_mysql/tests/pdo_mysql___construct_options_libmysql.phpt
View File

@@ -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!

4
ext/pdo_mysql/tests/pdo_mysql_attr_init_command.phpt
View File

@@ -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();

8
ext/pdo_mysql/tests/pdo_mysql_attr_max_buffer_size.phpt
View File

@@ -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,
]);

4
ext/pdo_mysql/tests/pdo_mysql_attr_multi_statements.phpt
View File

@@ -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));

2
ext/pdo_mysql/tests/pdo_mysql_attr_oracle_nulls.phpt
View File

@@ -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;"))) {

2
ext/pdo_mysql/tests/pdo_mysql_exec_load_data.phpt
View File

@@ -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 */

6
ext/pdo_mysql/tests/pdo_mysql_exec_select.phpt
View File

@@ -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!

22
ext/pdo_mysql/tests/pdo_mysql_get_attribute.phpt
View File

@@ -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.
*/

6
ext/pdo_mysql/tests/pdo_mysql_local_infile_default_off.phpt
View File

@@ -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--

8
ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_allowed.phpt
View File

@@ -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 {

8
ext/pdo_mysql/tests/pdo_mysql_local_infile_directory_denied.phpt
View File

@@ -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 {

8
ext/pdo_mysql/tests/pdo_mysql_local_infile_overrides_local_infile_directory.phpt
View File

@@ -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 {

4
ext/pdo_mysql/tests/pdo_mysql_local_infile_set_on.phpt
View File

@@ -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--

16
ext/pdo_mysql/tests/pdo_mysql_multi_stmt_nextrowset.phpt
View File

@@ -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) {

4
ext/pdo_mysql/tests/pdo_mysql_prepare_emulated.phpt
View File

@@ -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 {

8
ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous.phpt
View File

@@ -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');

4
ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_anonymous_placeholders.phpt
View File

@@ -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 {

4
ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam.phpt
View File

@@ -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 {

4
ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_myisam_index.phpt
View File

@@ -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 {

8
ext/pdo_mysql/tests/pdo_mysql_prepare_emulated_placeholder_everywhere.phpt
View File

@@ -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 ? > ?');

4
ext/pdo_mysql/tests/pdo_mysql_prepare_native.phpt
View File

@@ -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 {

4
ext/pdo_mysql/tests/pdo_mysql_prepare_native_anonymous_placeholder.phpt
View File

@@ -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 {

8
ext/pdo_mysql/tests/pdo_mysql_prepare_native_clear_error.phpt
View File

@@ -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');

4
ext/pdo_mysql/tests/pdo_mysql_prepare_native_column.phpt
View File

@@ -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");

12
ext/pdo_mysql/tests/pdo_mysql_prepare_native_dup_named_placeholder.phpt
View File

@@ -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");

4
ext/pdo_mysql/tests/pdo_mysql_prepare_native_mixed_style.phpt
View File

@@ -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}");

4
ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam.phpt
View File

@@ -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 {

4
ext/pdo_mysql/tests/pdo_mysql_prepare_native_myisam_index.phpt
View File

@@ -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 {

8
ext/pdo_mysql/tests/pdo_mysql_prepare_native_named_placeholder.phpt
View File

@@ -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.

8
ext/pdo_mysql/tests/pdo_mysql_prepare_native_placeholder_everywhere.phpt
View File

@@ -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');

8
ext/pdo_mysql/tests/pdo_mysql_stmt_bindcolumn.phpt
View File

@@ -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");

16
ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam.phpt
View File

@@ -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) {

4
ext/pdo_mysql/tests/pdo_mysql_stmt_bindparam_types.phpt
View File

@@ -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()))

8
ext/pdo_mysql/tests/pdo_mysql_stmt_bindvalue.phpt
View File

@@ -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");

28
ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor.phpt
View File

@@ -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!

6
ext/pdo_mysql/tests/pdo_mysql_stmt_closecursor_empty.phpt
View File

@@ -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");

8
ext/pdo_mysql/tests/pdo_mysql_stmt_columncount.phpt
View File

@@ -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}");

8
ext/pdo_mysql/tests/pdo_mysql_stmt_errorcode.phpt
View File

@@ -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');

8
ext/pdo_mysql/tests/pdo_mysql_stmt_errorinfo.phpt
View File

@@ -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');

4
ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_class.phpt
View File

@@ -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',

8
ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_non_select.phpt
View File

@@ -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';

4
ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize.phpt
View File

@@ -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',

4
ext/pdo_mysql/tests/pdo_mysql_stmt_fetch_serialize_fetch_class.phpt
View File

@@ -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',

4
ext/pdo_mysql/tests/pdo_mysql_stmt_getcolumnmeta.phpt
View File

@@ -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');

8
ext/pdo_mysql/tests/pdo_mysql_stmt_nextrowset.phpt
View File

@@ -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);

8
ext/pdo_mysql/tests/pdo_mysql_stmt_unbuffered_2050.phpt
View File

@@ -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));
/*

4
ext/pdo_mysql/tests/pdo_mysql_stmt_variable_columncount.phpt
View File

@@ -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();

81
ext/pdo_mysql/tests/php_8.5_deprecations.phpt Normal file
View File

@@ -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)

13
ext/pdo_odbc/pdo_odbc.c
View File

@@ -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;

2
ext/pdo_odbc/tests/bug80783a.phpt
View File

@@ -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);

31
ext/pdo_odbc/tests/php_8.5_deprecations.phpt Normal file
View File

@@ -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)

15
ext/pdo_pgsql/pdo_pgsql.c
View File

@@ -175,15 +175,18 @@ cleanup:
/* 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;

2
ext/pdo_pgsql/tests/bug68371.phpt
View File

@@ -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),

2
ext/pdo_pgsql/tests/bug73959.phpt
View File

@@ -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');

2
ext/pdo_pgsql/tests/disable_prepares.phpt
View File

@@ -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));

4
ext/pdo_pgsql/tests/gh15287.phpt
View File

@@ -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;

18
ext/pdo_pgsql/tests/is_in_transaction.phpt
View File

@@ -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)

15
ext/pdo_pgsql/tests/php_8.5_deprecations.phpt Normal file
View File

@@ -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)

17
ext/pdo_sqlite/pdo_sqlite.c
View File

@@ -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;

4
ext/pdo_sqlite/tests/pdo_sqlite_createfunction_with_flags.phpt
View File

@@ -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) {

4
ext/pdo_sqlite/tests/pdo_sqlite_extendederror_attr.phpt
View File

@@ -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 )");

2
ext/pdo_sqlite/tests/pdo_sqlite_open_flags.phpt
View File

@@ -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);'));
?>

Some files were not shown because too many files have changed in this diff Show More