package.xml merge=touch
php_pq.h merge=touch
-.travis.yml merge=touch
*.phar binary
--- /dev/null
+# generated file; do not edit!
+
+name: ci
+on:
+ workflow_dispatch:
+ push:
+ pull_request:
+
+jobs:
+ old-matrix-0:
+ name: "old-matrix-0 (7.0)"
+ env:
+ PHP: "7.0"
+ enable_debug: "yes"
+ enable_maintainer_zts: "yes"
+ enable_json: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ old-matrix-1:
+ name: "old-matrix-1 (7.1)"
+ env:
+ PHP: "7.1"
+ enable_debug: "yes"
+ enable_maintainer_zts: "yes"
+ enable_json: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ old-matrix-2:
+ name: "old-matrix-2 (7.2)"
+ env:
+ PHP: "7.2"
+ enable_debug: "yes"
+ enable_maintainer_zts: "yes"
+ enable_json: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ old-matrix-3:
+ name: "old-matrix-3 (7.3)"
+ env:
+ PHP: "7.3"
+ enable_debug: "yes"
+ enable_maintainer_zts: "yes"
+ enable_json: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ old-matrix-4:
+ name: "old-matrix-4 (7.4)"
+ env:
+ PHP: "7.4"
+ enable_debug: "yes"
+ enable_maintainer_zts: "yes"
+ enable_json: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ old-matrix-5:
+ name: "old-matrix-5 (8.0)"
+ env:
+ PHP: "8.0"
+ enable_debug: "yes"
+ enable_maintainer_zts: "yes"
+ enable_json: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ old-matrix-6:
+ name: "old-matrix-6 (8.1)"
+ env:
+ PHP: "8.1"
+ enable_debug: "yes"
+ enable_maintainer_zts: "yes"
+ enable_json: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ next-0:
+ name: "next-0 (master)"
+ continue-on-error: true
+ env:
+ PHP: "master"
+ enable_debug: "yes"
+ enable_zts: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ cur-dbg-zts-0:
+ name: "cur-dbg-zts-0 (8.2)"
+ env:
+ PHP: "8.2"
+ enable_debug: "yes"
+ enable_zts: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ cur-dbg-zts-1:
+ name: "cur-dbg-zts-1 (8.2)"
+ env:
+ PHP: "8.2"
+ enable_debug: "no"
+ enable_zts: "yes"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ cur-dbg-zts-2:
+ name: "cur-dbg-zts-2 (8.2)"
+ env:
+ PHP: "8.2"
+ enable_debug: "yes"
+ enable_zts: "no"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ cur-dbg-zts-3:
+ name: "cur-dbg-zts-3 (8.2)"
+ env:
+ PHP: "8.2"
+ enable_debug: "no"
+ enable_zts: "no"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+
+ cur-cov-0:
+ name: "cur-cov-0 (8.2)"
+ env:
+ CFLAGS: "-O0 -g --coverage"
+ CXXFLAGS: "-O0 -g --coverage"
+ PHP: "8.2"
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+ - name: Coverage
+ if: success()
+ run: |
+ cd src/.libs
+ bash <(curl -s https://codecov.io/bash) -X xcode -X coveragepy
+
*~
/*.tgz
.deps
+*.dep
+*.o
*.lo
*.la
/config.[^m]*
-[submodule "travis-pecl"]
- path = travis/pecl
- url = https://github.com/m6w6/travis-pecl.git
- branch = master
+[submodule "scripts/ci"]
+ path = scripts/ci
+ url = https://github.com/m6w6/pecl-ci.git
+++ /dev/null
-# autogenerated file; do not edit
-language: c
-sudo: false
-
-addons:
- postgresql: 9.4
- apt:
- packages:
- - php-cli
- - php-pear
- - valgrind
-
-cache:
- directories:
- - $HOME/cache
-
-before_cache:
- - find $HOME/cache -name '*.gcda' -o -name '*.gcno' -delete
-
-env:
- global:
- - PQ_DSN="postgres://postgres@localhost/test"
- matrix:
- - PHP=7.0 enable_debug=yes enable_maintainer_zts=yes enable_json=yes
- - PHP=7.1 enable_debug=yes enable_maintainer_zts=yes enable_json=yes
- - PHP=7.2 enable_debug=yes enable_maintainer_zts=yes enable_json=yes
- - PHP=7.3 enable_debug=yes enable_maintainer_zts=yes enable_json=yes
- - PHP=master enable_debug=yes enable_maintainer_zts=yes enable_json=yes
- - PHP=7.4 enable_json=no
- - PHP=7.4 enable_json=yes enable_debug=no enable_maintainer_zts=no
- - PHP=7.4 enable_json=yes enable_debug=yes enable_maintainer_zts=no
- - PHP=7.4 enable_json=yes enable_debug=no enable_maintainer_zts=yes
- - PHP=7.4 enable_json=yes enable_debug=yes enable_maintainer_zts=yes
- - PHP=7.4 enable_json=yes CFLAGS='-O0 -g --coverage' CXXFLAGS='-O0 -g --coverage'
-
-matrix:
- fast_finish: true
- allow_failures:
- - env: PHP=master enable_debug=yes enable_maintainer_zts=yes enable_json=yes
-
-install:
- - |
- if test "$PHP" = master; then \
- make -f travis/pecl/Makefile reconf; \
- make -f travis/pecl/Makefile pecl-rm pecl-clean PECL=raphf:raphf:2.0.0; \
- fi
- - make -f travis/pecl/Makefile php || make -f travis/pecl/Makefile clean php
- - make -f travis/pecl/Makefile pecl PECL=raphf:raphf:2.0.0
-
-before_script:
- - psql -U postgres -c "CREATE DATABASE test"
-
-script:
- - make -f travis/pecl/Makefile ext PECL=pq
- - make -f travis/pecl/Makefile test
-
-after_success:
- - test -n "$CFLAGS" && cd src/.libs && bash <(curl -s https://codecov.io/bash) -X xcode -X coveragepy
# pecl/pq
-[](https://travis-ci.org/m6w6/ext-pq)
+[](https://github.com/m6w6/ext-pq/actions?query=branch%3Amaster+workflow%3Aci)
+[](https://codecov.io/gh/m6w6/ext-pq)
## About:
### Highlights:
-* Nearly 100% support for [asynchronous usage](https://mdref.m6w6.name/pq/Connection/:+Asynchronous+Usage).
-* Extended [type support by pg_type](https://mdref.m6w6.name/pq/Types/:+Overview).
+* Nearly 100% support for [asynchronous usage](https://mdref.m6w6.name/pq/Connection/:%20Asynchronous%20Usage).
+* Extended [type support by pg_type](https://mdref.m6w6.name/pq/Types/:%20Overview).
* Fetching simple [multi-dimensional array maps](https://mdref.m6w6.name/pq/Result/map).
* Working [Gateway implementation](https://github.com/m6w6/pq-gateway).
Known issues are listed in [BUGS](./BUGS) and future ideas can be found in [TODO](./TODO).
-## Installing
+## Install
### PECL
if test "$PHP_PQ" != "yes"; then
SEARCH_PATH="$PHP_PQ $SEARCH_PATH"
fi
-
+
AC_MSG_CHECKING(for pg_config)
for i in $SEARCH_PATH; do
if test -x "$i/bin/pg_config"; then
break
fi
done
-
+
if test -z "$PG_CONFIG"; then
AC_PATH_PROG(PG_CONFIG, pg_config, no)
fi
-
+
AC_MSG_RESULT($PG_CONFIG)
-
+
if test "$PG_CONFIG" = "no"; then
AC_MSG_ERROR(could not find a usable pg_config in $SEARCH_PATH)
else
if test "$PHP_PQ" != "yes" -a "$PHP_PQ/bin/pg_config" != "$PG_CONFIG"; then
AC_MSG_WARN(Found pg_config is not in $PHP_PQ)
fi
-
+
AC_MSG_CHECKING(for PostgreSQL version)
PQ_VERSION=$($PG_CONFIG --version | $SED 's/PostgreSQL //')
AC_MSG_RESULT($PQ_VERSION)
AC_DEFINE_UNQUOTED(PHP_PQ_LIBVERSION, "$PQ_VERSION", [ ])
fi
-
+
PQ_INCDIR=$($PG_CONFIG --includedir)
PQ_LIBDIR=$($PG_CONFIG --libdir)
fi
PQ_CHECK_CONST(PGRES_SINGLE_TUPLE)
PQ_CHECK_CONST(PGRES_COPY_BOTH)
+ PQ_CHECK_CONST(CONNECTION_CHECK_WRITABLE)
+ PQ_CHECK_CONST(CONNECTION_CONSUME)
+ PQ_CHECK_CONST(CONNECTION_GSS_STARTUP)
dnl
dnl PQ_CHECK_FUNC(sym, fail-hard)
dnl
AC_DEFUN([PQ_CHECK_FUNC], [
+ PQ_SYM=$1
FAIL_HARD=$2
-
+ save_LIBS="$LIBS"
+ LIBS=
PHP_CHECK_LIBRARY(pq, $1, [
AC_DEFINE([HAVE_]translit($1,a-z,A-Z), 1, Have $1)
], [
if test -n "$FAIL_HARD"; then
- if "$FAIL_HARD"; then
- AC_MSG_ERROR(could not find $PQ_SYM in -lpq)
+ if $FAIL_HARD; then
+ AC_MSG_ERROR(could not find $PQ_SYM in -lpq -L$PQ_LIBDIR)
fi
fi
], [
-L$PQ_LIBDIR
])
+ LIBS="$save_LIBS"
])
PQ_CHECK_FUNC(PQregisterEventProc, true)
PHP_SUBST(PQ_SHARED_LIBADD)
PQ_CHECK_FUNC(PQlibVersion)
+ PQ_CHECK_FUNC(PQprotocolVersion)
+ PQ_CHECK_FUNC(PQserverVersion)
PQ_CHECK_FUNC(PQconninfo)
PQ_CHECK_FUNC(PQsetSingleRowMode)
AC_MSG_ERROR([Please install pecl/raphf and activate extension=raphf.$SHLIB_DL_SUFFIX_NAME in your php.ini])
])
PHP_ADD_EXTENSION_DEP(pq, raphf, true)
- PQ_HAVE_PHP_EXT([json], [
- AC_MSG_CHECKING([for php_json.h])
- PQ_EXT_JSON_INCDIR=
- for i in `echo $INCLUDES | $SED -e's/-I//g'` $abs_srcdir ../json ../jsonc ../jsond; do
- if test -d $i; then
- if test -f $i/php_json.h; then
- PQ_EXT_JSON_INCDIR=$i
- break
- elif test -f $i/ext/json/php_json.h; then
- PQ_EXT_JSON_INCDIR=$i/ext/json
- break
- fi
- fi
- done
- if test "x$PQ_EXT_JSON_INCDIR" = "x"; then
- AC_MSG_ERROR([not found])
- else
- AC_MSG_RESULT([$PQ_EXT_JSON_INCDIR])
- AC_DEFINE([PHP_PQ_HAVE_PHP_JSON_H], [1], [Have ext/json support])
- PHP_ADD_INCLUDE([$PQ_EXT_JSON_INCDIR])
- fi
- ])
fi
<email>remi@php.net</email>
<active>yes</active>
</developer>
- <date>2020-01-18</date>
+ <date>2024-02-05</date>
<version>
- <release>2.1.6</release>
+ <release>2.2.3</release>
<api>2.1.0</api>
</version>
<stability>
</stability>
<license uri="http://copyfree.org/content/standard/licenses/2bsd/license.txt">BSD-2-Clause</license>
<notes><![CDATA[
- * Fix PgSQL-12 compatibility
- * Fix PHP-7.4 compatibility
- * Fix empty arrays parsing (Dmitry Simushev)
+ * Fix incompatible pointer types (32-bit) (see hg issue #52)
]]></notes>
<contents>
<dir name="/">
<file role="test" name="async007.phpt" />
<file role="test" name="async008.phpt" />
<file role="test" name="async009.phpt" />
+ <file role="test" name="async010.phpt" />
<file role="test" name="basic001.phpt" />
<file role="test" name="basic002.phpt" />
+ <file role="test" name="basic003.phpt" />
<file role="test" name="bound002.phpt" />
<file role="test" name="callback001.phpt" />
<file role="test" name="callback002.phpt" />
<file role="test" name="flush001.phpt" />
<file role="test" name="gh-issue015_listeners.phpt" />
<file role="test" name="gh-issue015_statements.phpt" />
+ <file role="test" name="gh-issue047_jsonb.phpt" />
<file role="test" name="info001.phpt" />
<file role="test" name="info002.phpt" />
<file role="test" name="lob001.phpt" />
<min>7.0.0</min>
</php>
<pearinstaller>
- <min>1.4.0</min>
+ <min>1.10.0</min>
</pearinstaller>
<package>
<name>raphf</name>
<channel>pecl.php.net</channel>
- <min>2.0.0dev</min>
+ <min>2.0.0</min>
<providesextension>raphf</providesextension>
</package>
</required>
#ifndef PHP_PQ_H
#define PHP_PQ_H
-#define PHP_PQ_VERSION "2.1.6"
+#define PHP_PQ_VERSION "2.2.3"
#ifdef PHP_WIN32
# define PHP_PQ_API __declspec(dllexport)
--- /dev/null
+Subproject commit 547c8e89e38d6e899914c05ddf6598669bd16532
--- /dev/null
+#!/usr/bin/env php
+<?php echo "# generated file; do not edit!\n"; ?>
+
+name: ci
+on:
+ workflow_dispatch:
+ push:
+ pull_request:
+
+jobs:
+<?php
+
+$gen = include __DIR__ . "/ci/gen-matrix.php";
+$cur = "8.2";
+$job = $gen->github([
+"old-matrix" => [
+ "PHP" => ["7.0", "7.1", "7.2", "7.3", "7.4", "8.0", "8.1"],
+ "enable_debug" => "yes",
+ "enable_maintainer_zts" => "yes",
+ "enable_json" => "yes",
+],
+"next" => [
+ "PHP" => ["master"],
+ "enable_debug" => "yes",
+ "enable_zts" => "yes",
+],
+"cur-dbg-zts" => [
+ "PHP" => $cur,
+ "enable_debug",
+ "enable_zts",
+],
+"cur-cov" => [
+ "CFLAGS" => "-O0 -g --coverage",
+ "CXXFLAGS" => "-O0 -g --coverage",
+ "PHP" => $cur,
+]]);
+foreach ($job as $id => $env) {
+ printf(" %s:\n", $id);
+ printf(" name: \"%s (%s)\"\n", $id, $env["PHP"]);
+ if ($env["PHP"] == "master") {
+ printf(" continue-on-error: true\n");
+ }
+ printf(" env:\n");
+ foreach ($env as $key => $val) {
+ printf(" %s: \"%s\"\n", $key, $val);
+ }
+?>
+ PQ_DSN: "postgres:///runner"
+ runs-on: ubuntu-22.04
+ steps:
+ - uses: actions/checkout@v2
+ with:
+ submodules: true
+ - name: Install
+ run: |
+ sudo apt-get install -y \
+ php-cli \
+ php-pear \
+ libpq-dev \
+ re2c
+ - name: Prepare
+ run: |
+ make -f scripts/ci/Makefile php || make -f scripts/ci/Makefile clean php
+ make -f scripts/ci/Makefile pecl PECL=m6w6/ext-raphf.git:raphf:master
+ - name: Build
+ run: |
+ make -f scripts/ci/Makefile ext PECL=pq
+ - name: Prepare Test
+ run: |
+ sudo systemctl start postgresql
+ sudo -u postgres createuser --login runner
+ sudo -u postgres createdb -O runner runner
+ - name: Test
+ run: |
+ make -f scripts/ci/Makefile test
+<?php if (isset($env["CFLAGS"]) && strpos($env["CFLAGS"], "--coverage") != false) : ?>
+ - name: Coverage
+ if: success()
+ run: |
+ cd src/.libs
+ bash <(curl -s https://codecov.io/bash) -X xcode -X coveragepy
+<?php endif; ?>
+
+<?php
+}
+++ /dev/null
-#!/usr/bin/env php
-# autogenerated file; do not edit
-language: c
-sudo: false
-
-addons:
- postgresql: 9.4
- apt:
- packages:
- - php-cli
- - php-pear
- - valgrind
-
-cache:
- directories:
- - $HOME/cache
-
-before_cache:
- - find $HOME/cache -name '*.gcda' -o -name '*.gcno' -delete
-
-env:
- global:
- - PQ_DSN="postgres://postgres@localhost/test"
- matrix:
-<?php
-
-$gen = include "./travis/pecl/gen-matrix.php";
-$cur = "7.4";
-$env = $gen([
- "PHP" => ["7.0", "7.1", "7.2", "7.3", "master"],
- "enable_debug" => "yes",
- "enable_maintainer_zts" => "yes",
- "enable_json" => "yes",
-], [
- "PHP" => $cur,
- "enable_json" => "no",
-], [
- "PHP" => $cur,
- "enable_json" => "yes",
- "enable_debug",
- "enable_maintainer_zts"
-], [
- "PHP" => $cur,
- "enable_json" => "yes",
- "CFLAGS" => "'-O0 -g --coverage'",
- "CXXFLAGS" => "'-O0 -g --coverage'",
-]);
-
-foreach ($env as $g) {
- foreach ($g as $e) {
- printf(" - %s\n", $e);
- }
-}
-?>
-
-matrix:
- fast_finish: true
- allow_failures:
-<?php
-$allow_failures = array_merge( ... array_map(function($a) {
- return preg_grep('/^PHP=(master) /', $a);
-}, $env));
-foreach ($allow_failures as $e) {
- printf(" - env: %s\n", $e);
-}
-?>
-
-install:
- - |
- if test "$PHP" = master; then \
- make -f travis/pecl/Makefile reconf; \
- make -f travis/pecl/Makefile pecl-rm pecl-clean PECL=raphf:raphf:2.0.0; \
- fi
- - make -f travis/pecl/Makefile php || make -f travis/pecl/Makefile clean php
- - make -f travis/pecl/Makefile pecl PECL=raphf:raphf:2.0.0
-
-before_script:
- - psql -U postgres -c "CREATE DATABASE test"
-
-script:
- - make -f travis/pecl/Makefile ext PECL=pq
- - make -f travis/pecl/Makefile test
-
-after_success:
- - test -n "$CFLAGS" && cd src/.libs && bash <(curl -s https://codecov.io/bash) -X xcode -X coveragepy
struct php_pq_callback *recursion;
} php_pq_callback_t;
+#define PHP_PQ_CALLBACK_INIT {{0},{0},NULL}
+
extern void php_pq_callback_dtor(php_pq_callback_t *cb);
extern void php_pq_callback_addref(php_pq_callback_t *cb);
extern zval *php_pq_callback_to_zval(php_pq_callback_t *cb, zval *tmp);
#undef PHP_PQ_TYPE
#include "php_pq_type.h"
+/* convert version to string */
+extern void php_pq_version_to_string(int version, char *buffer, int len) {
+ if (version < 100000) {
+ slprintf(buffer, len, "%d.%d.%d", version/10000, version/100%100, version%100);
+ } else { /* since version 10 */
+ slprintf(buffer, len, "%d.%d", version/10000, version%100);
+ }
+}
/* clear result object associated with a result handle */
void php_pqres_clear(PGresult *r) {
}
}
-int php_pq_compare_index(const void *lptr, const void *rptr)
+static inline int compare_index(zend_ulong l, zend_ulong r)
{
- zend_ulong l = ((const Bucket *) lptr)->h;
- zend_ulong r = ((const Bucket *) rptr)->h;
-
if (l < r) {
return -1;
}
}
return 0;
}
+#if PHP_VERSION_ID >= 80000
+int php_pq_compare_index(Bucket *lptr, Bucket *rptr)
+{
+ return compare_index(lptr->h, rptr->h);
+}
+#else
+int php_pq_compare_index(const void *lptr, const void *rptr) {
+ return compare_index(((const Bucket *) lptr)->h, ((const Bucket *) rptr)->h);
+}
+#endif
void php_pq_hash_ptr_dtor(zval *p)
{
zend_class_entry *php_pqdt_class_entry;
+#if PHP_VERSION_ID >= 80100
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(ai_pqdt_jsonserialize, 0, 0, IS_MIXED, 0)
+ZEND_END_ARG_INFO()
+#else
+#define ai_pqdt_jsonserialize ai_pqdt_to_string
+#endif
+
+#if PHP_VERSION_ID >= 80200
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(ai_pqdt_to_string, 0, 0, IS_STRING, 0)
+#else
ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_to_string, 0, 0, 0)
+#endif
ZEND_END_ARG_INFO();
static PHP_METHOD(pqdt, __toString)
{
zval rv, tmp;
ZVAL_NULL(&rv);
- zend_call_method_with_1_params(getThis(), php_pqdt_class_entry, NULL, "format", &rv,
- zend_read_property(php_pqdt_class_entry, getThis(), ZEND_STRL("format"), 0, &tmp));
+ php_pq_call_method(getThis(), "format", 1, &rv, php_pq_read_property(getThis(), "format", &tmp));
RETVAL_ZVAL(&rv, 1, 1);
}
+#if PHP_VERSION_ID >= 80100
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_TYPE_MASK_EX(ai_pqdt_create_from_format, 0, 2, DateTime, MAY_BE_FALSE)
+#else
ZEND_BEGIN_ARG_INFO_EX(ai_pqdt_create_from_format, 0, 0, 2)
+#endif
ZEND_ARG_INFO(0, format)
ZEND_ARG_INFO(0, datetime)
#if PHP_VERSION_ID >= 70200
static zend_function_entry php_pqdt_methods[] = {
PHP_ME(pqdt, createFromFormat, ai_pqdt_create_from_format, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_ME(pqdt, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
- PHP_MALIAS(pqdt, jsonSerialize, __toString, ai_pqdt_to_string, ZEND_ACC_PUBLIC)
+ PHP_MALIAS(pqdt, jsonSerialize, __toString, ai_pqdt_jsonserialize, ZEND_ACC_PUBLIC)
{0}
};
-zval *php_pqdt_from_string(zval *zv, char *input_fmt, char *dt_str, size_t dt_len, char *output_fmt, zval *ztimezone)
+zval *php_pqdt_from_string(zval *zv, char *input_fmt, char *dt_str, size_t dt_len, const char *output_fmt, zval *ztimezone)
{
php_date_obj *dobj;
zval_dtor(zv);
ZVAL_NULL(zv);
} else if (output_fmt) {
- zend_update_property_string(php_pqdt_class_entry, zv, ZEND_STRL("format"), output_fmt);
+ zval fmt;
+ ZVAL_STRING(&fmt, output_fmt);
+ php_pq_update_property(zv, "format", &fmt);
+ zval_ptr_dtor(&fmt);
}
return zv;
ZVAL_NULL(&rv);
- if (Z_OBJ_HT_P(zdt)->cast_object
- && SUCCESS == Z_OBJ_HT_P(zdt)->cast_object(zdt, &rv, IS_STRING)
- ) {
+ if (php_pq_cast_object(zdt, IS_STRING, &rv)) {
return Z_STR(rv);
} else if (instanceof_function(Z_OBJCE_P(zdt), php_date_get_date_ce())) {
zval rv, zfmt;
ZVAL_NULL(&rv);
ZVAL_STRING(&zfmt, format);
- zend_call_method_with_1_params(zdt, Z_OBJCE_P(zdt), NULL, "format", &rv, &zfmt);
+ php_pq_call_method(zdt, "format", 1, &rv, &zfmt);
zval_ptr_dtor(&zfmt);
if (Z_TYPE(rv) == IS_STRING) {
extern PGresult *php_pq_prepare(PGconn *conn, const char *stmtName, const char *query, int nParams, const Oid *paramTypes);
extern PGresult *php_pq_exec_prepared(PGconn *conn, const char *stmtName, int nParams, const char *const * paramValues, const int *paramLengths, const int *paramFormats, int resultFormat);
+/* convert version to string */
+extern void php_pq_version_to_string(int version, char *buffer, int len);
/* trim LF from EOL */
extern char *php_pq_rtrim(char *e);
/* R, W, RW */
extern const char *php_pq_strmode(long mode);
-/* compare array index */
-extern int php_pq_compare_index(const void *lptr, const void *rptr);
-
/* free zval ptr values (as hash dtor) */
extern void php_pq_hash_ptr_dtor(zval *p);
#define PHP_PQresultErrorMessage(r) php_pq_rtrim(PQresultErrorMessage((r)))
extern zend_class_entry *php_pqdt_class_entry;
-extern zval *php_pqdt_from_string(zval *zv, char *input_fmt, char *dt_str, size_t dt_len, char *output_fmt, zval *ztimezone);
+extern zval *php_pqdt_from_string(zval *zv, char *input_fmt, char *dt_str, size_t dt_len, const char *output_fmt, zval *ztimezone);
extern zend_string *php_pqdt_to_string(zval *zdt, const char *format);
extern zend_class_entry *php_pqconv_class_entry;
extern HashTable *php_pq_parse_array(php_pqres_t *res, const char *val_str, size_t val_len, Oid typ);
+/* ZE compat */
+#if PHP_VERSION_ID >= 80000
+extern int php_pq_compare_index(Bucket *lptr, Bucket *rptr);
+
+# define php_pq_call_method(objval_ptr, method_name, num_args, ...) \
+ zend_call_method_with_ ## num_args ## _params( \
+ Z_OBJ_P(objval_ptr), Z_OBJCE_P(objval_ptr), NULL, \
+ (method_name), __VA_ARGS__)
+# define php_pq_read_property(objval_ptr, prop_name, tmpval_ptr) \
+ zend_read_property(Z_OBJCE_P(objval_ptr), Z_OBJ_P(objval_ptr), \
+ (prop_name), strlen(prop_name), 0, (tmpval_ptr))
+# define php_pq_update_property(objval_ptr, prop_name, newval_ptr) \
+ zend_update_property(Z_OBJCE_P(objval_ptr), Z_OBJ_P(objval_ptr), \
+ (prop_name), strlen(prop_name), (newval_ptr))
+#define php_pq_cast_object(objval_ptr, cast_type, retval_ptr) \
+ (Z_OBJ_HT_P(objval_ptr)->cast_object && \
+ SUCCESS == Z_OBJ_HT_P(objval_ptr)->cast_object(Z_OBJ_P(objval_ptr), (retval_ptr), (cast_type)))
+#else
+
+extern int php_pq_compare_index(const void *lptr, const void *rptr);
+
+# define zend_ce_countable spl_ce_Countable
+
+# define php_pq_call_method(objval_ptr, method_name, num_args, ...) \
+ zend_call_method_with_ ## num_args ## _params( \
+ (objval_ptr), NULL, NULL, \
+ (method_name), __VA_ARGS__)
+# define php_pq_read_property(objval_ptr, prop_name, tmpval_ptr) \
+ zend_read_property(Z_OBJCE_P(objval_ptr), (objval_ptr), \
+ (prop_name), strlen(prop_name), 0, (tmpval_ptr))
+# define php_pq_update_property(objval_ptr, prop_name, newval_ptr) \
+ zend_update_property(Z_OBJCE_P(objval_ptr), (objval_ptr), \
+ (prop_name), strlen(prop_name), (newval_ptr))
+#define php_pq_cast_object(objval_ptr, cast_type, retval_ptr) \
+ (Z_OBJ_HT_P(objval_ptr)->cast_object && \
+ SUCCESS == Z_OBJ_HT_P(objval_ptr)->cast_object(objval_ptr, (retval_ptr), (cast_type)))
+#endif
+
+#if PHP_VERSION_ID < 80100
+# define ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(name, return_reference, required_num_args, type, allow_null) \
+ ZEND_BEGIN_ARG_INFO_EX(name, 0, return_reference, required_num_args)
+# define ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_INFO_EX(name, return_reference, required_num_args, type, allow_null) \
+ ZEND_BEGIN_ARG_INFO_EX(name, 0, return_reference, required_num_args)
+#endif
+
+#ifndef ZEND_ACC_READONLY
+#define ZEND_ACC_READONLY 0
+#endif
extern PHP_MINIT_FUNCTION(pq_misc);
php_info_print_table_header(3, "Used Library", "Compiled", "Linked");
#ifdef HAVE_PQLIBVERSION
libpq_v = PQlibVersion();
- slprintf(libpq_version, sizeof(libpq_version), "%d.%d.%d", libpq_v/10000%100, libpq_v/100%100, libpq_v%100);
+ php_pq_version_to_string(libpq_v, libpq_version, sizeof(libpq_version));
#endif
php_info_print_table_row(3, "libpq", PHP_PQ_LIBVERSION, libpq_version);
php_info_print_table_end();
#include <php.h>
#include "php_pq_object.h"
+#include "php_pq_misc.h"
void *php_pq_object_create(zend_class_entry *ce, void *intern, size_t obj_size, zend_object_handlers *oh, HashTable *ph)
{
struct apply_pi_to_ht_arg {
HashTable *ht;
- zval *object;
php_pq_object_t *pq_obj;
unsigned gc:1;
};
php_pq_object_prophandler_t *handler;
if ((handler = zend_hash_find_ptr(arg->pq_obj->prophandler, pi->name)) && handler->gc) {
- zval member, return_value;
+ zval return_value;
- ZVAL_STR(&member, pi->name);
ZVAL_ARR(&return_value, arg->ht);
- handler->gc(arg->object, arg->pq_obj, &return_value);
+ handler->gc(arg->pq_obj, &return_value);
}
} else {
- zval tmp_prop, *property = NULL;
-
- property = zend_read_property(arg->pq_obj->zo.ce, arg->object, pi->name->val, pi->name->len, 0, &tmp_prop);
+ zval tmp_prop, *property;
+#if PHP_VERSION_ID < 80000
+ zval zobj;
+
+ ZVAL_OBJ(&zobj, &arg->pq_obj->zo);
+# if PHP_VERSION_ID < 70100
+ property = zend_read_property(arg->pq_obj->zo.ce, &zobj, pi->name->val, pi->name->len, 0, &tmp_prop);
+# else
+ property = zend_read_property_ex(arg->pq_obj->zo.ce, &zobj, pi->name, 0, &tmp_prop);
+# endif
+#else
+ property = zend_read_property_ex(arg->pq_obj->zo.ce, &arg->pq_obj->zo, pi->name, 0, &tmp_prop);
+#endif
zend_hash_update(arg->ht, pi->name, property);
}
return ZEND_HASH_APPLY_KEEP;
}
-HashTable *php_pq_object_debug_info(zval *object, int *temp)
+static inline HashTable *php_pq_object_debug_info_ex(zend_object *object, int *temp)
{
struct apply_pi_to_ht_arg arg = {NULL};
ALLOC_HASHTABLE(arg.ht);
ZEND_INIT_SYMTABLE(arg.ht);
- arg.object = object;
- arg.pq_obj = PHP_PQ_OBJ(object, NULL);
+ arg.pq_obj = PHP_PQ_OBJ(NULL, object);
arg.gc = 0;
zend_hash_apply_with_argument(&arg.pq_obj->zo.ce->properties_info, apply_pi_to_ht, &arg);
return arg.ht;
}
+#if PHP_VERSION_ID >= 80000
+HashTable *php_pq_object_debug_info(zend_object *object, int *temp)
+{
+ return php_pq_object_debug_info_ex(object, temp);
+}
+#else
+HashTable *php_pq_object_debug_info(zval *object, int *temp)
+{
+ return php_pq_object_debug_info_ex(Z_OBJ_P(object), temp);
+}
+#endif
-HashTable *php_pq_object_properties(zval *object)
+static inline HashTable *php_pq_object_properties_ex(zend_object *object, HashTable *props)
{
struct apply_pi_to_ht_arg arg = {NULL};
- arg.ht = zend_get_std_object_handlers()->get_properties(object);
- arg.object = object;
- arg.pq_obj = PHP_PQ_OBJ(object, NULL);
+ arg.ht = props;
+ arg.pq_obj = PHP_PQ_OBJ(NULL, object);
arg.gc = 0;
zend_hash_apply_with_argument(&arg.pq_obj->zo.ce->properties_info, apply_pi_to_ht, &arg);
return arg.ht;
}
+#if PHP_VERSION_ID >= 80000
+HashTable *php_pq_object_properties(zend_object *object)
+{
+ return php_pq_object_properties_ex(object, zend_std_get_properties(object));
+}
+#else
+HashTable *php_pq_object_properties(zval *object)
+{
+ return php_pq_object_properties_ex(Z_OBJ_P(object), zend_std_get_properties(object));
+}
+#endif
-HashTable *php_pq_object_get_gc(zval *object, zval **table, int *n)
+static inline HashTable *php_pq_object_get_gc_ex(zend_object *object, HashTable *props, zval **table, int *n)
{
struct apply_pi_to_ht_arg arg = {NULL};
- arg.object = object;
- arg.pq_obj = PHP_PQ_OBJ(object, NULL);
+ arg.pq_obj = PHP_PQ_OBJ(NULL, object);
arg.ht = &arg.pq_obj->gc;
arg.gc = 1;
- zend_hash_clean(arg.ht);
- zend_hash_copy(arg.ht, zend_std_get_properties(object), NULL);
- zend_hash_apply_with_argument(&arg.pq_obj->zo.ce->properties_info, apply_pi_to_ht, &arg);
+ if (GC_REFCOUNT(arg.ht) == 1) {
+ zend_hash_clean(arg.ht);
+ zend_hash_copy(arg.ht, props, NULL);
+ zend_hash_apply_with_argument(&arg.pq_obj->zo.ce->properties_info, apply_pi_to_ht, &arg);
+ }
*table = NULL;
*n = 0;
return arg.ht;
}
+#if PHP_VERSION_ID >= 80000
+HashTable *php_pq_object_get_gc(zend_object *object, zval **table, int *n)
+{
+ return php_pq_object_get_gc_ex(object, zend_std_get_properties(object), table, n);
+}
+#else
+HashTable *php_pq_object_get_gc(zval *object, zval **table, int *n)
+{
+ return php_pq_object_get_gc_ex(Z_OBJ_P(object), zend_std_get_properties(object), table, n);
+}
+#endif
zend_class_entry *ancestor(zend_class_entry *ce)
{
return ce;
}
-zval *php_pq_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *tmp)
+static inline int php_pq_object_read_prop_ex(zend_object *object, zend_string *member, int type, zval *return_value)
{
- php_pq_object_t *obj = PHP_PQ_OBJ(object, NULL);
+ php_pq_object_t *obj = PHP_PQ_OBJ(NULL, object);
php_pq_object_prophandler_t *handler;
- zval *return_value = NULL;
-
- return_value = zend_get_std_object_handlers()->read_property(object, member, type, cache_slot, tmp);
if (!obj->intern) {
php_error(E_RECOVERABLE_ERROR, "%s not initialized", ancestor(obj->zo.ce)->name->val);
- } else if (!(handler = zend_hash_find_ptr(obj->prophandler, Z_STR_P(member))) || !handler->read) {
+ } else if (!(handler = zend_hash_find_ptr(obj->prophandler, member)) || !handler->read) {
/* default handler */
} else if (type != BP_VAR_R) {
php_error(E_WARNING, "Cannot access %s properties by reference or array key/index", ancestor(obj->zo.ce)->name->val);
} else {
- handler->read(object, obj, tmp);
- zend_get_std_object_handlers()->write_property(object, member, tmp, cache_slot);
- return_value = tmp;
-
- /*
- zval dtor;
+ handler->read(obj, return_value);
+ return SUCCESS;
+ }
- ZVAL_COPY_VALUE(&dtor, return_value);
+ return FAILURE;
+}
+#if PHP_VERSION_ID >= 80000
+zval *php_pq_object_read_prop(zend_object *object, zend_string *member, int type, void **cache_slot, zval *tmp)
+{
+ if (SUCCESS != php_pq_object_read_prop_ex(object, member, type, tmp)) {
+ return zend_std_read_property(object, member, type, cache_slot, tmp);
+ }
- ZVAL_ZVAL(return_value, tmp, 0, 0);
- zval_ptr_dtor(&dtor);
+ zend_std_write_property(object, member, tmp, cache_slot);
- */
+ if (cache_slot) {
+ *cache_slot = NULL;
+ }
+ return tmp;
+}
+#else
+zval *php_pq_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *tmp)
+{
+ zend_string *member_str = zval_get_string(member);
- if (cache_slot) {
- *cache_slot = NULL;
- }
+ if (SUCCESS != php_pq_object_read_prop_ex(Z_OBJ_P(object), member_str, type, tmp)) {
+ zend_string_release(member_str);
+ return zend_get_std_object_handlers()->read_property(object, member, type, cache_slot, tmp);
}
+ zend_string_release(member_str);
- return return_value;
+ zend_std_write_property(object, member, tmp, cache_slot);
+
+ if (cache_slot) {
+ *cache_slot = NULL;
+ }
+ return tmp;
}
+#endif
-php_pq_object_write_prop_t php_pq_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot)
+static inline int php_pq_object_write_prop_ex(zend_object *object, zend_string *member, zval *value)
{
- php_pq_object_t *obj = PHP_PQ_OBJ(object, NULL);
+ php_pq_object_t *obj = PHP_PQ_OBJ(NULL, object);
php_pq_object_prophandler_t *handler;
if (!obj->intern) {
php_error(E_RECOVERABLE_ERROR, "%s not initialized", ancestor(obj->zo.ce)->name->val);
- zend_get_std_object_handlers()->write_property(object, member, value, cache_slot);
- } else if ((handler = zend_hash_find_ptr(obj->prophandler, Z_STR_P(member)))) {
+ } else if (!(handler = zend_hash_find_ptr(obj->prophandler, member))) {
+ /* default handler */
+ } else {
if (handler->write) {
- handler->write(object, obj, value);
+ handler->write(obj, value);
}
- } else {
- zend_get_std_object_handlers()->write_property(object, member, value, cache_slot);
+ return SUCCESS;
+ }
+ return FAILURE;
+}
+#if PHP_VERSION_ID >= 80000
+zval *php_pq_object_write_prop(zend_object *object, zend_string *member, zval *value, void **cache_slot)
+{
+ if (SUCCESS != php_pq_object_write_prop_ex(object, member, value)) {
+ return zend_std_write_property(object, member, value, cache_slot);
}
-#if PHP_VERSION_ID >= 70400
return value;
-#endif
}
+#elif PHP_VERSION_ID >= 70400
+zval *php_pq_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot)
+{
+ zend_string *member_str = zval_get_string(member);
+ if (SUCCESS != php_pq_object_write_prop_ex(Z_OBJ_P(object), member_str, value)) {
+ value = zend_std_write_property(object, member, value, cache_slot);
+ }
+ zend_string_release(member_str);
+ return value;
+}
+#else
+void php_pq_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot)
+{
+ zend_string *member_str = zval_get_string(member);
+ if (SUCCESS != php_pq_object_write_prop_ex(Z_OBJ_P(object), member_str, value)) {
+ zend_std_write_property(object, member, value, cache_slot);
+ }
+ zend_string_release(member_str);
+}
+#endif
+#if PHP_VERSION_ID >= 80000
+zval *php_pq_object_get_prop_ptr_null(zend_object *object, zend_string *member, int type, void **cache_slot)
+{
+ return NULL;
+}
+#else
zval *php_pq_object_get_prop_ptr_null(zval *object, zval *member, int type, void **cache_slot)
{
return NULL;
}
+#endif
void php_pq_object_prophandler_dtor(zval *zv) {
pefree(Z_PTR_P(zv), 1);
return (void *) (((char *) zo) - zo->handlers->offset);
}
-typedef void (*php_pq_object_prophandler_func_t)(zval *object, void *o, zval *return_value);
+extern zend_class_entry *ancestor(zend_class_entry *ce);
+
+typedef void (*php_pq_object_prophandler_func_t)(void *o, zval *return_value);
typedef struct php_pq_object_prophandler {
php_pq_object_prophandler_func_t read;
php_pq_object_prophandler_func_t gc;
} php_pq_object_prophandler_t;
+extern void php_pq_object_prophandler_dtor(zval *zv);
+
extern void *php_pq_object_create(zend_class_entry *ce, void *intern, size_t obj_size, zend_object_handlers *oh, HashTable *ph);
extern void php_pq_object_dtor(zend_object *obj);
extern void php_pq_object_to_zval(void *o, zval *zv);
extern void php_pq_object_to_zval_no_addref(void *o, zval *zv);
extern void php_pq_object_addref(void *o);
extern void php_pq_object_delref(void *o);
+
+#if PHP_VERSION_ID >= 80000
+extern HashTable *php_pq_object_debug_info(zend_object *object, int *temp);
+extern HashTable *php_pq_object_properties(zend_object *object);
+extern HashTable *php_pq_object_get_gc(zend_object *object, zval **table, int *n);
+extern zval *php_pq_object_read_prop(zend_object *object, zend_string *member, int type, void **cache_slot, zval *tmp);
+extern zval *php_pq_object_write_prop(zend_object *object, zend_string *member, zval *value, void **cache_slot);
+extern zval *php_pq_object_get_prop_ptr_null(zend_object *object, zend_string *member, int type, void **cache_slot);
+#else
extern HashTable *php_pq_object_debug_info(zval *object, int *temp);
extern HashTable *php_pq_object_properties(zval *object);
-HashTable *php_pq_object_get_gc(zval *object, zval **table, int *n);
-extern zend_class_entry *ancestor(zend_class_entry *ce);
+extern HashTable *php_pq_object_get_gc(zval *object, zval **table, int *n);
extern zval *php_pq_object_read_prop(zval *object, zval *member, int type, void **cache_slot, zval *tmp);
-#if PHP_VERSION_ID >= 70400
-typedef zval *php_pq_object_write_prop_t;
-#else
-typedef void php_pq_object_write_prop_t;
-#endif
-extern php_pq_object_write_prop_t php_pq_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot);
+# if PHP_VERSION_ID >= 70400
+extern zval *php_pq_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot);
+# else
+extern void php_pq_object_write_prop(zval *object, zval *member, zval *value, void **cache_slot);
+# endif
extern zval *php_pq_object_get_prop_ptr_null(zval *object, zval *member, int type, void **cache_slot);
-extern void php_pq_object_prophandler_dtor(zval *zv);
+#endif
#endif
#include <php.h>
#include <ext/standard/php_string.h>
-#if PHP_PQ_HAVE_PHP_JSON_H
-#include <php_json.h> /* we've added the include directory to INCLUDES */
-#endif
+#include <ext/json/php_json.h>
#include <Zend/zend_smart_str.h>
#include <Zend/zend_interfaces.h>
static zend_string *object_param_to_string(php_pq_params_t *p, zval *zobj, Oid type)
{
-#if PHP_PQ_HAVE_PHP_JSON_H && defined(PHP_PQ_OID_JSON)
+#ifdef PHP_PQ_OID_JSON
smart_str str = {0};
#endif
switch (type) {
-#if PHP_PQ_HAVE_PHP_JSON_H && defined(PHP_PQ_OID_JSON)
+#ifdef PHP_PQ_OID_JSON
# ifdef PHP_PQ_OID_JSONB
case PHP_PQ_OID_JSONB:
# endif
zval ztype, rv;
ZVAL_LONG(&ztype, arg->type);
- zend_call_method_with_2_params(arg->zconv, NULL, NULL, "converttostring", &rv, zparam, &ztype);
+ php_pq_call_method(arg->zconv, "converttostring", 2, &rv, zparam, &ztype);
tmpstr = zval_get_string(&rv);
zval_ptr_dtor(&rv);
goto append_string;
struct apply_to_param_from_array_arg arg = {NULL};
switch (type) {
-#if PHP_PQ_HAVE_PHP_JSON_H && defined(PHP_PQ_OID_JSON)
+#ifdef PHP_PQ_OID_JSON
# ifdef PHP_PQ_OID_JSONB
case PHP_PQ_OID_JSONB:
# endif
ZVAL_NULL(&rv);
ZVAL_LONG(&ztype, type);
- zend_call_method_with_2_params(zconv, NULL, NULL, "converttostring", &rv, zpp, &ztype);
+ php_pq_call_method(zconv, "converttostring", 2, &rv, zpp, &ztype);
convert_to_string(&rv);
p->param.strings[index] = Z_STRVAL_P(&rv);
zend_hash_next_index_insert(&p->param.dtor, &rv);
{
struct apply_to_params_arg *arg = arg_ptr;
- SEPARATE_ZVAL_IF_NOT_REF(zp);
+ ZVAL_DEREF(zp);
+ SEPARATE_ZVAL(zp);
php_pq_params_set_param(arg->params, arg->index++, zp);
return ZEND_HASH_APPLY_KEEP;
}
return &php_pqcancel_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqcancel_object_read_connection(zval *object, void *o, zval *return_value)
+static void php_pqcancel_object_read_connection(void *o, zval *return_value)
{
php_pqcancel_object_t *obj = o;
php_pq_object_to_zval(obj->intern->conn, return_value);
}
-static void php_pqcancel_object_gc_connection(zval *object, void *o, zval *return_value)
+static void php_pqcancel_object_gc_connection(void *o, zval *return_value)
{
php_pqcancel_object_t *obj = o;
zval zconn;
return &php_pqconn_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqconn_object_read_status(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_status(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_LONG(PQstatus(obj->intern->conn));
}
-static void php_pqconn_object_read_transaction_status(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_transaction_status(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_LONG(PQtransactionStatus(obj->intern->conn));
}
-static void php_pqconn_object_read_error_message(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_error_message(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
char *error = PHP_PQerrorMessage(obj->intern->conn);
}
}
-static void php_pqconn_object_read_busy(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_busy(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_BOOL(PQisBusy(obj->intern->conn));
}
-static void php_pqconn_object_read_encoding(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_encoding(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_STRING(pg_encoding_to_char(PQclientEncoding(obj->intern->conn)));
}
-static void php_pqconn_object_write_encoding(zval *object, void *o, zval *value)
+static void php_pqconn_object_write_encoding(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
zend_string *zenc = zval_get_string(value);
zend_string_release(zenc);
}
-static void php_pqconn_object_read_unbuffered(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_unbuffered(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_BOOL(obj->intern->unbuffered);
}
-static void php_pqconn_object_write_unbuffered(zval *object, void *o, zval *value)
+static void php_pqconn_object_write_unbuffered(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
obj->intern->unbuffered = z_is_true(value);
}
-static void php_pqconn_object_read_nonblocking(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_nonblocking(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_BOOL(PQisnonblocking(obj->intern->conn));
}
-static void php_pqconn_object_write_nonblocking(zval *object, void *o, zval *value)
+static void php_pqconn_object_write_nonblocking(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
PQsetnonblocking(obj->intern->conn, z_is_true(value));
}
-static void php_pqconn_object_read_db(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_db(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
char *db = PQdb(obj->intern->conn);
}
}
-static void php_pqconn_object_read_user(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_user(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
char *user = PQuser(obj->intern->conn);
}
}
-static void php_pqconn_object_read_pass(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_pass(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
char *pass = PQpass(obj->intern->conn);
}
}
-static void php_pqconn_object_read_host(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_host(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
char *host = PQhost(obj->intern->conn);
}
}
-static void php_pqconn_object_read_port(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_port(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
char *port = PQport(obj->intern->conn);
}
#if HAVE_PQCONNINFO
-static void php_pqconn_object_read_params(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_params(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
PQconninfoOption *ptr, *params = PQconninfo(obj->intern->conn);
}
#endif
-static void php_pqconn_object_read_options(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_options(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
char *options = PQoptions(obj->intern->conn);
return ZEND_HASH_APPLY_KEEP;
}
-static void php_pqconn_object_read_event_handlers(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_event_handlers(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
zend_hash_apply_with_arguments(&obj->intern->eventhandlers, apply_read_callbacks, 1, Z_ARRVAL_P(return_value));
}
-static void php_pqconn_object_gc_event_handlers(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_gc_event_handlers(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
zval *evhs;
ZEND_HASH_FOREACH_END();
}
-static void php_pqconn_object_read_listeners(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_listeners(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
zend_hash_apply_with_arguments(&obj->intern->listeners, apply_read_callbacks, 1, Z_ARRVAL_P(return_value));
}
-static void php_pqconn_object_gc_listeners(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_gc_listeners(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
zval *listeners;
ZEND_HASH_FOREACH_END();
}
-static void php_pqconn_object_read_converters(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_converters(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
zend_hash_copy(Z_ARRVAL_P(return_value), &obj->intern->converters, zval_add_ref);
}
-static void php_pqconn_object_gc_converters(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_gc_converters(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
zval *converter;
ZEND_HASH_FOREACH_END();
}
-static void php_pqconn_object_read_def_fetch_type(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_def_fetch_type(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_LONG(obj->intern->default_fetch_type);
}
-static void php_pqconn_object_write_def_fetch_type(zval *object, void *o, zval *value)
+static void php_pqconn_object_write_def_fetch_type(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
obj->intern->default_fetch_type = zval_get_long(value) & 0x3; /* two bits only */
}
-static void php_pqconn_object_read_def_txn_isolation(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_def_txn_isolation(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_LONG(obj->intern->default_txn_isolation);
}
-static void php_pqconn_object_write_def_txn_isolation(zval *object, void *o, zval *value)
+static void php_pqconn_object_write_def_txn_isolation(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
obj->intern->default_txn_isolation = zval_get_long(value) & 0x3; /* two bits only */
}
-static void php_pqconn_object_read_def_txn_readonly(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_def_txn_readonly(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_BOOL(obj->intern->default_txn_readonly);
}
-static void php_pqconn_object_write_def_txn_readonly(zval *object, void *o, zval *value)
+static void php_pqconn_object_write_def_txn_readonly(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
obj->intern->default_txn_readonly = z_is_true(value);
}
-static void php_pqconn_object_read_def_txn_deferrable(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_def_txn_deferrable(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_BOOL(obj->intern->default_txn_deferrable);
}
-static void php_pqconn_object_write_def_txn_deferrable(zval *object, void *o, zval *value)
+static void php_pqconn_object_write_def_txn_deferrable(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
obj->intern->default_txn_deferrable = zend_is_true(value);
}
-static void php_pqconn_object_read_def_auto_conv(zval *object, void *o, zval *return_value)
+static void php_pqconn_object_read_def_auto_conv(void *o, zval *return_value)
{
php_pqconn_object_t *obj = o;
RETVAL_LONG(obj->intern->default_auto_convert);
}
-static void php_pqconn_object_write_def_auto_conv(zval*object, void *o, zval *value)
+static void php_pqconn_object_write_def_auto_conv(void *o, zval *value)
{
php_pqconn_object_t *obj = o;
obj->intern->default_auto_convert = zval_get_long(value) & PHP_PQRES_CONV_ALL;
}
+#ifdef HAVE_PQLIBVERSION
+static void php_pqconn_object_read_lib_version(void *o, zval *return_value)
+{
+ char ver[16];
+
+ php_pq_version_to_string(PQlibVersion(), ver, sizeof(ver));
+ RETVAL_STRING(ver);
+}
+#endif
+#ifdef HAVE_PQPROTOCOLVERSION
+static void php_pqconn_object_read_protocol_version(void *o, zval *return_value)
+{
+ php_pqconn_object_t *obj = o;
+
+ RETVAL_LONG(PQprotocolVersion(obj->intern->conn));
+}
+#endif
+#ifdef HAVE_PQSERVERVERSION
+static void php_pqconn_object_read_server_version(void *o, zval *return_value)
+{
+ php_pqconn_object_t *obj = o;
+ char ver[16];
+
+ php_pq_version_to_string(PQserverVersion(obj->intern->conn), ver, sizeof(ver));
+ RETVAL_STRING(ver);
+}
+#endif
+
static ZEND_RESULT_CODE php_pqconn_update_socket(zval *zobj, php_pqconn_object_t *obj)
{
zval zsocket, zmember;
ZVAL_NULL(&zsocket);
retval = FAILURE;
}
- zend_get_std_object_handlers()->write_property(zobj, &zmember, &zsocket, NULL);
+#if PHP_VERSION_ID >= 80000
+ zend_std_write_property(Z_OBJ_P(zobj), Z_STR(zmember), &zsocket, NULL);
+#else
+ zend_std_write_property(zobj, &zmember, &zsocket, NULL);
+#endif
zval_ptr_dtor(&zsocket);
zval_ptr_dtor(&zmember);
smart_str_appends(&cmd, quoted_channel);
smart_str_0(&cmd);
- res = PQexec(conn, smart_str_v(&cmd));
+ res = php_pq_exec(conn, smart_str_v(&cmd));
smart_str_free(&cmd);
PQfreemem(quoted_channel);
zend_error_handling zeh;
char *channel_str = NULL;
size_t channel_len = 0;
- php_pq_callback_t listener = {{0}};
+ php_pq_callback_t listener = PHP_PQ_CALLBACK_INIT;
ZEND_RESULT_CODE rv;
zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
zend_error_handling zeh;
char *channel_str = NULL;
size_t channel_len = 0;
- php_pq_callback_t listener = {{0}};
+ php_pq_callback_t listener = PHP_PQ_CALLBACK_INIT;
ZEND_RESULT_CODE rv;
zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
PGresult *res;
char *params[2] = {channel_str, message_str};
- res = PQexecParams(obj->intern->conn, "select pg_notify($1, $2)", 2, NULL, (const char *const*) params, NULL, NULL, 0);
+ res = php_pq_exec_params(obj->intern->conn, "select pg_notify($1, $2)", 2, NULL, (const char *const*) params, NULL, NULL, 0);
if (!res) {
throw_exce(EX_RUNTIME, "Failed to notify listeners (%s)", PHP_PQerrorMessage(obj->intern->conn));
ZEND_END_ARG_INFO();
static PHP_METHOD(pqconn, execAsync) {
zend_error_handling zeh;
- php_pq_callback_t resolver = {{0}};
+ php_pq_callback_t resolver = PHP_PQ_CALLBACK_INIT;
char *query_str;
size_t query_len;
ZEND_RESULT_CODE rv;
php_pq_params_t *params;
params = php_pq_params_init(&obj->intern->converters, ztypes ? Z_ARRVAL_P(ztypes) : NULL, Z_ARRVAL_P(zparams));
- res = PQexecParams(obj->intern->conn, query_str, params->param.count, params->type.oids, (const char *const*) params->param.strings, NULL, NULL, 0);
+ res = php_pq_exec_params(obj->intern->conn, query_str, params->param.count, params->type.oids, (const char *const*) params->param.strings, NULL, NULL, 0);
php_pq_params_free(¶ms);
if (!res) {
ZEND_END_ARG_INFO();
static PHP_METHOD(pqconn, execParamsAsync) {
zend_error_handling zeh;
- php_pq_callback_t resolver = {{0}};
+ php_pq_callback_t resolver = PHP_PQ_CALLBACK_INIT;
char *query_str;
size_t query_len;
zval *zparams;
zend_error_handling zeh;
char *type_str;
size_t type_len;
- php_pq_callback_t cb = {{0}};
+ php_pq_callback_t cb = PHP_PQ_CALLBACK_INIT;
ZEND_RESULT_CODE rv;
zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
struct apply_set_converter_arg arg = {NULL};
ZVAL_NULL(&zoids);
- zend_call_method_with_0_params(zcnv, NULL, NULL, "converttypes", &zoids);
+ php_pq_call_method(zcnv, "converttypes", 0, &zoids);
ZVAL_DUP(&tmp, &zoids);
convert_to_array(&tmp);
struct apply_set_converter_arg arg = {NULL};
ZVAL_NULL(&zoids);
- zend_call_method_with_0_params(zcnv, NULL, NULL, "converttypes", &zoids);
+ php_pq_call_method(zcnv, "converttypes", 0, &zoids);
ZVAL_DUP(&tmp, &zoids);
convert_to_array(&tmp);
zend_hash_str_add_mem(&php_pqconn_object_prophandlers, "defaultAutoConvert", sizeof("defaultAutoConvert")-1, (void *) &ph, sizeof(ph));
ph.write = NULL;
+#ifdef HAVE_PQLIBVERSION
+ zend_declare_property_null(php_pqconn_class_entry, ZEND_STRL("libraryVersion"), ZEND_ACC_PUBLIC|ZEND_ACC_READONLY);
+ ph.read = php_pqconn_object_read_lib_version;
+ zend_hash_str_add_mem(&php_pqconn_object_prophandlers, ZEND_STRL("libraryVersion"), (void *) &ph, sizeof(ph));
+#endif
+
+#ifdef HAVE_PQPROTOCOLVERSION
+ zend_declare_property_null(php_pqconn_class_entry, ZEND_STRL("protocolVersion"), ZEND_ACC_PUBLIC|ZEND_ACC_READONLY);
+ ph.read = php_pqconn_object_read_protocol_version;
+ zend_hash_str_add_mem(&php_pqconn_object_prophandlers, ZEND_STRL("protocolVersion"), (void *) &ph, sizeof(ph));
+#endif
+
+#ifdef HAVE_PQSERVERVERSION
+ zend_declare_property_null(php_pqconn_class_entry, ZEND_STRL("serverVersion"), ZEND_ACC_PUBLIC|ZEND_ACC_READONLY);
+ ph.read = php_pqconn_object_read_server_version;
+ zend_hash_str_add_mem(&php_pqconn_object_prophandlers, ZEND_STRL("serverVersion"), (void *) &ph, sizeof(ph));
+#endif
+
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("OK"), CONNECTION_OK);
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("BAD"), CONNECTION_BAD);
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("STARTED"), CONNECTION_STARTED);
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("AUTH_OK"), CONNECTION_AUTH_OK);
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("SSL_STARTUP"), CONNECTION_SSL_STARTUP);
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("SETENV"), CONNECTION_SETENV);
+#ifdef HAVE_CONNECTION_CHECK_WRITABLE
+ zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("CHECK_WRITABLE"), CONNECTION_CHECK_WRITABLE);
+#endif
+#ifdef HAVE_CONNECTION_CONSUME
+ zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("CONSUME"), CONNECTION_CONSUME);
+#endif
+#ifdef HAVE_CONNECTION_GSS_STARTUP
+ zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("GSS_STARTUP"), CONNECTION_GSS_STARTUP);
+#endif
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("TRANS_IDLE"), PQTRANS_IDLE);
zend_declare_class_constant_long(php_pqconn_class_entry, ZEND_STRL("TRANS_ACTIVE"), PQTRANS_ACTIVE);
smart_str_appends(&cmd, quoted_channel);
smart_str_0(&cmd);
- res = PQexec(conn, smart_str_v(&cmd));
+ res = php_pq_exec(conn, smart_str_v(&cmd));
smart_str_free(&cmd);
PQfreemem(quoted_channel);
return &php_pqcopy_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqcopy_object_read_connection(zval *object, void *o, zval *return_value)
+static void php_pqcopy_object_read_connection(void *o, zval *return_value)
{
php_pqcopy_object_t *obj = o;
php_pq_object_to_zval(obj->intern->conn, return_value);
}
-static void php_pqcopy_object_gc_connection(zval *object, void *o, zval *return_value)
+static void php_pqcopy_object_gc_connection(void *o, zval *return_value)
{
php_pqcopy_object_t *obj = o;
zval zconn;
add_next_index_zval(return_value, &zconn);
}
-static void php_pqcopy_object_read_direction(zval *object, void *o, zval *return_value)
+static void php_pqcopy_object_read_direction(void *o, zval *return_value)
{
php_pqcopy_object_t *obj = o;
RETVAL_LONG(obj->intern->direction);
}
-static void php_pqcopy_object_read_expression(zval *object, void *o, zval *return_value)
+static void php_pqcopy_object_read_expression(void *o, zval *return_value)
{
php_pqcopy_object_t *obj = o;
RETURN_STRING(obj->intern->expression);
}
-static void php_pqcopy_object_read_options(zval *object, void *o, zval *return_value)
+static void php_pqcopy_object_read_options(void *o, zval *return_value)
{
php_pqcopy_object_t *obj = o;
char *spec_str = "1";
size_t spec_len = 1;
ZEND_RESULT_CODE rv;
- php_pq_callback_t resolver = {{0}};
+ php_pq_callback_t resolver = PHP_PQ_CALLBACK_INIT;
zend_error_handling zeh;
zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
return &php_pqcur_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqcur_object_read_name(zval *object, void *o, zval *return_value)
+static void php_pqcur_object_read_name(void *o, zval *return_value)
{
php_pqcur_object_t *obj = o;
RETVAL_STRING(obj->intern->name);
}
-static void php_pqcur_object_read_connection(zval *object, void *o, zval *return_value)
+static void php_pqcur_object_read_connection(void *o, zval *return_value)
{
php_pqcur_object_t *obj = o;
php_pq_object_to_zval(obj->intern->conn, return_value);
}
-static void php_pqcur_object_gc_connection(zval *object, void *o, zval *return_value)
+static void php_pqcur_object_gc_connection(void *o, zval *return_value)
{
php_pqcur_object_t *obj = o;
zval zconn;
add_next_index_zval(return_value, &zconn);
}
-static void php_pqcur_object_read_query(zval *object, void *o, zval *return_value)
+static void php_pqcur_object_read_query(void *o, zval *return_value)
{
php_pqcur_object_t *obj = o;
RETVAL_STRING(obj->intern->decl + obj->intern->query_offset);
}
-static void php_pqcur_object_read_flags(zval *object, void *o, zval *return_value)
+static void php_pqcur_object_read_flags(void *o, zval *return_value)
{
php_pqcur_object_t *obj = o;
PHP_ME(pqcur, move, ai_pqcur_move, ZEND_ACC_PUBLIC)
PHP_ME(pqcur, fetchAsync, ai_pqcur_fetchAsync, ZEND_ACC_PUBLIC)
PHP_ME(pqcur, moveAsync, ai_pqcur_moveAsync, ZEND_ACC_PUBLIC)
- {NULL, NULL, NULL}
+ {0}
};
PHP_MSHUTDOWN_FUNCTION(pqcur)
return &php_pqlob_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqlob_object_read_transaction(zval *object, void *o, zval *return_value)
+static void php_pqlob_object_read_transaction(void *o, zval *return_value)
{
php_pqlob_object_t *obj = o;
php_pq_object_to_zval(obj->intern->txn, return_value);
}
-static void php_pqlob_object_gc_transaction(zval *object, void *o, zval *return_value)
+static void php_pqlob_object_gc_transaction(void *o, zval *return_value)
{
php_pqlob_object_t *obj = o;
zval ztxn;
add_next_index_zval(return_value, &ztxn);
}
-static void php_pqlob_object_read_oid(zval *object, void *o, zval *return_value)
+static void php_pqlob_object_read_oid(void *o, zval *return_value)
{
php_pqlob_object_t *obj = o;
RETVAL_LONG(obj->intern->loid);
}
-static void php_pqlob_object_update_stream(zval *this_ptr, php_pqlob_object_t *obj, zval *zstream);
+static void php_pqlob_object_update_stream(php_pqlob_object_t *obj, zval *zstream);
-static void php_pqlob_object_read_stream(zval *object, void *o, zval *return_value)
+static void php_pqlob_object_read_stream(void *o, zval *return_value)
{
php_pqlob_object_t *obj = o;
zval zstream;
if (!obj->intern->stream) {
- php_pqlob_object_update_stream(object, obj, &zstream);
+ php_pqlob_object_update_stream(obj, &zstream);
} else {
php_stream_to_zval(obj->intern->stream, &zstream);
}
RETVAL_ZVAL(&zstream, 1, 0);
}
+#if PHP_VERSION_ID < 70400
static size_t php_pqlob_stream_write(php_stream *stream, const char *buffer, size_t length)
+#else
+static ssize_t php_pqlob_stream_write(php_stream *stream, const char *buffer, size_t length)
+#endif
{
php_pqlob_object_t *obj = stream->abstract;
- int written = 0;
+ ssize_t written = 0;
if (obj) {
written = lo_write(obj->intern->txn->intern->conn->intern->conn, obj->intern->lofd, buffer, length);
php_pqconn_notify_listeners(obj->intern->txn->intern->conn);
}
+#if PHP_VERSION_ID < 70400
+ return (written < 0 ? 0 : written);
+#else
return written;
+#endif
}
+#if PHP_VERSION_ID < 70400
static size_t php_pqlob_stream_read(php_stream *stream, char *buffer, size_t length)
+#else
+static ssize_t php_pqlob_stream_read(php_stream *stream, char *buffer, size_t length)
+#endif
{
php_pqlob_object_t *obj = stream->abstract;
- int read = 0;
+ ssize_t read = 0;
if (obj) {
php_pqconn_notify_listeners(obj->intern->txn->intern->conn);
}
+#if PHP_VERSION_ID < 70400
+ return (read < 0 ? 0 : read);
+#else
return read;
+#endif
}
static ZEND_RESULT_CODE php_pqlob_stream_close(php_stream *stream, int close_handle)
return SUCCESS;
}
-static ZEND_RESULT_CODE php_pqlob_stream_seek(php_stream *stream, off_t offset, int whence, off_t *newoffset)
+static ZEND_RESULT_CODE php_pqlob_stream_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset)
{
ZEND_RESULT_CODE rv = FAILURE;
php_pqlob_object_t *obj = stream->abstract;
NULL, /* set_option */
};
-static void php_pqlob_object_update_stream(zval *zpqlob, php_pqlob_object_t *obj, zval *zstream)
+static void php_pqlob_object_update_stream(php_pqlob_object_t *obj, zval *zstream)
{
- zval zmember;
+ zval zobj, zmember;
ZVAL_STRINGL(&zmember, "stream", sizeof("stream")-1);
- if (!obj) {
- obj = PHP_PQ_OBJ(zpqlob, NULL);
- }
obj->intern->stream = php_stream_alloc(&php_pqlob_stream_ops, obj, NULL, "r+b");
obj->intern->stream->flags |= PHP_STREAM_FLAG_NO_FCLOSE;
php_stream_to_zval(obj->intern->stream, zstream);
- zend_get_std_object_handlers()->write_property(zpqlob, &zmember, zstream, NULL);
+#if PHP_VERSION_ID >= 80000
+ zend_std_write_property(&obj->zo, Z_STR(zmember), zstream, NULL);
+#else
+ ZVAL_OBJ(&zobj, &obj->zo);
+ zend_std_write_property(&zobj, &zmember, zstream, NULL);
+#endif
zval_ptr_dtor(&zmember);
}
#include <php.h>
#include <ext/spl/spl_iterators.h>
-#if PHP_PQ_HAVE_PHP_JSON_H
-#include <php_json.h> /* we've added the include directory to INCLUDES */
-#endif
+#include <ext/json/php_json.h>
#include <libpq-events.h>
iter->zi.funcs = &php_pqres_iterator_funcs;
ZVAL_COPY_VALUE(&iter->zi.data, object);
- zfetch_type = zend_read_property(ce, object, ZEND_STRL("fetchType"), 0, &tmp);
+ zfetch_type = php_pq_read_property(object, "fetchType", &tmp);
iter->fetch_type = zval_get_long(zfetch_type);
#if DBG_GC
fprintf(stderr, "INIT iter(#%d) %p res(#%d) %p\n", iter->zi.std.handle, iter, Z_OBJ_HANDLE_P(object), PHP_PQ_OBJ(object, NULL));
ZVAL_NULL(&rv);
ZVAL_LONG(&ztype, typ);
- zend_call_method_with_2_params(zconv, NULL, NULL, "convertfromstring", &rv, zv, &ztype);
+ php_pq_call_method(zconv, "convertfromstring", 2, &rv, zv, &ztype);
zval_ptr_dtor(zv);
ZVAL_ZVAL(zv, &rv, 0, 0);
php_pqdt_from_string(zv, NULL, str->val, str->len, "Y-m-d H:i:s.uO", NULL);
break;
-#if PHP_PQ_HAVE_PHP_JSON_H && defined(PHP_PQ_OID_JSON)
+#ifdef PHP_PQ_OID_JSON
# ifdef PHP_PQ_OID_JSONB
case PHP_PQ_OID_JSONB:
# endif
break;
#endif
+ case PHP_PQ_OID_BYTEA:
+ if (!(res->auto_convert & PHP_PQRES_CONV_BYTEA)) {
+ goto noconversion;
+ } else {
+ size_t to_len;
+ char *to_str = (char *) PQunescapeBytea((unsigned char *) str->val, &to_len);
+
+ if (!to_str) {
+ ZVAL_NULL(zv);
+ php_error_docref(NULL, E_WARNING, "Failed to unsescape BYTEA: '%s'", str->val);
+ } else {
+ ZVAL_STRINGL(zv, to_str, to_len);
+ PQfreemem(to_str);
+ }
+ }
+ break;
+
default:
if (!(res->auto_convert & PHP_PQRES_CONV_ARRAY)) {
goto noconversion;
php_pqres_iterator_rewind,
/* invalidate current value/key (optional, may be NULL) */
php_pqres_iterator_invalidate
+#if PHP_VERSION_ID >= 80000
+ , NULL
+#endif
};
-static ZEND_RESULT_CODE php_pqres_count_elements(zval *object, long *count)
+static inline ZEND_RESULT_CODE php_pqres_count_elements_ex(zend_object *object, zend_long *count)
{
- php_pqres_object_t *obj = PHP_PQ_OBJ(object, NULL);
+ php_pqres_object_t *obj = PHP_PQ_OBJ(NULL, object);
if (!obj->intern) {
return FAILURE;
} else {
- *count = (long) PQntuples(obj->intern->res);
+ *count = (zend_long) PQntuples(obj->intern->res);
return SUCCESS;
}
}
+#if PHP_VERSION_ID >= 80000
+static ZEND_RESULT_CODE php_pqres_count_elements(zend_object *object, zend_long *count)
+{
+ return php_pqres_count_elements_ex(object, count);
+}
+#else
+static ZEND_RESULT_CODE php_pqres_count_elements(zval *object, zend_long *count)
+{
+ return php_pqres_count_elements_ex(Z_OBJ_P(object), count);
+}
+#endif
ZEND_RESULT_CODE php_pqres_success(PGresult *res)
{
- zval zexc;
+ zval zexc, zsqlstate;
switch (PQresultStatus(res)) {
case PGRES_BAD_RESPONSE:
case PGRES_NONFATAL_ERROR:
case PGRES_FATAL_ERROR:
ZVAL_OBJ(&zexc, throw_exce(EX_SQL, "%s", PHP_PQresultErrorMessage(res)));
- zend_update_property_string(Z_OBJCE(zexc), &zexc, ZEND_STRL("sqlstate"), PQresultErrorField(res, PG_DIAG_SQLSTATE));
+ ZVAL_STRING(&zsqlstate, PQresultErrorField(res, PG_DIAG_SQLSTATE));
+ php_pq_update_property(&zexc, "sqlstate", &zsqlstate);
+ zval_ptr_dtor(&zsqlstate);
return FAILURE;
default:
return SUCCESS;
return &php_pqres_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqres_object_read_status(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_status(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
RETVAL_LONG(PQresultStatus(obj->intern->res));
}
-static void php_pqres_object_read_status_message(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_status_message(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
RETVAL_STRING(PQresStatus(PQresultStatus(obj->intern->res))+sizeof("PGRES"));
}
-static void php_pqres_object_read_error_message(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_error_message(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
char *error = PHP_PQresultErrorMessage(obj->intern->res);
# define PG_DIAG_SOURCE_FUNCTION 'R'
#endif
-static void php_pqres_object_read_diag(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_diag(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
int i;
}
}
-static void php_pqres_object_read_num_rows(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_num_rows(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
RETVAL_LONG(PQntuples(obj->intern->res));
}
-static void php_pqres_object_read_num_cols(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_num_cols(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
RETVAL_LONG(PQnfields(obj->intern->res));
}
-static void php_pqres_object_read_affected_rows(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_affected_rows(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
RETVAL_LONG(atoi(PQcmdTuples(obj->intern->res)));
}
-static void php_pqres_object_read_fetch_type(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_fetch_type(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
RETVAL_LONG(php_pqres_fetch_type(obj->intern));
}
-static void php_pqres_object_write_fetch_type(zval *object, void *o, zval *value)
+static void php_pqres_object_write_fetch_type(void *o, zval *value)
{
php_pqres_object_t *obj = o;
if (!obj->intern->iter) {
- php_pqres_internal_iterator_init(object);
+ zval object;
+
+ ZVAL_OBJ(&object, &obj->zo);
+ php_pqres_internal_iterator_init(&object);
}
obj->intern->iter->fetch_type = zval_get_long(value);
}
-static void php_pqres_object_read_auto_conv(zval *object, void *o, zval *return_value)
+static void php_pqres_object_read_auto_conv(void *o, zval *return_value)
{
php_pqres_object_t *obj = o;
RETVAL_LONG(obj->intern->auto_convert);
}
-static void php_pqres_object_write_auto_conv(zval *object, void *o, zval *value)
+static void php_pqres_object_write_auto_conv(void *o, zval *value)
{
php_pqres_object_t *obj = o;
}
if (!col->name) {
- php_error_docref(NULL, E_WARNING, "Failed to find column at index %ld", index);
+ php_error_docref(NULL, E_WARNING, "Failed to find column at index " ZEND_LONG_FMT, index);
return FAILURE;
}
if (col->num == -1) {
ZEND_RESULT_CODE *rv = va_arg(argv, ZEND_RESULT_CODE *);
if (!(zvalue = zend_hash_index_find(Z_ARRVAL_P(zrow), key->h))) {
- php_error_docref(NULL, E_WARNING, "Failed to find column ad index %lu", key->h);
+ php_error_docref(NULL, E_WARNING, "Failed to find column ad index " ZEND_ULONG_FMT, key->h);
*rv = FAILURE;
return ZEND_HASH_APPLY_STOP;
} else {
}
}
-ZEND_BEGIN_ARG_INFO_EX(ai_pqres_count, 0, 0, 0)
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_TYPE_INFO_EX(ai_pqres_count, 0, 0, IS_LONG, 0)
ZEND_END_ARG_INFO();
static PHP_METHOD(pqres, count) {
zend_error_handling zeh;
zend_restore_error_handling(&zeh);
if (SUCCESS == rv) {
- long count;
+ zend_long count;
- if (SUCCESS != php_pqres_count_elements(getThis(), &count)) {
+ if (SUCCESS != php_pqres_count_elements_ex(Z_OBJ_P(getThis()), &count)) {
throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
} else {
RETVAL_LONG(count);
}
}
+#if PHP_VERSION_ID >= 80000
+ZEND_BEGIN_ARG_WITH_TENTATIVE_RETURN_OBJ_INFO_EX(ai_pqres_getIterator, 0, 0, Traversable, 0)
+ZEND_END_ARG_INFO();
+static PHP_METHOD(pqres, getIterator)
+{
+ zend_error_handling zeh;
+ ZEND_RESULT_CODE rv;
+
+ zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
+ rv = zend_parse_parameters_none();
+ zend_restore_error_handling(&zeh);
+
+ if (SUCCESS == rv) {
+ php_pqres_object_t *obj = PHP_PQ_OBJ(getThis(), NULL);
+
+ if (!obj->intern) {
+ throw_exce(EX_UNINITIALIZED, "pq\\Result not initialized");
+ } else {
+ zend_create_internal_iterator_zval(return_value, getThis());
+ }
+ }
+}
+#endif
+
static zend_function_entry php_pqres_methods[] = {
PHP_ME(pqres, bind, ai_pqres_bind, ZEND_ACC_PUBLIC)
PHP_ME(pqres, fetchBound, ai_pqres_fetch_bound, ZEND_ACC_PUBLIC)
PHP_ME(pqres, count, ai_pqres_count, ZEND_ACC_PUBLIC)
PHP_ME(pqres, map, ai_pqres_map, ZEND_ACC_PUBLIC)
PHP_ME(pqres, desc, ai_pqres_desc, ZEND_ACC_PUBLIC)
+#if PHP_VERSION_ID >= 80000
+ PHP_ME(pqres, getIterator, ai_pqres_getIterator, ZEND_ACC_PUBLIC)
+#endif
{0}
};
php_pqres_class_entry = zend_register_internal_class_ex(&ce, NULL);
php_pqres_class_entry->create_object = php_pqres_create_object;
php_pqres_class_entry->get_iterator = php_pqres_iterator_init;
- zend_class_implements(php_pqres_class_entry, 2, zend_ce_traversable, spl_ce_Countable);
+#if PHP_VERSION_ID >= 80000
+ zend_class_implements(php_pqres_class_entry, 2, zend_ce_aggregate, zend_ce_countable);
+#else
+ zend_class_implements(php_pqres_class_entry, 2, zend_ce_traversable, zend_ce_countable);
+#endif
memcpy(&php_pqres_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
php_pqres_object_handlers.offset = XtOffsetOf(php_pqres_object_t, zo);
zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_SCALAR"), PHP_PQRES_CONV_SCALAR);
zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_ARRAY"), PHP_PQRES_CONV_ARRAY);
zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_DATETIME"), PHP_PQRES_CONV_DATETIME);
-#if PHP_PQ_HAVE_PHP_JSON_H
zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_JSON"), PHP_PQRES_CONV_JSON);
-#endif
+ zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_BYTEA"), PHP_PQRES_CONV_BYTEA);
zend_declare_class_constant_long(php_pqres_class_entry, ZEND_STRL("CONV_ALL"), PHP_PQRES_CONV_ALL);
return SUCCESS;
#define PHP_PQRES_CONV_BOOL 0x0001
#define PHP_PQRES_CONV_INT 0x0002
#define PHP_PQRES_CONV_FLOAT 0x0004
+#define PHP_PQRES_CONV_BYTEA 0x0008
#define PHP_PQRES_CONV_SCALAR 0x000f
#define PHP_PQRES_CONV_ARRAY 0x0010
#define PHP_PQRES_CONV_DATETIME 0x0020
return &php_pqstm_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqstm_object_read_name(zval *object, void *o, zval *return_value)
+static void php_pqstm_object_read_name(void *o, zval *return_value)
{
php_pqstm_object_t *obj = o;
RETVAL_STRING(obj->intern->name);
}
-static void php_pqstm_object_read_connection(zval *object, void *o, zval *return_value)
+static void php_pqstm_object_read_connection(void *o, zval *return_value)
{
php_pqstm_object_t *obj = o;
php_pq_object_to_zval(obj->intern->conn, return_value);
}
-static void php_pqstm_object_gc_connection(zval *object, void *o, zval *return_value)
+static void php_pqstm_object_gc_connection(void *o, zval *return_value)
{
php_pqstm_object_t *obj = o;
zval zconn;
add_next_index_zval(return_value, &zconn);
}
-static void php_pqstm_object_read_query(zval *object, void *o, zval *return_value)
+static void php_pqstm_object_read_query(void *o, zval *return_value)
{
php_pqstm_object_t *obj = o;
RETVAL_STRING(obj->intern->query);
}
-static void php_pqstm_object_read_types(zval *object, void *o, zval *return_value)
+static void php_pqstm_object_read_types(void *o, zval *return_value)
{
int i;
php_pqstm_object_t *obj = o;
static PHP_METHOD(pqstm, execAsync) {
zend_error_handling zeh;
zval *zparams = NULL;
- php_pq_callback_t resolver = {{0}};
+ php_pq_callback_t resolver = PHP_PQ_CALLBACK_INIT;
ZEND_RESULT_CODE rv;
zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
ZEND_END_ARG_INFO();
static PHP_METHOD(pqstm, descAsync) {
zend_error_handling zeh;
- php_pq_callback_t resolver = {{0}};
+ php_pq_callback_t resolver = PHP_PQ_CALLBACK_INIT;
ZEND_RESULT_CODE rv;
zend_replace_error_handling(EH_THROW, exce(EX_INVALID_ARGUMENT), &zeh);
return &php_pqtxn_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqtxn_object_read_connection(zval *object, void *o, zval *return_value)
+static void php_pqtxn_object_read_connection(void *o, zval *return_value)
{
php_pqtxn_object_t *obj = o;
php_pq_object_to_zval(obj->intern->conn, return_value);
}
-static void php_pqtxn_object_gc_connection(zval *object, void *o, zval *return_value)
+static void php_pqtxn_object_gc_connection(void *o, zval *return_value)
{
php_pqtxn_object_t *obj = o;
zval zconn;
add_next_index_zval(return_value, &zconn);
}
-static void php_pqtxn_object_read_isolation(zval *object, void *o, zval *return_value)
+static void php_pqtxn_object_read_isolation(void *o, zval *return_value)
{
php_pqtxn_object_t *obj = o;
RETVAL_LONG(obj->intern->isolation);
}
-static void php_pqtxn_object_read_readonly(zval *object, void *o, zval *return_value)
+static void php_pqtxn_object_read_readonly(void *o, zval *return_value)
{
php_pqtxn_object_t *obj = o;
RETVAL_BOOL(obj->intern->readonly);
}
-static void php_pqtxn_object_read_deferrable(zval *object, void *o, zval *return_value)
+static void php_pqtxn_object_read_deferrable(void *o, zval *return_value)
{
php_pqtxn_object_t *obj = o;
RETVAL_BOOL(obj->intern->deferrable);
}
-static void php_pqtxn_object_write_isolation(zval *object, void *o, zval *value)
+static void php_pqtxn_object_write_isolation(void *o, zval *value)
{
php_pqtxn_object_t *obj = o;
php_pqtxn_isolation_t orig = obj->intern->isolation;
}
}
-static void php_pqtxn_object_write_readonly(zval *object, void *o, zval *value)
+static void php_pqtxn_object_write_readonly(void *o, zval *value)
{
php_pqtxn_object_t *obj = o;
PGresult *res;
}
}
-static void php_pqtxn_object_write_deferrable(zval *object, void *o, zval *value)
+static void php_pqtxn_object_write_deferrable(void *o, zval *value)
{
php_pqtxn_object_t *obj = o;
PGresult *res;
return &php_pqtypes_create_object_ex(class_type, NULL)->zo;
}
-static void php_pqtypes_object_read_connection(zval *object, void *o, zval *return_value)
+static void php_pqtypes_object_read_connection(void *o, zval *return_value)
{
php_pqtypes_object_t *obj = o;
php_pq_object_to_zval(obj->intern->conn, return_value);
}
-static void php_pqtypes_object_gc_connection(zval *object, void *o, zval *return_value)
+static void php_pqtypes_object_gc_connection(void *o, zval *return_value)
{
php_pqtypes_object_t *obj = o;
zval zconn;
add_next_index_zval(return_value, &zconn);
}
-static int has_dimension(HashTable *ht, zval *member, zend_string **key, zend_long *index)
+static inline int has_dimension(HashTable *ht, zval *member, zend_string **key, zend_long *index)
{
if (Z_TYPE_P(member) == IS_LONG) {
*index = Z_LVAL_P(member);
}
}
-static int php_pqtypes_object_has_dimension(zval *object, zval *member, int check_empty)
+static inline int php_pqtypes_object_has_dimension_ex(zend_object *object, zval *member, int check_empty)
{
- php_pqtypes_object_t *obj = PHP_PQ_OBJ(object, NULL);
+ php_pqtypes_object_t *obj = PHP_PQ_OBJ(NULL, object);
zend_string *key = NULL;
zend_long index = 0;
return 0;
}
+#if PHP_VERSION_ID >= 80000
+static int php_pqtypes_object_has_dimension(zend_object *object, zval *member, int check_empty)
+{
+ return php_pqtypes_object_has_dimension_ex(object, member, check_empty);
+}
+#else
+static int php_pqtypes_object_has_dimension(zval *object, zval *member, int check_empty)
+{
+ return php_pqtypes_object_has_dimension_ex(Z_OBJ_P(object), member, check_empty);
+}
+#endif
-static zval *php_pqtypes_object_read_dimension(zval *object, zval *member, int type, zval *rv)
+static inline zval *php_pqtypes_object_read_dimension_ex(zend_object *object, zval *member, int type, zval *rv)
{
- php_pqtypes_object_t *obj = PHP_PQ_OBJ(object, NULL);
+ php_pqtypes_object_t *obj = PHP_PQ_OBJ(NULL, object);
zend_string *key = NULL;
zend_long index = 0;
zval *data = NULL;
return data;
}
+#if PHP_VERSION_ID >= 80000
+static zval *php_pqtypes_object_read_dimension(zend_object *object, zval *member, int type, zval *rv)
+{
+ return php_pqtypes_object_read_dimension_ex(object, member, type, rv);
+}
+#else
+static zval *php_pqtypes_object_read_dimension(zval *object, zval *member, int type, zval *rv)
+{
+ return php_pqtypes_object_read_dimension_ex(Z_OBJ_P(object), member, type, rv);
+}
+#endif
+#if PHP_VERSION_ID >= 80000
+static void php_pqtypes_object_write_dimension(zend_object *object, zval *offset, zval *value)
+{
+ throw_exce(EX_RUNTIME, "pq\\Types object must not be modified");
+}
+#else
static void php_pqtypes_object_write_dimension(zval *object, zval *offset, zval *value)
{
throw_exce(EX_RUNTIME, "pq\\Types object must not be modified");
}
+#endif
+#if PHP_VERSION_ID >= 80000
+static void php_pqtypes_object_unset_dimension(zend_object *object, zval *offset)
+{
+ throw_exce(EX_RUNTIME, "pq\\Types object must not be modified");
+}
+#else
static void php_pqtypes_object_unset_dimension(zval *object, zval *offset)
{
throw_exce(EX_RUNTIME, "pq\\Types object must not be modified");
}
+#endif
ZEND_BEGIN_ARG_INFO_EX(ai_pqtypes_construct, 0, 0, 1)
ZEND_ARG_OBJ_INFO(0, connection, pq\\Connection, 0)
zend_hash_init(&obj->intern->types, 512, NULL, ZVAL_PTR_DTOR, 0);
if (znsp) {
- zend_call_method_with_1_params(getThis(), Z_OBJCE_P(getThis()), NULL, "refresh", NULL, znsp);
+ php_pq_call_method(getThis(), "refresh", 1, NULL, znsp);
} else {
- zend_call_method_with_0_params(getThis(), Z_OBJCE_P(getThis()), NULL, "refresh", NULL);
+ php_pq_call_method(getThis(), "refresh", 0, NULL);
}
}
}
include "_setup.inc";
defined("PQ_DSN") or die("skip PQ_DSN undefined");
try {
- new pq\Connection(PQ_DSN);
+ $c = new pq\Connection(PQ_DSN);
+ if (defined("SERVER_MIN") && version_compare(SERVER_MIN, $c->serverVersion) > 0) {
+ die("skip server {$c->serverVersion} is too old, needed " . SERVER_MIN);
+ }
} catch (pq\Exception $e) {
die("skip could not connect to PQ_DSN ".$e->getMessage());
}
--EXPECTREGEX--
Test
(WP(RP)*)+S
-2(,\d)*,0
+[23](,\d*)*,0
DONE
--EXPECTREGEX--
Test
(WP(RP)*)+S
-2(,\d)*,0
+[23](,\d*)*,0
(WP(RP)*)+S
-2(,\d)*,0
+[23](,\d*)*,0
DONE
--- /dev/null
+--TEST--
+asnyc query not cleaned before sync exec
+--SKIPIF--
+<?php include "_skipif.inc"; ?>
+--FILE--
+<?php
+echo "Test\n";
+include "_setup.inc";
+
+$c = new pq\Connection(PQ_DSN);
+
+var_dump([
+ "async" => $c->execAsync("select clock_timestamp(), pg_sleep(0.1), clock_timestamp()", function($r) {
+ var_dump([
+ "cb" => $r->fetchRow()
+ ]);
+ })
+]);
+
+var_dump([
+ "execParams" => $c->execParams("select \$1::int4", [123])->fetchRow()
+]);
+?>
+DONE
+--EXPECTF--
+Test
+array(1) {
+ ["async"]=>
+ NULL
+}
+array(1) {
+ ["cb"]=>
+ array(3) {
+ [0]=>
+ object(pq\DateTime)#%d (4) {
+ ["format"]=>
+ string(14) "Y-m-d H:i:s.uO"
+ ["date"]=>
+ string(26) "%s"
+ ["timezone_type"]=>
+ int(1)
+ ["timezone"]=>
+ string(6) "%s"
+ }
+ [1]=>
+ string(0) ""
+ [2]=>
+ object(pq\DateTime)#%d (4) {
+ ["format"]=>
+ string(14) "Y-m-d H:i:s.uO"
+ ["date"]=>
+ string(26) "%s"
+ ["timezone_type"]=>
+ int(1)
+ ["timezone"]=>
+ string(6) "%s"
+ }
+ }
+}
+array(1) {
+ ["execParams"]=>
+ array(1) {
+ [0]=>
+ int(123)
+ }
+}
+DONE
--- /dev/null
+--TEST--
+basic functionality
+--SKIPIF--
+<?php include "_skipif.inc"; ?>
+--FILE--
+<?php
+echo "Test\n";
+include "_setup.inc";
+
+$c = new pq\Connection(PQ_DSN);
+
+var_dump($c->libraryVersion);
+var_dump($c->protocolVersion);
+var_dump($c->serverVersion);
+?>
+DONE
+--EXPECTF--
+Test
+string(%d) "%s"
+int(%d)
+string(%d) "%s"
+DONE
include "_setup.inc";
$c = new pq\Connection(PQ_DSN);
+try {
+ $c->exec("SET lc_messages TO 'C'");
+} catch (pq\Exception $e) {
+ // no not fail if we are not superuser
+}
$x = new pq\Cancel($c);
--SKIPIF--
<?php
include "_skipif.inc";
+if (version_compare(PHP_VERSION, "8.2", ">="))
+ echo "skip PHP_VERSION>=8.2 (dynamic properties deprecated)\n";
?>
--FILE--
<?php
--TEST--
crash stm reverse dependency from connection
--SKIPIF--
-<?php
+<?php
include "_skipif.inc";
+if (version_compare(PHP_VERSION, "8.2", ">="))
+ echo "skip PHP_VERSION>=8.2 (dynamic properties deprecated)\n";
?>
--FILE--
-<?php
+<?php
echo "Test\n";
include "_setup.inc";
--SKIPIF--
<?php
include "_skipif.inc";
+if (version_compare(PHP_VERSION, "8.2", ">="))
+ echo "skip PHP_VERSION>=8.2 (dynamic properties deprecated)\n";
?>
--FILE--
<?php
try {
new pq\Connection(1,2,3,4);
foo();
-} catch (pq\Exception $e) {
-assert($e->getCode() == pq\Exception::INVALID_ARGUMENT, $e->getCode()."!=".pq\Exception::INVALID_ARGUMENT);
-}
-try {
- new pq\Connection(1,2,3,4);
- foo();
+} catch (ArgumentCountError $e) {
+ // PHP 8
} catch (pq\Exception\InvalidArgumentException $e) {
assert($e->getCode() == pq\Exception::INVALID_ARGUMENT, $e->getCode()."!=".pq\Exception::INVALID_ARGUMENT);
}
--- /dev/null
+--TEST--
+json conv broken since 2.2.1
+--SKIPIF--
+<?php
+define("SERVER_MIN", "9.4");
+include "_skipif.inc";
+?>
+--INI--
+date.timezone=UTC
+--FILE--
+<?php
+echo "Test\n";
+
+include "_setup.inc";
+
+$c = new pq\Connection(PQ_DSN);
+$c->defaultFetchType = \pq\Result::FETCH_ASSOC;
+
+$q = <<<EOF
+ SELECT '0'::jsonb UNION SELECT '"text"'::jsonb;
+EOF;
+$r = $c->exec($q);
+
+var_dump($r->fetchAll());
+?>
+===DONE===
+--EXPECT--
+Test
+array(2) {
+ [0]=>
+ array(1) {
+ ["jsonb"]=>
+ string(4) "text"
+ }
+ [1]=>
+ array(1) {
+ ["jsonb"]=>
+ int(0)
+ }
+}
+===DONE===
public $dummy = 2;
}
-var_dump(new pq\Result, get_object_vars(new r));
+var_dump(new pq\Result);
+
+echo "Test\n";
+$v = get_object_vars(new r);
+ksort($v);
+var_dump($v);
+
?>
Done
--EXPECTF--
Warning: pq\Result not initialized in %s on line %d
Warning: pq\Result not initialized in %s on line %d
+object(pq\Result)#%d (9) {
+ ["status"]=>
+ NULL
+ ["statusMessage"]=>
+ NULL
+ ["errorMessage"]=>
+ NULL
+ ["diag"]=>
+ NULL
+ ["numRows"]=>
+ int(0)
+ ["numCols"]=>
+ int(0)
+ ["affectedRows"]=>
+ int(0)
+ ["fetchType"]=>
+ int(0)
+ ["autoConvert"]=>
+ int(65535)
+}
+Test
Warning: pq\Result not initialized in %s on line %d
Warning: pq\Result not initialized in %s on line %d
Warning: pq\Result not initialized in %s on line %d
-object(pq\Result)#%d (9) {
- ["status"]=>
- NULL
- ["statusMessage"]=>
- NULL
- ["errorMessage"]=>
- NULL
- ["diag"]=>
- NULL
- ["numRows"]=>
- int(0)
- ["numCols"]=>
- int(0)
+array(10) {
["affectedRows"]=>
int(0)
- ["fetchType"]=>
- int(0)
["autoConvert"]=>
int(65535)
-}
-array(10) {
+ ["diag"]=>
+ NULL
["dummy"]=>
int(2)
- ["status"]=>
- NULL
- ["statusMessage"]=>
- NULL
["errorMessage"]=>
NULL
- ["diag"]=>
- NULL
- ["numRows"]=>
+ ["fetchType"]=>
int(0)
["numCols"]=>
int(0)
- ["affectedRows"]=>
- int(0)
- ["fetchType"]=>
+ ["numRows"]=>
int(0)
- ["autoConvert"]=>
- int(65535)
+ ["status"]=>
+ NULL
+ ["statusMessage"]=>
+ NULL
}
Done
$c = new pq\Connection(PQ_DSN);
$c->exec("DROP TABLE IF EXISTS test CASCADE");
$c->exec("SET client_min_messages TO NOTICE");
+try {
+ $c->exec("SET lc_messages TO 'C'");
+} catch (pq\Exception $e) {
+ // do not die if we are not superuser
+}
$c->on(pq\Connection::EVENT_NOTICE, function($c, $notice) {
echo "Got notice: $notice\n";
});
'2013-01-01 01:01:01 UTC'::timestamptz as timestamptz,
array[array[1,2,3],array[4,5,6],array[NULL::int,NULL::int,NULL::int]] as intarray,
array[box(point(1,2),point(2,3)),box(point(4,5),point(5,6))] as boxarray,
-array[]::text[] as emptyarray
+array[]::text[] as emptyarray,
+'foo\n'::bytea as bytea,
+'foo\n'::bytea::text as bytea_text
");
var_dump($r->fetchRow(pq\Result::FETCH_ASSOC));
?>
DONE
--EXPECTF--
Test
-array(13) {
+array(15) {
["null"]=>
NULL
["bool"]=>
["emptyarray"]=>
array(0) {
}
+ ["bytea"]=>
+ string(4) "foo
+"
+ ["bytea_text"]=>
+ string(10) "\x666f6f0a"
}
-DONE
\ No newline at end of file
+DONE
+++ /dev/null
-Subproject commit 309d295271f95d9267c64535de8c2e638f6614cc
projects / m6w6 / ext-pq / commitdiff
