Fixed case where operators containing question mark were erroneously substituted by the parameter parser (#40)

Author: Bilge

src/Internal/functions.php

@@ -5,12 +5,28 @@
 use function Amp\Postgres\cast;
 
 const STATEMENT_PARAM_REGEX = <<<'REGEX'
-~(["'`])(?:\\(?:\\|\1)|(?!\1).)*+\1(*SKIP)(*FAIL)|(\$(\d+)|\?)|(?<!:):([a-zA-Z_][a-zA-Z0-9_]*)~ms
+[
+    # Skip all quoted groups.
+    (['"])(?:\\(?:\\|\1)|(?!\1).)*+\1(*SKIP)(*FAIL)
+    |
+    # Unnamed parameters.
+    (
+        \$(\d+)
+        |
+        # Match all question marks except those surrounded by "operator"-class characters on either side.
+        (?<!(?<operators>[-+\\*/<>~!@#%^&|`?]))
+        \?
+        (?!\g<operators>|=)
+    )
+    |
+    # Named parameters.
+    (?<!:):([a-zA-Z_][a-zA-Z0-9_]*)
+]msxS
 REGEX;
 
 /**
  * @param string $sql SQL statement with named and unnamed placeholders.
- * @param array $names [Output] Array of parameter positions mapped to names and/or indexed locations.
+ * @param array|null $names [Output] Array of parameter positions mapped to names and/or indexed locations.
  *
  * @return string SQL statement with Postgres-style placeholders
  */
@@ -21,7 +37,7 @@ function parseNamedParams(string $sql, ?array &$names): string
         static $index = 0, $unnamed = 0, $numbered = 1;
 
         if (isset($matches[4])) {
-            $names[$index] = $matches[4];
+            $names[$index] = $matches[5];
         } elseif ($matches[2] === '?') {
             $names[$index] = $unnamed++;
         } else {

test/InternalFunctionsTest.php

@@ -0,0 +1,63 @@
+<?php
+declare(strict_types=1);
+
+namespace Amp\Postgres\Test;
+
+use PHPUnit\Framework\TestCase;
+use function Amp\Postgres\Internal\parseNamedParams;
+
+final class InternalFunctionsTest extends TestCase
+{
+    /**
+     * Tests that unnamed parameters are substituted correctly.
+     *
+     * @see parseNamedParams
+     * @dataProvider provideUnnamedParams
+     */
+    public function testParseUnnamedParams(string $sqlIn, string $sqlOut): void
+    {
+        self::assertSame($sqlOut, parseNamedParams($sqlIn, $dummy));
+    }
+
+    public function provideUnnamedParams(): iterable
+    {
+        return [
+            'Bare' => ['SELECT ?', 'SELECT $1'],
+            'Parenthesized' => ['SELECT (?)', 'SELECT ($1)'],
+            'Row constructor' => ['SELECT (?, ?)', 'SELECT ($1, $2)'],
+            // Special-case exclude the =? operator to permit the following usage.
+            '=? operator' => ['UPDATE foo SET bar=?', 'UPDATE foo SET bar=$1']
+        ];
+    }
+
+    /**
+     * Tests that operators containing the question mark character, that could be confused with unnamed parameters,
+     * are parsed correctly.
+     *
+     * @see parseNamedParams
+     * @see https://github.com/amphp/postgres/issues/39
+     * @dataProvider provideProblematicOperators
+     */
+    public function testParseProblematicOperators(string $sql): void
+    {
+        self::assertSame($sql, parseNamedParams($sql, $dummy));
+    }
+
+    public function provideProblematicOperators(): iterable
+    {
+        return [
+            // JSONB operators. https://postgresql.org/docs/12/functions-json.html#FUNCTIONS-JSONB-OP-TABLE
+            // Bare question mark currently unsupported. ?| can be used instead.
+            #'?' => ["SELECT WHERE '{\"foo\":null}'::jsonb ? 'foo'"],
+            '?|' => ["SELECT WHERE '{\"foo\":null}'::jsonb ?| array['foo']"],
+            '?&' => ["SELECT WHERE '{\"foo\":null}'::jsonb ?& array['foo']"],
+            '@?' => ["SELECT WHERE '{\"foo\":1}'::jsonb @? '$ ? (@.foo > 0)'"],
+
+            // Geometric operators. https://postgresql.org/docs/12/functions-geometry.html#FUNCTIONS-GEOMETRY-OP-TABLE
+            '?- unary' => ["SELECT WHERE ?- lseg '((-1,0),(1,0))'"],
+            '?-' => ["SELECT WHERE point '(1,0)' ?- point '(0,0)'"],
+            '?-|' => ["SELECT WHERE lseg '((0,0),(0,1))' ?-| lseg '((0,0),(1,0))'"],
+            '?||' => ["SELECT WHERE lseg '((-1,0),(1,0))' ?|| lseg '((-1,2),(1,2))'"],
+        ];
+    }
+}