Make PDO use class constants

diff --git a/ext/pdo/pdo.c b/ext/pdo/pdo.c
index 1a92d504a32a48182a1793f1c23ea41355383143..2518e925208501945aa8d8cb0e4d9f44b586ad07 100755 (executable)
--- a/ext/pdo/pdo.c
+++ b/ext/pdo/pdo.c
@@ -302,89 +302,6 @@ PHP_MINIT_FUNCTION(pdo)
        le_ppdo = zend_register_list_destructors_ex(NULL, php_pdo_pdbh_dtor,
                "PDO persistent database", module_number);
 
-       REGISTER_LONG_CONSTANT("PDO_PARAM_BOOL", (long)PDO_PARAM_BOOL,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_PARAM_NULL", (long)PDO_PARAM_NULL,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_PARAM_INT",  (long)PDO_PARAM_INT,   CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_PARAM_STR",  (long)PDO_PARAM_STR,   CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_PARAM_LOB",  (long)PDO_PARAM_LOB,   CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_PARAM_STMT", (long)PDO_PARAM_STMT,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_PARAM_INPUT_OUTPUT", (long)PDO_PARAM_INPUT_OUTPUT,  CONST_CS|CONST_PERSISTENT);
-
-       REGISTER_LONG_CONSTANT("PDO_FETCH_LAZY", (long)PDO_FETCH_LAZY,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_ASSOC",(long)PDO_FETCH_ASSOC, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_NUM",  (long)PDO_FETCH_NUM,   CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_BOTH", (long)PDO_FETCH_BOTH,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_OBJ",  (long)PDO_FETCH_OBJ,   CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_BOUND",(long)PDO_FETCH_BOUND, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_COLUMN",(long)PDO_FETCH_COLUMN,       CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_CLASS",(long)PDO_FETCH_CLASS, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_INTO", (long)PDO_FETCH_INTO,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_FUNC", (long)PDO_FETCH_FUNC,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_GROUP",(long)PDO_FETCH_GROUP, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_UNIQUE",(long)PDO_FETCH_UNIQUE, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_CLASSTYPE",(long)PDO_FETCH_CLASSTYPE, CONST_CS|CONST_PERSISTENT);
-#if PHP_MAJOR_VERSION > 5 || PHP_MINOR_VERSION >= 1
-       REGISTER_LONG_CONSTANT("PDO_FETCH_SERIALIZE",(long)PDO_FETCH_SERIALIZE, CONST_CS|CONST_PERSISTENT);
-#endif
-       REGISTER_LONG_CONSTANT("PDO_FETCH_NAMED",(long)PDO_FETCH_NAMED, CONST_CS|CONST_PERSISTENT);
-
-       REGISTER_LONG_CONSTANT("PDO_ATTR_AUTOCOMMIT",   (long)PDO_ATTR_AUTOCOMMIT,      CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_PREFETCH",             (long)PDO_ATTR_PREFETCH,        CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_TIMEOUT",              (long)PDO_ATTR_TIMEOUT,         CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_ERRMODE",              (long)PDO_ATTR_ERRMODE,         CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_SERVER_VERSION",       (long)PDO_ATTR_SERVER_VERSION,  CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_CLIENT_VERSION",       (long)PDO_ATTR_CLIENT_VERSION,          CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_SERVER_INFO",          (long)PDO_ATTR_SERVER_INFO,     CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_CONNECTION_STATUS",    (long)PDO_ATTR_CONNECTION_STATUS,               CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_CASE",                 (long)PDO_ATTR_CASE,            CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_CURSOR_NAME",  (long)PDO_ATTR_CURSOR_NAME,             CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_CURSOR",               (long)PDO_ATTR_CURSOR,          CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_ORACLE_NULLS", (long)PDO_ATTR_ORACLE_NULLS,    CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_PERSISTENT",   (long)PDO_ATTR_PERSISTENT,              CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_STATEMENT_CLASS",              (long)PDO_ATTR_STATEMENT_CLASS,                 CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_FETCH_TABLE_NAMES",            (long)PDO_ATTR_FETCH_TABLE_NAMES,                       CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_FETCH_CATALOG_NAMES",          (long)PDO_ATTR_FETCH_CATALOG_NAMES,                     CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_DRIVER_NAME",          (long)PDO_ATTR_DRIVER_NAME,     CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_STRINGIFY_FETCHES",(long)PDO_ATTR_STRINGIFY_FETCHES,   CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ATTR_MAX_COLUMN_LEN",(long)PDO_ATTR_MAX_COLUMN_LEN, CONST_CS|CONST_PERSISTENT);
-       
-       REGISTER_LONG_CONSTANT("PDO_ERRMODE_SILENT",    (long)PDO_ERRMODE_SILENT,               CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERRMODE_WARNING",   (long)PDO_ERRMODE_WARNING,              CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERRMODE_EXCEPTION", (long)PDO_ERRMODE_EXCEPTION,    CONST_CS|CONST_PERSISTENT);
-
-       REGISTER_LONG_CONSTANT("PDO_CASE_NATURAL",      (long)PDO_CASE_NATURAL,         CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_CASE_LOWER",        (long)PDO_CASE_LOWER,           CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_CASE_UPPER",        (long)PDO_CASE_UPPER,           CONST_CS|CONST_PERSISTENT);
-
-       REGISTER_LONG_CONSTANT("PDO_NULL_NATURAL",      (long)PDO_NULL_NATURAL,         CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_NULL_EMPTY_STRING", (long)PDO_NULL_EMPTY_STRING,            CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_NULL_TO_STRING",    (long)PDO_NULL_TO_STRING,               CONST_CS|CONST_PERSISTENT);
-                       
-       REGISTER_STRING_CONSTANT("PDO_ERR_NONE",        PDO_ERR_NONE,           CONST_CS|CONST_PERSISTENT);
-
-       REGISTER_LONG_CONSTANT("PDO_FETCH_ORI_NEXT", (long)PDO_FETCH_ORI_NEXT, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_ORI_PRIOR", (long)PDO_FETCH_ORI_PRIOR, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_ORI_FIRST", (long)PDO_FETCH_ORI_FIRST, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_ORI_LAST", (long)PDO_FETCH_ORI_LAST, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_ORI_ABS", (long)PDO_FETCH_ORI_ABS, CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_FETCH_ORI_REL", (long)PDO_FETCH_ORI_REL, CONST_CS|CONST_PERSISTENT);
-       
-       REGISTER_LONG_CONSTANT("PDO_CURSOR_FWDONLY", (long)PDO_CURSOR_FWDONLY,CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_CURSOR_SCROLL", (long)PDO_CURSOR_SCROLL,CONST_CS|CONST_PERSISTENT);
-
-#if 0
-       REGISTER_LONG_CONSTANT("PDO_ERR_CANT_MAP",                      (long)PDO_ERR_CANT_MAP,         CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_SYNTAX",                        (long)PDO_ERR_SYNTAX,           CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_CONSTRAINT",            (long)PDO_ERR_CONSTRAINT,               CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_NOT_FOUND",             (long)PDO_ERR_NOT_FOUND,                CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_ALREADY_EXISTS",        (long)PDO_ERR_ALREADY_EXISTS,           CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_NOT_IMPLEMENTED",       (long)PDO_ERR_NOT_IMPLEMENTED,          CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_MISMATCH",                      (long)PDO_ERR_MISMATCH,         CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_TRUNCATED",             (long)PDO_ERR_TRUNCATED,                CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_DISCONNECTED",          (long)PDO_ERR_DISCONNECTED,             CONST_CS|CONST_PERSISTENT);
-       REGISTER_LONG_CONSTANT("PDO_ERR_NO_PERM",                       (long)PDO_ERR_NO_PERM,                  CONST_CS|CONST_PERSISTENT);
-#endif
-
        INIT_CLASS_ENTRY(ce, "PDOException", NULL);
 #if can_handle_soft_dependency_on_SPL && defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
        pdo_exception_ce = zend_register_internal_class_ex(&ce, spl_ce_RuntimeException, NULL TSRMLS_CC);

diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index b560c5f879d8d0fad19cc8473ca0e67cbdbe659e..c3103c8a71db95795a4d72c4e8ed879652e00074 100755 (executable)
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -1125,6 +1125,90 @@ void pdo_dbh_init(TSRMLS_D)
        memcpy(&pdo_dbh_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
        pdo_dbh_object_handlers.get_method = dbh_method_get;
        pdo_dbh_object_handlers.compare_objects = dbh_compare;
+
+       REGISTER_PDO_CLASS_CONST_LONG("PARAM_BOOL", (long)PDO_PARAM_BOOL);
+       REGISTER_PDO_CLASS_CONST_LONG("PARAM_NULL", (long)PDO_PARAM_NULL);
+       REGISTER_PDO_CLASS_CONST_LONG("PARAM_INT",  (long)PDO_PARAM_INT);
+       REGISTER_PDO_CLASS_CONST_LONG("PARAM_STR",  (long)PDO_PARAM_STR);
+       REGISTER_PDO_CLASS_CONST_LONG("PARAM_LOB",  (long)PDO_PARAM_LOB);
+       REGISTER_PDO_CLASS_CONST_LONG("PARAM_STMT", (long)PDO_PARAM_STMT);
+       REGISTER_PDO_CLASS_CONST_LONG("PARAM_INPUT_OUTPUT", (long)PDO_PARAM_INPUT_OUTPUT);
+
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_LAZY", (long)PDO_FETCH_LAZY);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_ASSOC",(long)PDO_FETCH_ASSOC);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_NUM",  (long)PDO_FETCH_NUM);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_BOTH", (long)PDO_FETCH_BOTH);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_OBJ",  (long)PDO_FETCH_OBJ);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_BOUND",(long)PDO_FETCH_BOUND);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_COLUMN",(long)PDO_FETCH_COLUMN);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_CLASS",(long)PDO_FETCH_CLASS);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_INTO", (long)PDO_FETCH_INTO);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_FUNC", (long)PDO_FETCH_FUNC);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_GROUP",(long)PDO_FETCH_GROUP);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_UNIQUE",(long)PDO_FETCH_UNIQUE);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_CLASSTYPE",(long)PDO_FETCH_CLASSTYPE);
+#if PHP_MAJOR_VERSION > 5 || PHP_MINOR_VERSION >= 1
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_SERIALIZE",(long)PDO_FETCH_SERIALIZE);
+#endif
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_NAMED",(long)PDO_FETCH_NAMED);
+
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_AUTOCOMMIT",        (long)PDO_ATTR_AUTOCOMMIT);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_PREFETCH",          (long)PDO_ATTR_PREFETCH);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_TIMEOUT",           (long)PDO_ATTR_TIMEOUT);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_ERRMODE",           (long)PDO_ATTR_ERRMODE);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_SERVER_VERSION",    (long)PDO_ATTR_SERVER_VERSION);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_CLIENT_VERSION",    (long)PDO_ATTR_CLIENT_VERSION);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_SERVER_INFO",               (long)PDO_ATTR_SERVER_INFO);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_CONNECTION_STATUS",         (long)PDO_ATTR_CONNECTION_STATUS);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_CASE",                      (long)PDO_ATTR_CASE);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_CURSOR_NAME",       (long)PDO_ATTR_CURSOR_NAME);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_CURSOR",            (long)PDO_ATTR_CURSOR);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_ORACLE_NULLS",      (long)PDO_ATTR_ORACLE_NULLS);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_PERSISTENT",        (long)PDO_ATTR_PERSISTENT);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_STATEMENT_CLASS",           (long)PDO_ATTR_STATEMENT_CLASS);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_FETCH_TABLE_NAMES",         (long)PDO_ATTR_FETCH_TABLE_NAMES);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_FETCH_CATALOG_NAMES",               (long)PDO_ATTR_FETCH_CATALOG_NAMES);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_DRIVER_NAME",               (long)PDO_ATTR_DRIVER_NAME);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_STRINGIFY_FETCHES",(long)PDO_ATTR_STRINGIFY_FETCHES);
+       REGISTER_PDO_CLASS_CONST_LONG("ATTR_MAX_COLUMN_LEN",(long)PDO_ATTR_MAX_COLUMN_LEN);
+       
+       REGISTER_PDO_CLASS_CONST_LONG("ERRMODE_SILENT", (long)PDO_ERRMODE_SILENT);
+       REGISTER_PDO_CLASS_CONST_LONG("ERRMODE_WARNING",        (long)PDO_ERRMODE_WARNING);
+       REGISTER_PDO_CLASS_CONST_LONG("ERRMODE_EXCEPTION",      (long)PDO_ERRMODE_EXCEPTION);
+
+       REGISTER_PDO_CLASS_CONST_LONG("CASE_NATURAL",   (long)PDO_CASE_NATURAL);
+       REGISTER_PDO_CLASS_CONST_LONG("CASE_LOWER",     (long)PDO_CASE_LOWER);
+       REGISTER_PDO_CLASS_CONST_LONG("CASE_UPPER",     (long)PDO_CASE_UPPER);
+
+       REGISTER_PDO_CLASS_CONST_LONG("NULL_NATURAL",   (long)PDO_NULL_NATURAL);
+       REGISTER_PDO_CLASS_CONST_LONG("NULL_EMPTY_STRING",      (long)PDO_NULL_EMPTY_STRING);
+       REGISTER_PDO_CLASS_CONST_LONG("NULL_TO_STRING", (long)PDO_NULL_TO_STRING);
+                       
+       REGISTER_PDO_CLASS_CONST_STRING("ERR_NONE",     PDO_ERR_NONE);
+
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_NEXT", (long)PDO_FETCH_ORI_NEXT);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_PRIOR", (long)PDO_FETCH_ORI_PRIOR);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_FIRST", (long)PDO_FETCH_ORI_FIRST);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_LAST", (long)PDO_FETCH_ORI_LAST);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_ABS", (long)PDO_FETCH_ORI_ABS);
+       REGISTER_PDO_CLASS_CONST_LONG("FETCH_ORI_REL", (long)PDO_FETCH_ORI_REL);
+       
+       REGISTER_PDO_CLASS_CONST_LONG("CURSOR_FWDONLY", (long)PDO_CURSOR_FWDONLY);
+       REGISTER_PDO_CLASS_CONST_LONG("CURSOR_SCROLL", (long)PDO_CURSOR_SCROLL);
+
+#if 0
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_CANT_MAP",           (long)PDO_ERR_CANT_MAP);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_SYNTAX",             (long)PDO_ERR_SYNTAX);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_CONSTRAINT",         (long)PDO_ERR_CONSTRAINT);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_NOT_FOUND",          (long)PDO_ERR_NOT_FOUND);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_ALREADY_EXISTS",     (long)PDO_ERR_ALREADY_EXISTS);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_NOT_IMPLEMENTED",    (long)PDO_ERR_NOT_IMPLEMENTED);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_MISMATCH",           (long)PDO_ERR_MISMATCH);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_TRUNCATED",          (long)PDO_ERR_TRUNCATED);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_DISCONNECTED",       (long)PDO_ERR_DISCONNECTED);
+       REGISTER_PDO_CLASS_CONST_LONG("ERR_NO_PERM",            (long)PDO_ERR_NO_PERM);
+#endif
+
 }
 
 static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)

diff --git a/ext/pdo/php_pdo.h b/ext/pdo/php_pdo.h
index c9fbb5606c77fd6a32149990789d002f31bc90d4..ba63cbfb97b948a27ac010557fac4809a8007076 100755 (executable)
--- a/ext/pdo/php_pdo.h
+++ b/ext/pdo/php_pdo.h
@@ -58,6 +58,18 @@ ZEND_END_MODULE_GLOBALS(pdo)
 # define PDOG(v) (pdo_globals.v)
 #endif
 
+#define REGISTER_PDO_CLASS_CONST_LONG(const_name, value) \
+       zend_declare_class_constant_long(pdo_dbh_ce, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC);
+
+#define REGISTER_PDO_CONST_LONG(const_name, value) { \
+       zend_class_entry **pce; \
+       if (zend_hash_find(CG(class_table), "pdo", sizeof("pdo"), (void **) &pce) != FAILURE)   \
+               zend_declare_class_constant_long(*pce, const_name, sizeof(const_name)-1, (long)value TSRMLS_CC);        \
+}      \
+
+#define REGISTER_PDO_CLASS_CONST_STRING(const_name, value) \
+       zend_declare_class_constant_stringl(pdo_dbh_ce, const_name, sizeof(const_name)-1, value, sizeof(value)-1 TSRMLS_CC);
+
 #endif /* PHP_PDO_H */
 
 

diff --git a/ext/pdo/tests/pdo_001.phpt b/ext/pdo/tests/pdo_001.phpt
index cf2013bfcec66c166e74997348e5b26f142dc08b..a3fca654068f3f470ddf53ecc315475b5570d560 100644 (file)
--- a/ext/pdo/tests/pdo_001.phpt
+++ b/ext/pdo/tests/pdo_001.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_ASSOC
+PDO Common: PDO::FETCH_ASSOC
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,7 +21,7 @@ $db->exec("INSERT INTO test VALUES(3, 'C')");
 $stmt = $db->prepare('SELECT * from test');
 $stmt->execute();
 
-var_dump($stmt->fetchAll(PDO_FETCH_ASSOC));
+var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 ?>
 --EXPECT--
 array(3) {

diff --git a/ext/pdo/tests/pdo_002.phpt b/ext/pdo/tests/pdo_002.phpt
index 3dbdff2945c6becfb497d921abdf4e0367e4d6f2..56a5e4d2efe88ce2f84b6460a698a7b1b27f70df 100644 (file)
--- a/ext/pdo/tests/pdo_002.phpt
+++ b/ext/pdo/tests/pdo_002.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_NUM
+PDO Common: PDO::FETCH_NUM
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,7 +21,7 @@ $db->exec("INSERT INTO test VALUES(3, 'C')");
 $stmt = $db->prepare('SELECT * from test');
 $stmt->execute();
 
-var_dump($stmt->fetchAll(PDO_FETCH_NUM));
+var_dump($stmt->fetchAll(PDO::FETCH_NUM));
 ?>
 --EXPECT--
 array(3) {

diff --git a/ext/pdo/tests/pdo_003.phpt b/ext/pdo/tests/pdo_003.phpt
index 963b43b9422b7a47acd6edc4e260fa59d943ef6d..fb99d2a255c9725dcbc70edb392db364e1de97d5 100644 (file)
--- a/ext/pdo/tests/pdo_003.phpt
+++ b/ext/pdo/tests/pdo_003.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_BOTH
+PDO Common: PDO::FETCH_BOTH
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,7 +21,7 @@ $db->exec("INSERT INTO test VALUES(3, 'C')");
 $stmt = $db->prepare('SELECT * from test');
 $stmt->execute();
 
-var_dump($stmt->fetchAll(PDO_FETCH_BOTH));
+var_dump($stmt->fetchAll(PDO::FETCH_BOTH));
 ?>
 --EXPECT--
 array(3) {

diff --git a/ext/pdo/tests/pdo_004.phpt b/ext/pdo/tests/pdo_004.phpt
index 6c8363885c22e5c36339b4e77d1de06b8fc44584..540faf6ba88c65e690f84452a6cbaf35ea4076bf 100644 (file)
--- a/ext/pdo/tests/pdo_004.phpt
+++ b/ext/pdo/tests/pdo_004.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_OBJ
+PDO Common: PDO::FETCH_OBJ
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,7 +21,7 @@ $db->exec("INSERT INTO test VALUES(3, 'C')");
 $stmt = $db->prepare('SELECT * from test');
 $stmt->execute();
 
-var_dump($stmt->fetchAll(PDO_FETCH_OBJ));
+var_dump($stmt->fetchAll(PDO::FETCH_OBJ));
 ?>
 --EXPECTF--
 array(3) {

diff --git a/ext/pdo/tests/pdo_005.phpt b/ext/pdo/tests/pdo_005.phpt
index 2b658de8fabdf252a83e8d034fb29f3bfb7b097a..04ffe1860442a2e6edf5bdda2ece2c23b1291a43 100644 (file)
--- a/ext/pdo/tests/pdo_005.phpt
+++ b/ext/pdo/tests/pdo_005.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_CLASS
+PDO Common: PDO::FETCH_CLASS
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -39,13 +39,13 @@ class TestDerived extends TestBase
 }
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_CLASS));
+var_dump($stmt->fetchAll(PDO::FETCH_CLASS));
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_CLASS, 'TestBase'));
+var_dump($stmt->fetchAll(PDO::FETCH_CLASS, 'TestBase'));
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_CLASS, 'TestDerived', array(0)));
+var_dump($stmt->fetchAll(PDO::FETCH_CLASS, 'TestDerived', array(0)));
 
 ?>
 --EXPECTF--

diff --git a/ext/pdo/tests/pdo_006.phpt b/ext/pdo/tests/pdo_006.phpt
index a07bc856a5af16d55f6f539e78930deb5ac25bb6..33baac3fc725bf851eccaea7309d4edf6f0150a3 100644 (file)
--- a/ext/pdo/tests/pdo_006.phpt
+++ b/ext/pdo/tests/pdo_006.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_GROUP
+PDO Common: PDO::FETCH_GROUP
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,10 +21,10 @@ $db->exec("INSERT INTO test VALUES(3, 'C')");
 $stmt = $db->prepare('SELECT val, id from test');
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_NUM|PDO_FETCH_GROUP));
+var_dump($stmt->fetchAll(PDO::FETCH_NUM|PDO::FETCH_GROUP));
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_ASSOC|PDO_FETCH_GROUP));
+var_dump($stmt->fetchAll(PDO::FETCH_ASSOC|PDO::FETCH_GROUP));
 
 ?>
 --EXPECT--

diff --git a/ext/pdo/tests/pdo_007.phpt b/ext/pdo/tests/pdo_007.phpt
index e50846ec9e7997e6cfed78765788d2b33ab61f8d..657daaa5589d6bc8a53b471a45fc87348182640d 100644 (file)
--- a/ext/pdo/tests/pdo_007.phpt
+++ b/ext/pdo/tests/pdo_007.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_UNIQUE
+PDO Common: PDO::FETCH_UNIQUE
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,10 +21,10 @@ $db->exec("INSERT INTO test VALUES('C', 'C')");
 $stmt = $db->prepare('SELECT id, val from test');
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_NUM|PDO_FETCH_UNIQUE));
+var_dump($stmt->fetchAll(PDO::FETCH_NUM|PDO::FETCH_UNIQUE));
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_ASSOC|PDO_FETCH_UNIQUE));
+var_dump($stmt->fetchAll(PDO::FETCH_ASSOC|PDO::FETCH_UNIQUE));
 
 ?>
 --EXPECT--

diff --git a/ext/pdo/tests/pdo_008.phpt b/ext/pdo/tests/pdo_008.phpt
index 9b49324a37841818558ee8f94e680db26f4f13db..543359fc182abe079be558c341400002517515fe 100644 (file)
--- a/ext/pdo/tests/pdo_008.phpt
+++ b/ext/pdo/tests/pdo_008.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_UNIQUE conflict
+PDO Common: PDO::FETCH_UNIQUE conflict
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,7 +21,7 @@ $db->exec("INSERT INTO test VALUES('C', 'C')");
 $stmt = $db->prepare('SELECT val, id from test');
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_NUM|PDO_FETCH_UNIQUE));
+var_dump($stmt->fetchAll(PDO::FETCH_NUM|PDO::FETCH_UNIQUE));
 
 ?>
 --EXPECT--

diff --git a/ext/pdo/tests/pdo_009.phpt b/ext/pdo/tests/pdo_009.phpt
index 61e198773466f0734750cf8380c356cf68da9092..a8a31e962ee0c5ac4def5a41a72a8dd9ac8bbea8 100644 (file)
--- a/ext/pdo/tests/pdo_009.phpt
+++ b/ext/pdo/tests/pdo_009.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_CLASSTYPE
+PDO Common: PDO::FETCH_CLASSTYPE
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -50,10 +50,10 @@ class Test3
 }
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_NUM));
+var_dump($stmt->fetchAll(PDO::FETCH_NUM));
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_CLASS|PDO_FETCH_CLASSTYPE, 'Test3'));
+var_dump($stmt->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_CLASSTYPE, 'Test3'));
 
 ?>
 --EXPECTF--

diff --git a/ext/pdo/tests/pdo_010.phpt b/ext/pdo/tests/pdo_010.phpt
index d78d1bf7ee9f8b12f287ebd7e734ff0aeaf9b6db..8a34d5791ba4209306374c3f8e9ed6ed588373ab 100644 (file)
--- a/ext/pdo/tests/pdo_010.phpt
+++ b/ext/pdo/tests/pdo_010.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_CLASSTYPE and GROUP/UNIQUE
+PDO Common: PDO::FETCH_CLASSTYPE and GROUP/UNIQUE
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -51,10 +51,10 @@ class Test3
 
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_CLASS|PDO_FETCH_CLASSTYPE|PDO_FETCH_GROUP, 'Test3'));
+var_dump($stmt->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_CLASSTYPE|PDO::FETCH_GROUP, 'Test3'));
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_CLASS|PDO_FETCH_CLASSTYPE|PDO_FETCH_UNIQUE, 'Test3'));
+var_dump($stmt->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_CLASSTYPE|PDO::FETCH_UNIQUE, 'Test3'));
 
 ?>
 --EXPECTF--

diff --git a/ext/pdo/tests/pdo_011.phpt b/ext/pdo/tests/pdo_011.phpt
index c2ff2b6e964490161f460aa1c715f51c23091a66..08aa55dba878746fa2c19473ab04700d5dadae2e 100644 (file)
--- a/ext/pdo/tests/pdo_011.phpt
+++ b/ext/pdo/tests/pdo_011.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_FUNC and statement overloading
+PDO Common: PDO::FETCH_FUNC and statement overloading
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -35,7 +35,7 @@ class DerivedStatement extends PDOStatement
 
 $select1 = $db->prepare('SELECT grp, id FROM test');
 $select2 = $db->prepare('SELECT id, val FROM test');
-$derived = $db->prepare('SELECT id, val FROM test', array(PDO_ATTR_STATEMENT_CLASS=>array('DerivedStatement', array('Overloaded', $db))));
+$derived = $db->prepare('SELECT id, val FROM test', array(PDO::ATTR_STATEMENT_CLASS=>array('DerivedStatement', array('Overloaded', $db))));
 
 class Test1
 {
@@ -62,20 +62,20 @@ function test($id,$val='N/A')
 $f = new Test1(0,0);
 
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_FUNC|PDO_FETCH_GROUP, 'test'));
+var_dump($select1->fetchAll(PDO::FETCH_FUNC|PDO::FETCH_GROUP, 'test'));
 
 $select2->execute();
-var_dump($select2->fetchAll(PDO_FETCH_FUNC, 'test'));
+var_dump($select2->fetchAll(PDO::FETCH_FUNC, 'test'));
 
 $select2->execute();
-var_dump($select2->fetchAll(PDO_FETCH_FUNC, array('Test1','factory')));
+var_dump($select2->fetchAll(PDO::FETCH_FUNC, array('Test1','factory')));
 
 $select2->execute();
-var_dump($select2->fetchAll(PDO_FETCH_FUNC, array($f, 'factory')));
+var_dump($select2->fetchAll(PDO::FETCH_FUNC, array($f, 'factory')));
 
 var_dump(get_class($derived));
 $derived->execute();
-var_dump($derived->fetchAll(PDO_FETCH_FUNC, array($derived, 'retrieve')));
+var_dump($derived->fetchAll(PDO::FETCH_FUNC, array($derived, 'retrieve')));
 
 ?>
 --EXPECTF--

diff --git a/ext/pdo/tests/pdo_012.phpt b/ext/pdo/tests/pdo_012.phpt
index de6857ae154004e4628deb826866ab3e39b8662f..22db0796e08cc356f5fbc62c6890e401daa63e21 100644 (file)
--- a/ext/pdo/tests/pdo_012.phpt
+++ b/ext/pdo/tests/pdo_012.phpt
@@ -19,7 +19,7 @@ $db->exec('INSERT INTO test VALUES(2, \'B\', \'Group2\')');
 
 $SELECT = 'SELECT val, grp FROM test';
 
-$stmt = $db->query($SELECT, PDO_FETCH_NUM);
+$stmt = $db->query($SELECT, PDO::FETCH_NUM);
 var_dump($stmt->fetchAll());
 
 class Test
@@ -32,13 +32,13 @@ class Test
 
 unset($stmt);
 
-$stmt = $db->query($SELECT, PDO_FETCH_CLASS, 'Test');
+$stmt = $db->query($SELECT, PDO::FETCH_CLASS, 'Test');
 var_dump($stmt->fetchAll());
 
 unset($stmt);
 
-$stmt = $db->query($SELECT, PDO_FETCH_NUM);
-$stmt->setFetchMode(PDO_FETCH_CLASS, 'Test', array('Changed'));
+$stmt = $db->query($SELECT, PDO::FETCH_NUM);
+$stmt->setFetchMode(PDO::FETCH_CLASS, 'Test', array('Changed'));
 var_dump($stmt->fetchAll());
 
 ?>

diff --git a/ext/pdo/tests/pdo_013.phpt b/ext/pdo/tests/pdo_013.phpt
index 1a0e601c47450ba01c268bfb16234ded48756155..08a62af1319f5a0d7ca5c40a24daf51823914633 100644 (file)
--- a/ext/pdo/tests/pdo_013.phpt
+++ b/ext/pdo/tests/pdo_013.phpt
@@ -22,7 +22,7 @@ $SELECT = 'SELECT val, grp FROM test';
 $stmt = $db->prepare($SELECT);
 
 $stmt->execute();
-$stmt->setFetchMode(PDO_FETCH_NUM);
+$stmt->setFetchMode(PDO::FETCH_NUM);
 foreach ($stmt as $data)
 {
        var_dump($data);
@@ -38,14 +38,14 @@ class Test
 
 unset($stmt);
 
-foreach ($db->query($SELECT, PDO_FETCH_CLASS, 'Test') as $data)
+foreach ($db->query($SELECT, PDO::FETCH_CLASS, 'Test') as $data)
 {
        var_dump($data);
 }
 
 unset($stmt);
 
-$stmt = $db->query($SELECT, PDO_FETCH_CLASS, 'Test', array('WOW'));
+$stmt = $db->query($SELECT, PDO::FETCH_CLASS, 'Test', array('WOW'));
 
 foreach($stmt as $data)
 {

diff --git a/ext/pdo/tests/pdo_014.phpt b/ext/pdo/tests/pdo_014.phpt
index 316b8447f22299236c7fcc28aefcff9f1d744dbe..2343ee48df2501f986e63c64a9e0d2976b42c713 100644 (file)
--- a/ext/pdo/tests/pdo_014.phpt
+++ b/ext/pdo/tests/pdo_014.phpt
@@ -28,7 +28,7 @@ class Test
        }
 }
 
-$stmt = $db->query($SELECT, PDO_FETCH_CLASS, 'Test', array('WOW'));
+$stmt = $db->query($SELECT, PDO::FETCH_CLASS, 'Test', array('WOW'));
 
 $it = new IteratorIterator($stmt); /* check if we can convert that thing */
 
@@ -48,7 +48,7 @@ class PDOStatementAggregate extends PDOStatement implements IteratorAggregate
        private function __construct()
        {
                echo __METHOD__ . "\n";
-               $this->setFetchMode(PDO_FETCH_NUM);   
+               $this->setFetchMode(PDO::FETCH_NUM);   
                /* default fetch mode is BOTH, so we see if the ctor can overwrite that */
        }
 
@@ -60,7 +60,7 @@ class PDOStatementAggregate extends PDOStatement implements IteratorAggregate
        }
 }
 
-$stmt = $db->prepare($SELECT, array(PDO_ATTR_STATEMENT_CLASS=>array('PDOStatementAggregate')));
+$stmt = $db->prepare($SELECT, array(PDO::ATTR_STATEMENT_CLASS=>array('PDOStatementAggregate')));
 
 foreach($stmt as $data)
 {

diff --git a/ext/pdo/tests/pdo_015.phpt b/ext/pdo/tests/pdo_015.phpt
index 7a00a77acbe2c85b36378db31dcfb6cc3f132f51..cb3addd4738d1476dbad5baa0f5e35cc8cb6f89e 100644 (file)
--- a/ext/pdo/tests/pdo_015.phpt
+++ b/ext/pdo/tests/pdo_015.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_COLUMN
+PDO Common: PDO::FETCH_COLUMN
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -21,22 +21,22 @@ $select1 = $db->prepare('SELECT id, val, val2 FROM test');
 $select2 = $db->prepare('SELECT val, val2 FROM test');
 
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_COLUMN));
+var_dump($select1->fetchAll(PDO::FETCH_COLUMN));
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_COLUMN, 2));
+var_dump($select1->fetchAll(PDO::FETCH_COLUMN, 2));
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_GROUP));
+var_dump($select1->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP));
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE));
+var_dump($select1->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE));
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE, 0));
+var_dump($select1->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE, 0));
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE, 1));
+var_dump($select1->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE, 1));
 $select1->execute();
-var_dump($select1->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE, 2));
+var_dump($select1->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE, 2));
 
 $select2->execute();
-var_dump($select2->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_GROUP));
+var_dump($select2->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP));
 
 ?>
 --EXPECT--

diff --git a/ext/pdo/tests/pdo_016.phpt b/ext/pdo/tests/pdo_016.phpt
index 9b7d1684200703353a6960e7a9c14d7ecb5fc107..1e1744ce59cbc4611a4ac2f9d613f183e058403e 100644 (file)
--- a/ext/pdo/tests/pdo_016.phpt
+++ b/ext/pdo/tests/pdo_016.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_BOUND
+PDO Common: PDO::FETCH_BOUND
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -26,7 +26,7 @@ var_dump($stmt1->fetchColumn());
 $stmt1 = null;
 
 $stmt2->execute();
-$cont = $stmt2->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE);
+$cont = $stmt2->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE);
 var_dump($cont);
 
 echo "===WHILE===\n";
@@ -35,7 +35,7 @@ $stmt2->bindColumn('idx', $idx);
 $stmt2->bindColumn('txt', $txt);
 $stmt2->execute();
 
-while($stmt2->fetch(PDO_FETCH_BOUND)) {
+while($stmt2->fetch(PDO::FETCH_BOUND)) {
        var_dump(array($idx=>$txt));
 }
 
@@ -57,7 +57,7 @@ foreach($cont as $idx => $txt)
                 * after execute() has been called at least once */
                $stmt3->bindColumn('txt', $col1);
        }
-       var_dump($stmt3->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt3->fetch(PDO::FETCH_BOUND));
        $stmt3->closeCursor();
 
        var_dump($stmt4->execute());
@@ -66,7 +66,7 @@ foreach($cont as $idx => $txt)
                 * after execute() has been called at least once */
                $stmt4->bindColumn('idx', $col2);
        }
-       var_dump($stmt4->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt4->fetch(PDO::FETCH_BOUND));
        $stmt4->closeCursor();
        var_dump(array($col2=>$col1));
 }
@@ -79,11 +79,11 @@ foreach($cont as $idx => $txt)
 {
        var_dump(array($idx=>$txt));
        var_dump($stmt3->execute());
-       var_dump($stmt3->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt3->fetch(PDO::FETCH_BOUND));
        $stmt3->closeCursor();
        var_dump($col1);
        var_dump($stmt4->execute());
-       var_dump($stmt4->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt4->fetch(PDO::FETCH_BOUND));
        $stmt4->closeCursor();
        var_dump($col1);
 }
@@ -94,7 +94,7 @@ $stmt2->bindColumn('idx', $col1);
 $stmt2->bindColumn('txt', $col1);
 $stmt2->execute();
 
-while($stmt2->fetch(PDO_FETCH_BOUND))
+while($stmt2->fetch(PDO::FETCH_BOUND))
 {
        var_dump($col1);
 }

diff --git a/ext/pdo/tests/pdo_016a.phpt b/ext/pdo/tests/pdo_016a.phpt
index 0303ea8ce72f0b7185ad24434455c9c1f087bf11..699ddea7f8755e77b72f63dacead5184b4decc22 100755 (executable)
--- a/ext/pdo/tests/pdo_016a.phpt
+++ b/ext/pdo/tests/pdo_016a.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_BOUND w/o :
+PDO Common: PDO::FETCH_BOUND w/o :
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -26,7 +26,7 @@ var_dump($stmt1->fetchColumn());
 $stmt1 = null;
 
 $stmt2->execute();
-$cont = $stmt2->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE);
+$cont = $stmt2->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE);
 var_dump($cont);
 
 echo "===WHILE===\n";
@@ -35,7 +35,7 @@ $stmt2->bindColumn('idx', $idx);
 $stmt2->bindColumn('txt', $txt);
 $stmt2->execute();
 
-while($stmt2->fetch(PDO_FETCH_BOUND)) {
+while($stmt2->fetch(PDO::FETCH_BOUND)) {
        var_dump(array($idx=>$txt));
 }
 
@@ -57,7 +57,7 @@ foreach($cont as $idx => $txt)
                 * after execute() has been called at least once */
                $stmt3->bindColumn('txt', $col1);
        }
-       var_dump($stmt3->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt3->fetch(PDO::FETCH_BOUND));
        $stmt3->closeCursor();
 
        var_dump($stmt4->execute());
@@ -66,7 +66,7 @@ foreach($cont as $idx => $txt)
                 * after execute() has been called at least once */
                $stmt4->bindColumn('idx', $col2);
        }
-       var_dump($stmt4->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt4->fetch(PDO::FETCH_BOUND));
        $stmt4->closeCursor();
        var_dump(array($col2=>$col1));
 }
@@ -79,11 +79,11 @@ foreach($cont as $idx => $txt)
 {
        var_dump(array($idx=>$txt));
        var_dump($stmt3->execute());
-       var_dump($stmt3->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt3->fetch(PDO::FETCH_BOUND));
        $stmt3->closeCursor();
        var_dump($col1);
        var_dump($stmt4->execute());
-       var_dump($stmt4->fetch(PDO_FETCH_BOUND));
+       var_dump($stmt4->fetch(PDO::FETCH_BOUND));
        $stmt4->closeCursor();
        var_dump($col1);
 }
@@ -94,7 +94,7 @@ $stmt2->bindColumn('idx', $col1);
 $stmt2->bindColumn('txt', $col1);
 $stmt2->execute();
 
-while($stmt2->fetch(PDO_FETCH_BOUND))
+while($stmt2->fetch(PDO::FETCH_BOUND))
 {
        var_dump($col1);
 }

diff --git a/ext/pdo/tests/pdo_017.phpt b/ext/pdo/tests/pdo_017.phpt
index def132e5692e38eaf0d1eb6e843bf998fda63a49..bb35bd8aca6b574f77b8e6921dc653b32c52390a 100644 (file)
--- a/ext/pdo/tests/pdo_017.phpt
+++ b/ext/pdo/tests/pdo_017.phpt
@@ -15,7 +15,7 @@ try {
   die('skip no working transactions: ' . $e->getMessage());
 }
 
-if ($db->getAttribute(PDO_ATTR_DRIVER_NAME) == 'mysql') {
+if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
        if (false === PDOTest::detect_transactional_mysql_engine($db)) {
                die('skip your mysql configuration does not support working transactions');
        }
@@ -26,7 +26,7 @@ if ($db->getAttribute(PDO_ATTR_DRIVER_NAME) == 'mysql') {
 require getenv('REDIR_TEST_DIR') . 'pdo_test.inc';
 $db = PDOTest::factory();
 
-if ($db->getAttribute(PDO_ATTR_DRIVER_NAME) == 'mysql') {
+if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
        $suf = ' Type=' . PDOTest::detect_transactional_mysql_engine($db);
 } else {
        $suf = '';

diff --git a/ext/pdo/tests/pdo_018.phpt b/ext/pdo/tests/pdo_018.phpt
index ad6cea8cd839bde0e18b961622ba6ac41e5b3b49..b3cb37811088c0508559b14c7c28ee1b6702f9c0 100644 (file)
--- a/ext/pdo/tests/pdo_018.phpt
+++ b/ext/pdo/tests/pdo_018.phpt
@@ -72,10 +72,10 @@ $db->exec('INSERT INTO classtypes VALUES(1, \'TestBase\')');
 $db->exec('INSERT INTO classtypes VALUES(2, \'TestDerived\')'); 
 $db->exec('CREATE TABLE test(id int NOT NULL PRIMARY KEY, classtype int NULL, val VARCHAR(255))');
 
-$db->setAttribute(PDO_ATTR_ERRMODE, PDO_ERRMODE_EXCEPTION);
+$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 
 var_dump($db->query('SELECT COUNT(*) FROM classtypes')->fetchColumn());
-var_dump($db->query('SELECT id, name FROM classtypes ORDER by id')->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE));
+var_dump($db->query('SELECT id, name FROM classtypes ORDER by id')->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE));
 
 $objs = array();
 $objs[0] = new stdClass;
@@ -94,7 +94,7 @@ foreach($objs as $obj)
        $ctype = NULL; /* set default for non stored class name */
        $stmt->execute();
        $stmt->bindColumn('id', $ctype);
-       $stmt->fetch(PDO_FETCH_BOUND);
+       $stmt->fetch(PDO::FETCH_BOUND);
        $ctypes[$cname] = $ctype;
 }
 
@@ -126,12 +126,12 @@ foreach($objs as $idx => $obj)
 unset($stmt);
 
 echo "===DATA===\n";
-var_dump($db->query('SELECT test.val FROM test')->fetchAll(PDO_FETCH_COLUMN));
+var_dump($db->query('SELECT test.val FROM test')->fetchAll(PDO::FETCH_COLUMN));
 
 echo "===FAILURE===\n";
 try
 {
-       $db->query('SELECT classtypes.name AS name, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id')->fetchAll(PDO_FETCH_CLASS|PDO_FETCH_CLASSTYPE|PDO_FETCH_SERIALIZE, 'TestLeaf', array());
+       $db->query('SELECT classtypes.name AS name, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id')->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_CLASSTYPE|PDO::FETCH_SERIALIZE, 'TestLeaf', array());
 }
 catch (PDOException $e)
 {
@@ -146,11 +146,11 @@ echo "===DATABASE===\n";
 $stmt = $db->prepare('SELECT classtypes.name AS name, test.val AS val FROM test LEFT JOIN classtypes ON test.classtype=classtypes.id WHERE (classtypes.id IS NULL OR classtypes.id > 0)');
 
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_ASSOC));
+var_dump($stmt->fetchAll(PDO::FETCH_ASSOC));
 
 echo "===FETCHCLASS===\n";
 $stmt->execute();
-var_dump($stmt->fetchAll(PDO_FETCH_CLASS|PDO_FETCH_CLASSTYPE|PDO_FETCH_SERIALIZE, 'TestLeaf'));
+var_dump($stmt->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_CLASSTYPE|PDO::FETCH_SERIALIZE, 'TestLeaf'));
 
 
 ?>

diff --git a/ext/pdo/tests/pdo_019.phpt b/ext/pdo/tests/pdo_019.phpt
index 3a4652a3e72b5e517afe4107ea6f283493c61f8d..35a20f07ae9d1084bdb074ea6790b9c7065c4659 100644 (file)
--- a/ext/pdo/tests/pdo_019.phpt
+++ b/ext/pdo/tests/pdo_019.phpt
@@ -25,7 +25,7 @@ var_dump($db->query('SELECT COUNT(*) FROM test')->fetchColumn());
 $stmt = $db->prepare('SELECT idx, txt FROM test ORDER by idx');
 
 $stmt->execute();
-$cont = $stmt->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE);
+$cont = $stmt->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE);
 var_dump($cont);
 
 echo "===WHILE===\n";
@@ -34,7 +34,7 @@ $stmt->bindColumn('idx', $idx);
 $stmt->bindColumn('txt', $txt);
 $stmt->execute();
 
-while($stmt->fetch(PDO_FETCH_BOUND)) {
+while($stmt->fetch(PDO::FETCH_BOUND)) {
        var_dump(array($idx=>$txt));
 }
 

diff --git a/ext/pdo/tests/pdo_023.phpt b/ext/pdo/tests/pdo_023.phpt
index 109781e23a4726e3816a673a9339fbdc1d636eba..c2108ed3a461c47ed6436d82918f1b66f4e7cc9f 100644 (file)
--- a/ext/pdo/tests/pdo_023.phpt
+++ b/ext/pdo/tests/pdo_023.phpt
@@ -49,7 +49,7 @@ class PDODatabaseX extends PDO
     function query($sql)
     {
        echo __METHOD__ . "()\n";
-       $stmt = parent::prepare($sql, array(PDO_ATTR_STATEMENT_CLASS=>array('PDOStatementx')));
+       $stmt = parent::prepare($sql, array(PDO::ATTR_STATEMENT_CLASS=>array('PDOStatementx')));
        $stmt->execute();
        return $stmt;
     }
@@ -66,7 +66,7 @@ $db->query('INSERT INTO test VALUES(1, \'B\')');
 
 $stmt = $db->query('SELECT val, id FROM test');
 var_dump($stmt);
-var_dump($stmt->fetchAll(PDO_FETCH_COLUMN|PDO_FETCH_UNIQUE));
+var_dump($stmt->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_UNIQUE));
 
 $stmt = NULL;
 $db = NULL;

diff --git a/ext/pdo/tests/pdo_025.phpt b/ext/pdo/tests/pdo_025.phpt
index b97db84991f430744dd1041883b14c8564307496..8a0d72a5b1a6b7d006db0d2b9c1859747701cf96 100644 (file)
--- a/ext/pdo/tests/pdo_025.phpt
+++ b/ext/pdo/tests/pdo_025.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_INTO
+PDO Common: PDO::FETCH_INTO
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -36,7 +36,7 @@ class Test {
 }
 
 $stmt = $db->prepare('SELECT * FROM test');
-$stmt->setFetchMode(PDO_FETCH_INTO, new Test);
+$stmt->setFetchMode(PDO::FETCH_INTO, new Test);
 $stmt->execute();
 
 foreach($stmt as $obj) {
@@ -50,7 +50,7 @@ class Fail {
        public $val, $val2;
 }
 
-$stmt->setFetchMode(PDO_FETCH_INTO, new Fail);
+$stmt->setFetchMode(PDO::FETCH_INTO, new Fail);
 $stmt->execute();
 
 foreach($stmt as $obj) {

diff --git a/ext/pdo/tests/pdo_026.phpt b/ext/pdo/tests/pdo_026.phpt
index e0a4a7ea554ed1c244366e14aa9d0a9f6c556a0e..aa07034c7214a2a3e95a2408773cce83e16133a2 100644 (file)
--- a/ext/pdo/tests/pdo_026.phpt
+++ b/ext/pdo/tests/pdo_026.phpt
@@ -44,8 +44,8 @@ class PDODatabase extends PDO
     function query($sql)
     {
        echo __METHOD__ . "()\n";
-       $stmt = $this->prepare($sql, array(PDO_ATTR_STATEMENT_CLASS=>array('PDOStatementx', array($this))));
-       $stmt->setFetchMode(PDO_FETCH_ASSOC);
+       $stmt = $this->prepare($sql, array(PDO::ATTR_STATEMENT_CLASS=>array('PDOStatementx', array($this))));
+       $stmt->setFetchMode(PDO::FETCH_ASSOC);
        $stmt->execute();
        return $stmt;
     }

diff --git a/ext/pdo/tests/pdo_027.phpt b/ext/pdo/tests/pdo_027.phpt
index 468aeedc62ddbe72e19a2af3a4f11014912a92a6..226b4670aa932312f3d54ee61a6c378c29ca2496 100644 (file)
--- a/ext/pdo/tests/pdo_027.phpt
+++ b/ext/pdo/tests/pdo_027.phpt
@@ -1,5 +1,5 @@
 --TEST--
-PDO Common: PDO_FETCH_LAZY
+PDO Common: PDO::FETCH_LAZY
 --SKIPIF--
 <?php # vim:ft=php
 if (!extension_loaded('pdo')) die('skip');
@@ -17,7 +17,7 @@ $db->exec('create table test (id int, name varchar(10) NULL)');
 $db->exec("INSERT INTO test (id,name) VALUES(1,'test1')");
 $db->exec("INSERT INTO test (id,name) VALUES(2,'test2')");
 
-foreach ($db->query("SELECT * FROM test", PDO_FETCH_LAZY) as $v) {
+foreach ($db->query("SELECT * FROM test", PDO::FETCH_LAZY) as $v) {
        echo "lazy: " . $v->id.$v->name."\n";
 }
 echo "End\n";

diff --git a/ext/pdo/tests/pdo_test.inc b/ext/pdo/tests/pdo_test.inc
index 2498d43f58025ad9ad169d77b70868b32dbdeb90..79df2baa29c8f949151d490fa3c26167436da2f3 100644 (file)
--- a/ext/pdo/tests/pdo_test.inc
+++ b/ext/pdo/tests/pdo_test.inc
@@ -30,9 +30,9 @@ class PDOTest {
                        $db->exec("DROP TABLE $table");
                }
                
-               $db->setAttribute(PDO_ATTR_ERRMODE, PDO_ERRMODE_WARNING);
-               $db->setAttribute(PDO_ATTR_CASE, PDO_CASE_LOWER);
-               $db->setAttribute(PDO_ATTR_STRINGIFY_FETCHES, true);
+               $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
+               $db->setAttribute(PDO::ATTR_CASE, PDO::CASE_LOWER);
+               $db->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
                return $db;
        }
 

diff --git a/ext/pdo_mysql/pdo_mysql.c b/ext/pdo_mysql/pdo_mysql.c
index a224e6e012bde8627382fa7cdef651556dc5a5a8..3f92c8dcb345f3ac7babaacf97281016ff58cffc 100755 (executable)
--- a/ext/pdo_mysql/pdo_mysql.c
+++ b/ext/pdo_mysql/pdo_mysql.c
@@ -75,7 +75,7 @@ ZEND_GET_MODULE(pdo_mysql)
  */
 PHP_MINIT_FUNCTION(pdo_mysql)
 {
-       REGISTER_LONG_CONSTANT("PDO_MYSQL_ATTR_USE_BUFFERED_QUERY", (long)PDO_MYSQL_ATTR_USE_BUFFERED_QUERY,    CONST_CS|CONST_PERSISTENT);
+       REGISTER_PDO_CONST_LONG("PDO_MYSQL_ATTR_USE_BUFFERED_QUERY", (long)PDO_MYSQL_ATTR_USE_BUFFERED_QUERY);
 
        return php_pdo_register_driver(&pdo_mysql_driver);
 }

diff --git a/ext/pdo_pgsql/pdo_pgsql.c b/ext/pdo_pgsql/pdo_pgsql.c
index 72cb4e724135bcc53bab3840b1b8aecca3098e65..2161296b03f9a299885776b42e7263d74aae5226 100644 (file)
--- a/ext/pdo_pgsql/pdo_pgsql.c
+++ b/ext/pdo_pgsql/pdo_pgsql.c
@@ -77,7 +77,7 @@ ZEND_GET_MODULE(pdo_pgsql)
 PHP_MINIT_FUNCTION(pdo_pgsql)
 {
        php_pdo_register_driver(&pdo_pgsql_driver);
-       REGISTER_LONG_CONSTANT("PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT", PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT, CONST_CS|CONST_PERSISTENT);
+       REGISTER_PDO_CONST_LONG("PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT", PDO_PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT);
        return SUCCESS;
 }
 /* }}} */

diff --git a/ext/pdo_pgsql/pgsql_statement.c b/ext/pdo_pgsql/pgsql_statement.c
index 88e0e4620fd46e299bc9f0d86e332807bbaacf25..e5889ef4d7ce26b56dc2b60495854f9ef02d8296 100644 (file)
--- a/ext/pdo_pgsql/pgsql_statement.c
+++ b/ext/pdo_pgsql/pgsql_statement.c
@@ -506,7 +506,9 @@ static int pgsql_stmt_get_column_meta(pdo_stmt_t *stmt, long colno, zval *return
 
 static int pdo_pgsql_stmt_cursor_closer(pdo_stmt_t *stmt TSRMLS_DC)
 {
+#if HAVE_PQPREPARE
        return 1;
+#endif
 }
 
 struct pdo_stmt_methods pgsql_stmt_methods = {