pdo_pgsql: unbuffered fetching: test

memory & non-regression test

Author: outtersg

ext/pdo_pgsql/tests/gh15287.phpt

@@ -0,0 +1,150 @@
+--TEST--
+PDO PgSQL #15287 (Pdo\Pgsql has no real lazy fetch mode)
+--EXTENSIONS--
+pdo
+pdo_pgsql
+--SKIPIF--
+<?php
+require __DIR__ . '/config.inc';
+require  __DIR__ . '/../../../ext/pdo/tests/pdo_test.inc';
+PDOTest::skip();
+?>
+--FILE--
+<?php
+
+require  __DIR__ . '/../../../ext/pdo/tests/pdo_test.inc';
+$pdo = PDOTest::test_factory(__DIR__ . '/common.phpt');
+
+// We need a dataset of some KB so that memory gain is significant.
+// See https://www.postgresql.org/message-id/1140652.1687950987%40sss.pgh.pa.us
+$pdo->exec("create temp table t (n int, t text)");
+$pdo->exec("insert into t values (0, 'original')");
+for ($i = -1; ++$i < 8;) {
+	$pdo->exec("insert into t select n + 1, 'non '||t from t");
+}
+
+$reqOf3 = 'select 79 n union all select 80 union all select 81';
+$reqOfBig = 'select * from t';
+
+echo "=== mem test ===\n";
+
+// First execute without lazy fetching, as a reference and non-regression;
+// execute twice: in case warmup reduces memory consumption, we want the stabilized consumption.
+for ($i = -1; ++$i < 3;) {
+	switch ($i) {
+		case 0:
+			echo "Without lazy fetching:\n";
+			break;
+		case 2:
+			echo "With lazy fetching:\n";
+			$pdo->setAttribute(PDO::ATTR_PREFETCH, 0);
+			break;
+	}
+	$stmt = $pdo->prepare($reqOfBig);
+	$stmt->execute();
+	$res = [];
+	// No fetchAll because we want the memory of the result of the FORElast call (the last one is empty).
+	while (($re = $stmt->fetch(PDO::FETCH_ASSOC))) {
+		$res[] = $re;
+		// Memory introspection relies on an optionally-compiled constant.
+		if (defined('PDO::PGSQL_ATTR_RESULT_MEMORY_SIZ')) {
+			$mem = $stmt->getAttribute(PDO::PGSQL_ATTR_RESULT_MEMORY_SIZE);
+		} else {
+			// If not there emulate a return value which validates our test.
+			$mem = $i < 2 ? 1 : 0;
+		}
+	}
+	echo "ResultSet is $mem bytes long\n";
+	if ($i == 2) {
+		echo "ResultSet is " . ($mem > $mem0 ? "longer" : ($mem == $mem0 ? "not shorter" : ($mem <= $mem0 / 2 ? "more than twice shorter" : "a bit shorter"))) . " than without lazy fetching\n";
+	} else {
+		$mem0 = $mem;
+	}
+}
+
+$pdo->setAttribute(PDO::ATTR_PREFETCH, 0);
+
+foreach ([
+	// @todo Understand why query only returns the first result.
+	//       The statement destructor gets called between the query and the first fetch;
+	//       as such only the first fetch (which is called during query()) stores a result,
+	//       the subsequent ones work on an invalid, freed statement.
+	//[ 'query', 'fetch' ],
+	//[ 'query', 'fetchAll' ],
+	[ 'prepare', 'fetch' ],
+	[ 'prepare', 'fetchAll' ],
+] as $mode) {
+	echo "=== with " . implode(' / ', $mode). " ===\n";
+	switch ($mode[0]) {
+		case 'query':
+			$stmt = $pdo->query($reqOf3);
+			break;
+		case 'prepare':
+			$stmt = $pdo->prepare($reqOf3);
+			$stmt->execute();
+			break;
+	}
+	switch ($mode[1]) {
+		case 'fetch':
+			$res = [];
+			while (($re = $stmt->fetch(PDO::FETCH_ASSOC))) {
+				$res[] = $re;
+			}
+			break;
+		case 'fetchAll':
+			$res = $stmt->fetchAll(PDO::FETCH_ASSOC);
+			break;
+	}
+	var_dump($res);
+}
+echo "without reading the full result set:\n";
+// @todo
+echo "DML works too:\n";
+// @todo
+?>
+--EXPECTF--
+=== mem test ===
+Without lazy fetching:
+ResultSet is %d bytes long
+ResultSet is %d bytes long
+With lazy fetching:
+ResultSet is %d bytes long
+ResultSet is more than twice shorter than without lazy fetching
+=== with prepare / fetch ===
+array(3) {
+  [0]=>
+  array(1) {
+    ["n"]=>
+    string(2) "79"
+  }
+  [1]=>
+  array(1) {
+    ["n"]=>
+    string(2) "80"
+  }
+  [2]=>
+  array(1) {
+    ["n"]=>
+    string(2) "81"
+  }
+}
+=== with prepare / fetchAll ===
+array(3) {
+  [0]=>
+  array(1) {
+    ["n"]=>
+    string(2) "79"
+  }
+  [1]=>
+  array(1) {
+    ["n"]=>
+    string(2) "80"
+  }
+  [2]=>
+  array(1) {
+    ["n"]=>
+    string(2) "81"
+  }
+}
+without reading the full result set:
+DML works too: