add support for pdo-pgsql in phpng refactoring

diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index 9f286a5ca679f870f350ffbd784a05da4c0c9a21..1a2aa39d94c40d7324581acdbdf3bc9d63344489 100644 (file)
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -402,7 +402,7 @@ options:
                        zval *attr_value;
                        ulong long_key;
                        zend_string *str_key = NULL;
-                       
+
                        ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(options), long_key, str_key, attr_value) {
                                if (str_key) {
                                        continue;
@@ -1529,6 +1529,18 @@ static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)
        //???pefree(dbh, dbh->is_persistent);
 }
 
+PDO_API void php_pdo_dbh_addref(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
+{
+       dbh->refcount++;
+}
+/* }}} */
+
+PDO_API void php_pdo_dbh_delref(pdo_dbh_t *dbh TSRMLS_DC) /* {{{ */
+{
+       dbh_free(dbh TSRMLS_CC);
+}
+/* }}} */
+
 static void pdo_dbh_free_storage(zend_object *std TSRMLS_DC)
 {
        pdo_dbh_t *dbh = php_pdo_dbh_fetch_object(std);

diff --git a/ext/pdo_pgsql/pgsql_driver.c b/ext/pdo_pgsql/pgsql_driver.c
index 24a5865c75428fd011701eeb2cd4a9f0fd0d84d6..48320d314859298a4f88f787685e5bd90c1156b5 100644 (file)
--- a/ext/pdo_pgsql/pgsql_driver.c
+++ b/ext/pdo_pgsql/pgsql_driver.c
@@ -380,17 +380,17 @@ static int pdo_pgsql_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value
 
        switch (attr) {
                case PDO_ATTR_CLIENT_VERSION:
-                       ZVAL_STRING(return_value, PG_VERSION, 1);
+                       ZVAL_STRING(return_value, PG_VERSION);
                        break;
 
                case PDO_ATTR_SERVER_VERSION:
                        if (PQprotocolVersion(H->server) >= 3) { /* PostgreSQL 7.4 or later */
-                               ZVAL_STRING(return_value, (char*)PQparameterStatus(H->server, "server_version"), 1);
+                               ZVAL_STRING(return_value, (char*)PQparameterStatus(H->server, "server_version"));
                        } else /* emulate above via a query */
                        {
                                PGresult *res = PQexec(H->server, "SELECT VERSION()");
                                if (res && PQresultStatus(res) == PGRES_TUPLES_OK) {
-                                       ZVAL_STRING(return_value, (char *)PQgetvalue(res, 0, 0), 1);
+                                       ZVAL_STRING(return_value, (char *)PQgetvalue(res, 0, 0));
                                }
 
                                if (res) {
@@ -402,48 +402,51 @@ static int pdo_pgsql_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_value
                case PDO_ATTR_CONNECTION_STATUS:
                        switch (PQstatus(H->server)) {
                                case CONNECTION_STARTED:
-                                       ZVAL_STRINGL(return_value, "Waiting for connection to be made.", sizeof("Waiting for connection to be made.")-1, 1);
+                                       ZVAL_STRINGL(return_value, "Waiting for connection to be made.", sizeof("Waiting for connection to be made.")-1);
                                        break;
 
                                case CONNECTION_MADE:
                                case CONNECTION_OK:
-                                       ZVAL_STRINGL(return_value, "Connection OK; waiting to send.", sizeof("Connection OK; waiting to send.")-1, 1);
+                                       ZVAL_STRINGL(return_value, "Connection OK; waiting to send.", sizeof("Connection OK; waiting to send.")-1);
                                        break;
 
                                case CONNECTION_AWAITING_RESPONSE:
-                                       ZVAL_STRINGL(return_value, "Waiting for a response from the server.", sizeof("Waiting for a response from the server.")-1, 1);
+                                       ZVAL_STRINGL(return_value, "Waiting for a response from the server.", sizeof("Waiting for a response from the server.")-1);
                                        break;
 
                                case CONNECTION_AUTH_OK:
-                                       ZVAL_STRINGL(return_value, "Received authentication; waiting for backend start-up to finish.", sizeof("Received authentication; waiting for backend start-up to finish.")-1, 1);
+                                       ZVAL_STRINGL(return_value, "Received authentication; waiting for backend start-up to finish.", sizeof("Received authentication; waiting for backend start-up to finish.")-1);
                                        break;
 #ifdef CONNECTION_SSL_STARTUP
                                case CONNECTION_SSL_STARTUP:
-                                       ZVAL_STRINGL(return_value, "Negotiating SSL encryption.", sizeof("Negotiating SSL encryption.")-1, 1);
+                                       ZVAL_STRINGL(return_value, "Negotiating SSL encryption.", sizeof("Negotiating SSL encryption.")-1);
                                        break;
 #endif
                                case CONNECTION_SETENV:
-                                       ZVAL_STRINGL(return_value, "Negotiating environment-driven parameter settings.", sizeof("Negotiating environment-driven parameter settings.")-1, 1);
+                                       ZVAL_STRINGL(return_value, "Negotiating environment-driven parameter settings.", sizeof("Negotiating environment-driven parameter settings.")-1);
                                        break;
 
                                case CONNECTION_BAD:
                                default:
-                                       ZVAL_STRINGL(return_value, "Bad connection.", sizeof("Bad connection.")-1, 1);
+                                       ZVAL_STRINGL(return_value, "Bad connection.", sizeof("Bad connection.")-1);
                                        break;
                        }
                        break;
 
                case PDO_ATTR_SERVER_INFO: {
                        int spid = PQbackendPID(H->server);
-                       char *tmp;
-                       spprintf(&tmp, 0,
-                               "PID: %d; Client Encoding: %s; Is Superuser: %s; Session Authorization: %s; Date Style: %s",
-                               spid,
-                               (char*)PQparameterStatus(H->server, "client_encoding"),
-                               (char*)PQparameterStatus(H->server, "is_superuser"),
-                               (char*)PQparameterStatus(H->server, "session_authorization"),
-                               (char*)PQparameterStatus(H->server, "DateStyle"));
-                       ZVAL_STRING(return_value, tmp, 0);
+
+                       
+                       zend_string *str_info =
+                               strpprintf(0,
+                                       "PID: %d; Client Encoding: %s; Is Superuser: %s; Session Authorization: %s; Date Style: %s",
+                                       spid,
+                                       (char*)PQparameterStatus(H->server, "client_encoding"),
+                                       (char*)PQparameterStatus(H->server, "is_superuser"),
+                                       (char*)PQparameterStatus(H->server, "session_authorization"),
+                                       (char*)PQparameterStatus(H->server, "DateStyle"));
+
+                       ZVAL_STR(return_value, str_info);
                }
                        break;
 
@@ -533,7 +536,7 @@ static PHP_METHOD(PDO, pgsqlCopyFromArray)
                RETURN_FALSE;
        }
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
        PDO_DBH_CLEAR_ERR();
 
@@ -564,33 +567,33 @@ static PHP_METHOD(PDO, pgsqlCopyFromArray)
        if (status == PGRES_COPY_IN && pgsql_result) {
                int command_failed = 0;
                int buffer_len = 0;
-               zval **tmp;
+               zval *tmp;
                HashPosition pos;
 
                PQclear(pgsql_result);
                zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(pg_rows), &pos);
-               while (zend_hash_get_current_data_ex(Z_ARRVAL_P(pg_rows), (void **) &tmp, &pos) == SUCCESS) {
+               while ((tmp = zend_hash_get_current_data_ex(Z_ARRVAL_P(pg_rows), &pos)) != NULL) {
                        int query_len;
                        convert_to_string_ex(tmp);
 
-                       if (buffer_len < Z_STRLEN_PP(tmp)) {
-                               buffer_len = Z_STRLEN_PP(tmp);
+                       if (buffer_len < Z_STRLEN_P(tmp)) {
+                               buffer_len = Z_STRLEN_P(tmp);
                                query = erealloc(query, buffer_len + 2); /* room for \n\0 */
                        }
-                       memcpy(query, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
-                       query_len = Z_STRLEN_PP(tmp);
+                       memcpy(query, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
+                       query_len = Z_STRLEN_P(tmp);
                        if (query[query_len - 1] != '\n') {
                                query[query_len++] = '\n';
                        }
                        query[query_len] = '\0';
                        if (PQputCopyData(H->server, query, query_len) != 1) {
-                               efree(query);
-                               pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, NULL);
+                               efree(query);
+                               pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, NULL);
                                PDO_HANDLE_DBH_ERR();
-                               RETURN_FALSE;
-                       }
+                               RETURN_FALSE;
+                       }
                        zend_hash_move_forward_ex(Z_ARRVAL_P(pg_rows), &pos);
-                }
+               }
                if (query) {
                        efree(query);
                }
@@ -641,7 +644,7 @@ static PHP_METHOD(PDO, pgsqlCopyFromFile)
        }
 
        /* Obtain db Handler */
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
        PDO_DBH_CLEAR_ERR();
 
@@ -741,7 +744,7 @@ static PHP_METHOD(PDO, pgsqlCopyToFile)
                return;
        }
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
        PDO_DBH_CLEAR_ERR();
 
@@ -834,7 +837,7 @@ static PHP_METHOD(PDO, pgsqlCopyToArray)
                return;
        }
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
        PDO_DBH_CLEAR_ERR();
 
@@ -899,7 +902,7 @@ static PHP_METHOD(PDO, pgsqlLOBCreate)
        pdo_pgsql_db_handle *H;
        Oid lfd;
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
        PDO_DBH_CLEAR_ERR();
 
@@ -907,9 +910,9 @@ static PHP_METHOD(PDO, pgsqlLOBCreate)
        lfd = lo_creat(H->server, INV_READ|INV_WRITE);
 
        if (lfd != InvalidOid) {
-               char *buf;
-               spprintf(&buf, 0, "%lu", (long) lfd);
-               RETURN_STRING(buf, 0);
+               zend_string *buf = strpprintf(0, "%lu", (long) lfd);
+
+               RETURN_STR(buf);
        }
 
        pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, NULL);
@@ -947,7 +950,7 @@ static PHP_METHOD(PDO, pgsqlLOBOpen)
                mode = INV_READ|INV_WRITE;
        }
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
        PDO_DBH_CLEAR_ERR();
 
@@ -990,7 +993,7 @@ static PHP_METHOD(PDO, pgsqlLOBUnlink)
                RETURN_FALSE;
        }
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
        PDO_DBH_CLEAR_ERR();
 
@@ -1021,7 +1024,7 @@ static PHP_METHOD(PDO, pgsqlGetNotify)
                RETURN_FALSE;
        }
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
 
        if (result_type == PDO_FETCH_USE_DEFAULT) {
@@ -1075,7 +1078,7 @@ static PHP_METHOD(PDO, pgsqlGetPid)
        pdo_dbh_t *dbh;
        pdo_pgsql_db_handle *H;
 
-       dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+       dbh = Z_PDO_DBH_P(getThis());
        PDO_CONSTRUCT_CHECK;
 
        H = (pdo_pgsql_db_handle *)dbh->driver_data;

diff --git a/ext/pdo_pgsql/pgsql_statement.c b/ext/pdo_pgsql/pgsql_statement.c
index c9c9e5c45022d80027ebdaf9d3d813958ae52a16..6cebb7d9f24a381ed4bbb2c76a0d656c00d2958f 100644 (file)
--- a/ext/pdo_pgsql/pgsql_statement.c
+++ b/ext/pdo_pgsql/pgsql_statement.c
@@ -255,16 +255,17 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
                        case PDO_PARAM_EVT_NORMALIZE:
                                /* decode name from $1, $2 into 0, 1 etc. */
                                if (param->name) {
-                                       if (param->name[0] == '$') {
-                                               param->paramno = atoi(param->name + 1);
+                                       if (param->name->val[0] == '$') {
+                                               param->paramno = atoi(param->name->val + 1);
                                        } else {
                                                /* resolve parameter name to rewritten name */
-                                               char *nameptr;
-                                               if (stmt->bound_param_map && SUCCESS == zend_hash_find(stmt->bound_param_map,
-                                                               param->name, param->namelen + 1, (void**)&nameptr)) {
-                                                       param->paramno = atoi(nameptr + 1) - 1;
+                                               zval *namevar;
+
+                                               if (stmt->bound_param_map && (namevar = zend_hash_find(stmt->bound_param_map,
+                                                               param->name)) != NULL) {
+                                                       param->paramno = atoi(Z_PTR_P(namevar) + 1) - 1;
                                                } else {
-                                                       pdo_raise_impl_error(stmt->dbh, stmt, "HY093", param->name TSRMLS_CC);
+                                                       pdo_raise_impl_error(stmt->dbh, stmt, "HY093", param->name->val TSRMLS_CC);
                                                        return 0;
                                                }
                                        }
@@ -303,7 +304,7 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
                                        }
 
                                        if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB &&
-                                                       Z_TYPE_P(param->parameter) == IS_RESOURCE) {
+                                                       Z_TYPE(param->parameter) == IS_RESOURCE) {
                                                php_stream *stm;
                                                php_stream_from_zval_no_verify(stm, &param->parameter);
                                                if (stm) {
@@ -325,12 +326,10 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
                                                                int len;
 
                                                                SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);
-                                                               Z_TYPE_P(param->parameter) = IS_STRING;
+                                                               Z_TYPE_INFO(param->parameter) = IS_STRING;
 
-                                                               if ((len = php_stream_copy_to_mem(stm, &Z_STRVAL_P(param->parameter), PHP_STREAM_COPY_ALL, 0)) > 0) {
-                                                                       Z_STRLEN_P(param->parameter) = len;
-                                                               } else {
-                                                                       ZVAL_EMPTY_STRING(param->parameter);
+                                                               if ((Z_STR(param->parameter) = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0)) == NULL) {
+                                                                       ZVAL_EMPTY_STRING(&param->parameter);
                                                                }
                                                        }
                                                } else {
@@ -341,18 +340,18 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
                                        }
 
                                        if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_NULL ||
-                                                       Z_TYPE_P(param->parameter) == IS_NULL) {
+                                                       Z_TYPE(param->parameter) == IS_NULL) {
                                                S->param_values[param->paramno] = NULL;
                                                S->param_lengths[param->paramno] = 0;
-                                       } else if (Z_TYPE_P(param->parameter) == IS_BOOL) {
-                                               S->param_values[param->paramno] = Z_BVAL_P(param->parameter) ? "t" : "f";
+                                       } else if (Z_TYPE(param->parameter) == IS_FALSE || Z_TYPE(param->parameter) == IS_TRUE) {
+                                               S->param_values[param->paramno] = Z_TYPE(param->parameter) == IS_TRUE ? "t" : "f";
                                                S->param_lengths[param->paramno] = 1;
                                                S->param_formats[param->paramno] = 0;
                                        } else {
                                                SEPARATE_ZVAL_IF_NOT_REF(&param->parameter);
-                                               convert_to_string(param->parameter);
-                                               S->param_values[param->paramno] = Z_STRVAL_P(param->parameter);
-                                               S->param_lengths[param->paramno] = Z_STRLEN_P(param->parameter);
+                                               convert_to_string_ex(&param->parameter);
+                                               S->param_values[param->paramno] = Z_STRVAL(param->parameter);
+                                               S->param_lengths[param->paramno] = Z_STRLEN(param->parameter);
                                                S->param_formats[param->paramno] = 0;
                                        }
 
@@ -371,7 +370,7 @@ static int pgsql_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_data *
                        ((param->param_type & PDO_PARAM_INPUT_OUTPUT) != PDO_PARAM_INPUT_OUTPUT)) {
                        SEPARATE_ZVAL(&param->parameter);
                        param->param_type = PDO_PARAM_STR;
-                       ZVAL_STRINGL(param->parameter, Z_BVAL_P(param->parameter) ? "t" : "f", 1, 1);
+                       ZVAL_STRINGL(&param->parameter, Z_TYPE(param->parameter) == IS_TRUE ? "t" : "f", 1);
                }
        }
        return 1;
@@ -450,11 +449,9 @@ static int pgsql_stmt_describe(pdo_stmt_t *stmt, int colno TSRMLS_DC)
                case OIDOID:
                        /* did the user bind the column as a LOB ? */
                        if (stmt->bound_columns && (
-                                       SUCCESS == zend_hash_index_find(stmt->bound_columns,
-                                               colno, (void**)&param) ||
-                                       SUCCESS == zend_hash_find(stmt->bound_columns,
-                                               cols[colno].name, cols[colno].namelen,
-                                               (void**)&param))) {
+                                       (param = zend_hash_index_find(stmt->bound_columns, colno)) != NULL ||
+                                       (param = zend_hash_str_find(stmt->bound_columns, cols[colno].name, cols[colno].namelen)) != NULL)) {
+
                                if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_LOB) {
                                        cols[colno].param_type = PDO_PARAM_LOB;
                                        break;