feat: extend support of REGEXP_LIKE(), REGEXP_MATCH() and REGEXP_REPLACE() while deprecating the legacy limited flagged variations of FlaggedRegexpLike, FlaggedRegexpMatch and FlaggedRegexpReplace (#357)

martin-georgiev · web-flow · commit ef688dc2d62c · 2025-04-22T18:25:41.000Z
diff --git a/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseRegexpFunction.php b/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseRegexpFunction.php
diff --git a/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpLike.php b/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpLike.php
@@ -5,8 +5,9 @@
 namespace MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;
 
 /**
- * Implementation of PostgreSQL REGEXP_LIKE() with flags.
+ * @deprecated This function will be dropped in v4.0. Use RegexpLike instead.
  *
+ * Implementation of PostgreSQL REGEXP_LIKE() with flags.
  * @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP
  * @see https://www.postgresql.org/docs/15/functions-matching.html#POSIX-EMBEDDED-OPTIONS-TABLE
  * @since 2.0
@@ -17,7 +18,7 @@ class FlaggedRegexpLike extends BaseFunction
 {
     protected function customizeFunction(): void
     {
-        $this->setFunctionPrototype('regexp_like(%s, %s, 1, %s)');
+        $this->setFunctionPrototype('regexp_like(%s, %s, %s)');
         $this->addNodeMapping('StringPrimary');
         $this->addNodeMapping('StringPrimary');
         $this->addNodeMapping('StringPrimary');
diff --git a/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpMatch.php b/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpMatch.php
@@ -5,8 +5,9 @@
 namespace MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;
 
 /**
- * Implementation of PostgreSQL REGEXP_MATCH() with flags.
+ * @deprecated This function will be dropped in v4.0. Use RegexpMatch instead.
  *
+ * Implementation of PostgreSQL REGEXP_MATCH() with flags.
  * @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP
  * @see https://www.postgresql.org/docs/15/functions-matching.html#POSIX-EMBEDDED-OPTIONS-TABLE
  * @since 2.0
diff --git a/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpReplace.php b/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpReplace.php
@@ -5,8 +5,9 @@
 namespace MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;
 
 /**
- * Implementation of PostgreSQL REGEXP_REPLACE().
+ * @deprecated This function will be dropped in v4.0. Use RegexpReplace instead.
  *
+ * Implementation of PostgreSQL REGEXP_REPLACE().
  * @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP
  * @since 2.5
  *
diff --git a/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpLike.php b/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpLike.php
@@ -7,20 +7,36 @@
 /**
  * Implementation of PostgreSQL REGEXP_LIKE().
  *
- * @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP
+ * Returns true if a string matches a POSIX regular expression pattern, or false if it does not.
+ *
+ * @see https://www.postgresql.org/docs/17/functions-matching.html#FUNCTIONS-POSIX-REGEXP
  * @since 2.0
  *
  * @author Martin Georgiev <martin.georgiev@gmail.com>
+ *
+ * @example Using it in DQL: "SELECT REGEXP_LIKE(e.text, 'pattern', 'i') FROM Entity e"
  */
-class RegexpLike extends BaseRegexpFunction
+class RegexpLike extends BaseVariadicFunction
 {
+    protected function getNodeMappingPattern(): array
+    {
+        return [
+            'StringPrimary',
+        ];
+    }
+
     protected function getFunctionName(): string
     {
         return 'regexp_like';
     }
 
-    protected function getParameterCount(): int
+    protected function getMinArgumentCount(): int
     {
         return 2;
     }
+
+    protected function getMaxArgumentCount(): int
+    {
+        return 3;
+    }
 }
diff --git a/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpMatch.php b/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpMatch.php
@@ -7,20 +7,36 @@
 /**
  * Implementation of PostgreSQL REGEXP_MATCH().
  *
- * @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP
+ * Returns the first substring(s) that match a POSIX regular expression pattern, or NULL if there is no match.
+ *
+ * @see https://www.postgresql.org/docs/17/functions-matching.html#FUNCTIONS-POSIX-REGEXP
  * @since 2.0
  *
  * @author Martin Georgiev <martin.georgiev@gmail.com>
+ *
+ * @example Using it in DQL: "SELECT REGEXP_MATCH(e.text, 'pattern', 'i') FROM Entity e"
  */
-class RegexpMatch extends BaseRegexpFunction
+class RegexpMatch extends BaseVariadicFunction
 {
+    protected function getNodeMappingPattern(): array
+    {
+        return [
+            'StringPrimary',
+        ];
+    }
+
     protected function getFunctionName(): string
     {
         return 'regexp_match';
     }
 
-    protected function getParameterCount(): int
+    protected function getMinArgumentCount(): int
     {
         return 2;
     }
+
+    protected function getMaxArgumentCount(): int
+    {
+        return 3;
+    }
 }
diff --git a/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpReplace.php b/src/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpReplace.php
@@ -13,20 +13,25 @@
  * @since 2.5
  *
  * @author Colin Doig
+ * @author Martin Georgiev <martin.georgiev@gmail.com>
  *
  * @example Using it in DQL: "SELECT REGEXP_REPLACE(e.text, 'pattern', 'replacement', 3, 2, 'i') FROM Entity e"
  */
 class RegexpReplace extends BaseVariadicFunction
 {
     protected function getNodeMappingPattern(): array
     {
+        /*
+         * PostgreSQL overloads the 4th argument depending on its type:
+         *   - if the 4th arg is a string, it’s taken as flags.
+         *   - if the 4th arg is an integer, it’s taken as start position. This can be extended with the Nth argument.
+         */
         return [
-            'StringPrimary,StringPrimary,StringPrimary,ArithmeticPrimary,ArithmeticPrimary,StringPrimary',
-            'StringPrimary,StringPrimary,StringPrimary,ArithmeticPrimary,ArithmeticPrimary',
-            'StringPrimary,StringPrimary,StringPrimary,ArithmeticPrimary,StringPrimary',
-            'StringPrimary,StringPrimary,StringPrimary,ArithmeticPrimary',
-            'StringPrimary,StringPrimary,StringPrimary,StringPrimary',
-            'StringPrimary,StringPrimary,StringPrimary',
+            'StringPrimary,StringPrimary,StringPrimary,ArithmeticPrimary,ArithmeticPrimary,StringPrimary', // with start, N and flags: regexp_replace(string, pattern, replacement, 3, 2, 'i')
+            'StringPrimary,StringPrimary,StringPrimary,ArithmeticPrimary,ArithmeticPrimary', // with start and N: regexp_replace(string, pattern, replacement, 3, 2)
+            'StringPrimary,StringPrimary,StringPrimary,ArithmeticPrimary', // with start: regexp_replace(string, pattern, replacement, 3)
+            'StringPrimary,StringPrimary,StringPrimary,StringPrimary', // with flags: regexp_replace(string, pattern, replacement, 'i')
+            'StringPrimary,StringPrimary,StringPrimary', // basic replacement: regexp_replace(string, pattern, replacement)
         ];
     }
 
diff --git a/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseVariadicFunctionTestCase.php b/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/BaseVariadicFunctionTestCase.php
@@ -28,7 +28,7 @@ public function throws_an_exception_when_lexer_is_not_populated_with_a_lookahead
             ->willReturn(new Configuration());
 
         $query = new Query($em);
-        $query->setDQL('TRUE');
+        $query->setDQL('SELECT 1');
 
         $parser = new Parser($query);
         $parser->getLexer()->moveNext();
diff --git a/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpLikeTest.php b/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpLikeTest.php
@@ -12,14 +12,14 @@ class FlaggedRegexpLikeTest extends TestCase
     protected function getStringFunctions(): array
     {
         return [
-            'FLAGGED_REGEXP_LIKE' => FlaggedRegexpLike::class,
+            'FLAGGED_REGEXP_LIKE' => FlaggedRegexpLike::class, // @phpstan-ignore-line
         ];
     }
 
     protected function getExpectedSqlStatements(): array
     {
         return [
-            "SELECT regexp_like(c0_.text1, 'pattern', 1, 'i') AS sclr_0 FROM ContainsTexts c0_",
+            "SELECT regexp_like(c0_.text1, 'pattern', 'i') AS sclr_0 FROM ContainsTexts c0_",
         ];
     }
 
diff --git a/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpMatchTest.php b/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpMatchTest.php
@@ -12,7 +12,7 @@ class FlaggedRegexpMatchTest extends TestCase
     protected function getStringFunctions(): array
     {
         return [
-            'FLAGGED_REGEXP_MATCH' => FlaggedRegexpMatch::class,
+            'FLAGGED_REGEXP_MATCH' => FlaggedRegexpMatch::class, // @phpstan-ignore-line
         ];
     }
 
diff --git a/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpReplaceTest.php b/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/FlaggedRegexpReplaceTest.php
@@ -12,7 +12,7 @@ class FlaggedRegexpReplaceTest extends TestCase
     protected function getStringFunctions(): array
     {
         return [
-            'FLAGGED_REGEXP_REPLACE' => FlaggedRegexpReplace::class,
+            'FLAGGED_REGEXP_REPLACE' => FlaggedRegexpReplace::class, // @phpstan-ignore-line
         ];
     }
 
diff --git a/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpLikeTest.php b/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpLikeTest.php
@@ -5,10 +5,17 @@
 namespace Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;
 
 use Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsTexts;
+use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BaseVariadicFunction;
+use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Exception\InvalidArgumentForVariadicFunctionException;
 use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpLike;
 
-class RegexpLikeTest extends TestCase
+class RegexpLikeTest extends BaseVariadicFunctionTestCase
 {
+    protected function createFixture(): BaseVariadicFunction
+    {
+        return new RegexpLike('REGEXP_LIKE');
+    }
+
     protected function getStringFunctions(): array
     {
         return [
@@ -19,14 +26,34 @@ protected function getStringFunctions(): array
     protected function getExpectedSqlStatements(): array
     {
         return [
-            "SELECT regexp_like(c0_.text1, 'pattern') AS sclr_0 FROM ContainsTexts c0_",
+            'basic match' => "SELECT regexp_like(c0_.text1, 'pattern') AS sclr_0 FROM ContainsTexts c0_",
+            'with flags' => "SELECT regexp_like(c0_.text1, 'pattern', 'i') AS sclr_0 FROM ContainsTexts c0_",
         ];
     }
 
     protected function getDqlStatements(): array
     {
         return [
-            \sprintf("SELECT REGEXP_LIKE(e.text1, 'pattern') FROM %s e", ContainsTexts::class),
+            'basic match' => \sprintf("SELECT REGEXP_LIKE(e.text1, 'pattern') FROM %s e", ContainsTexts::class),
+            'with flags' => \sprintf("SELECT REGEXP_LIKE(e.text1, 'pattern', 'i') FROM %s e", ContainsTexts::class),
         ];
     }
+
+    public function test_too_few_arguments_throws_exception(): void
+    {
+        $this->expectException(InvalidArgumentForVariadicFunctionException::class);
+        $this->expectExceptionMessage('regexp_like() requires at least 2 arguments');
+
+        $dql = \sprintf('SELECT REGEXP_LIKE(e.text1) FROM %s e', ContainsTexts::class);
+        $this->buildEntityManager()->createQuery($dql)->getSQL();
+    }
+
+    public function test_too_many_arguments_throws_exception(): void
+    {
+        $this->expectException(InvalidArgumentForVariadicFunctionException::class);
+        $this->expectExceptionMessage('regexp_like() requires between 2 and 3 arguments');
+
+        $dql = \sprintf("SELECT REGEXP_LIKE(e.text1, 'pattern', 'i', 'extra_arg') FROM %s e", ContainsTexts::class);
+        $this->buildEntityManager()->createQuery($dql)->getSQL();
+    }
 }
diff --git a/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpMatchTest.php b/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpMatchTest.php
@@ -5,10 +5,17 @@
 namespace Tests\MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;
 
 use Fixtures\MartinGeorgiev\Doctrine\Entity\ContainsTexts;
+use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\BaseVariadicFunction;
+use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\Exception\InvalidArgumentForVariadicFunctionException;
 use MartinGeorgiev\Doctrine\ORM\Query\AST\Functions\RegexpMatch;
 
-class RegexpMatchTest extends TestCase
+class RegexpMatchTest extends BaseVariadicFunctionTestCase
 {
+    protected function createFixture(): BaseVariadicFunction
+    {
+        return new RegexpMatch('REGEXP_MATCH');
+    }
+
     protected function getStringFunctions(): array
     {
         return [
@@ -19,14 +26,34 @@ protected function getStringFunctions(): array
     protected function getExpectedSqlStatements(): array
     {
         return [
-            "SELECT regexp_match(c0_.text1, 'pattern') AS sclr_0 FROM ContainsTexts c0_",
+            'basic match' => "SELECT regexp_match(c0_.text1, 'pattern') AS sclr_0 FROM ContainsTexts c0_",
+            'with flags' => "SELECT regexp_match(c0_.text1, 'pattern', 'i') AS sclr_0 FROM ContainsTexts c0_",
         ];
     }
 
     protected function getDqlStatements(): array
     {
         return [
-            \sprintf("SELECT REGEXP_MATCH(e.text1, 'pattern') FROM %s e", ContainsTexts::class),
+            'basic match' => \sprintf("SELECT REGEXP_MATCH(e.text1, 'pattern') FROM %s e", ContainsTexts::class),
+            'with flags' => \sprintf("SELECT REGEXP_MATCH(e.text1, 'pattern', 'i') FROM %s e", ContainsTexts::class),
         ];
     }
+
+    public function test_too_few_arguments_throws_exception(): void
+    {
+        $this->expectException(InvalidArgumentForVariadicFunctionException::class);
+        $this->expectExceptionMessage('regexp_match() requires at least 2 arguments');
+
+        $dql = \sprintf('SELECT REGEXP_MATCH(e.text1) FROM %s e', ContainsTexts::class);
+        $this->buildEntityManager()->createQuery($dql)->getSQL();
+    }
+
+    public function test_too_many_arguments_throws_exception(): void
+    {
+        $this->expectException(InvalidArgumentForVariadicFunctionException::class);
+        $this->expectExceptionMessage('regexp_match() requires between 2 and 3 arguments');
+
+        $dql = \sprintf("SELECT REGEXP_MATCH(e.text1, 'pattern', 'i', 'extra_arg') FROM %s e", ContainsTexts::class);
+        $this->buildEntityManager()->createQuery($dql)->getSQL();
+    }
 }
diff --git a/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpReplaceTest.php b/tests/MartinGeorgiev/Doctrine/ORM/Query/AST/Functions/RegexpReplaceTest.php
@@ -29,7 +29,6 @@ protected function getExpectedSqlStatements(): array
             'basic replacement' => "SELECT regexp_replace(c0_.text1, 'pattern', 'replacement') AS sclr_0 FROM ContainsTexts c0_",
             'with flags but no start position' => "SELECT regexp_replace(c0_.text1, 'pattern', 'replacement', 'i') AS sclr_0 FROM ContainsTexts c0_",
             'with start position' => "SELECT regexp_replace(c0_.text1, 'pattern', 'replacement', 3) AS sclr_0 FROM ContainsTexts c0_",
-            'with start position and flags' => "SELECT regexp_replace(c0_.text1, 'pattern', 'replacement', 3, 'i') AS sclr_0 FROM ContainsTexts c0_",
             'with occurrence count but no flags' => "SELECT regexp_replace(c0_.text1, 'pattern', 'replacement', 3, 2) AS sclr_0 FROM ContainsTexts c0_",
             'with occurrence count and flags' => "SELECT regexp_replace(c0_.text1, 'pattern', 'replacement', 3, 2, 'i') AS sclr_0 FROM ContainsTexts c0_",
         ];
@@ -41,7 +40,6 @@ protected function getDqlStatements(): array
             'basic replacement' => \sprintf("SELECT REGEXP_REPLACE(e.text1, 'pattern', 'replacement') FROM %s e", ContainsTexts::class),
             'with flags but no start position' => \sprintf("SELECT REGEXP_REPLACE(e.text1, 'pattern', 'replacement', 'i') FROM %s e", ContainsTexts::class),
             'with start position' => \sprintf("SELECT REGEXP_REPLACE(e.text1, 'pattern', 'replacement', 3) FROM %s e", ContainsTexts::class),
-            'with start position and flags' => \sprintf("SELECT REGEXP_REPLACE(e.text1, 'pattern', 'replacement', 3, 'i') FROM %s e", ContainsTexts::class),
             'with occurrence count but no flags' => \sprintf("SELECT REGEXP_REPLACE(e.text1, 'pattern', 'replacement', 3, 2) FROM %s e", ContainsTexts::class),
             'with occurrence count and flags' => \sprintf("SELECT REGEXP_REPLACE(e.text1, 'pattern', 'replacement', 3, 2, 'i') FROM %s e", ContainsTexts::class),
         ];

Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,9 @@`
`5`	`5`	`namespace MartinGeorgiev\Doctrine\ORM\Query\AST\Functions;`
`6`	`6`
`7`	`7`	`/**`
`8`		`- * Implementation of PostgreSQL REGEXP_LIKE() with flags.`
	`8`	`+ * @deprecated This function will be dropped in v4.0. Use RegexpLike instead.`
`9`	`9`	`*`
	`10`	`+ * Implementation of PostgreSQL REGEXP_LIKE() with flags.`
`10`	`11`	`* @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP`
`11`	`12`	`* @see https://www.postgresql.org/docs/15/functions-matching.html#POSIX-EMBEDDED-OPTIONS-TABLE`
`12`	`13`	`* @since 2.0`
`@@ -17,7 +18,7 @@ class FlaggedRegexpLike extends BaseFunction`
`17`	`18`	`{`
`18`	`19`	`protected function customizeFunction(): void`
`19`	`20`	`{`
`20`		`- $this->setFunctionPrototype('regexp_like(%s, %s, 1, %s)');`
	`21`	`+ $this->setFunctionPrototype('regexp_like(%s, %s, %s)');`
`21`	`22`	`$this->addNodeMapping('StringPrimary');`
`22`	`23`	`$this->addNodeMapping('StringPrimary');`
`23`	`24`	`$this->addNodeMapping('StringPrimary');`
Original file line number	Diff line number	Diff line change
`@@ -7,20 +7,36 @@`
`7`	`7`	`/**`
`8`	`8`	`* Implementation of PostgreSQL REGEXP_LIKE().`
`9`	`9`	`*`
`10`		`- * @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP`
	`10`	`+ * Returns true if a string matches a POSIX regular expression pattern, or false if it does not.`
	`11`	`+ *`
	`12`	`+ * @see https://www.postgresql.org/docs/17/functions-matching.html#FUNCTIONS-POSIX-REGEXP`
`11`	`13`	`* @since 2.0`
`12`	`14`	`*`
`13`	`15`	`* @author Martin Georgiev <martin.georgiev@gmail.com>`
	`16`	`+ *`
	`17`	`+ * @example Using it in DQL: "SELECT REGEXP_LIKE(e.text, 'pattern', 'i') FROM Entity e"`
`14`	`18`	`*/`
`15`		`-class RegexpLike extends BaseRegexpFunction`
	`19`	`+class RegexpLike extends BaseVariadicFunction`
`16`	`20`	`{`
	`21`	`+ protected function getNodeMappingPattern(): array`
	`22`	`+ {`
	`23`	`+ return [`
	`24`	`+ 'StringPrimary',`
	`25`	`+ ];`
	`26`	`+ }`
	`27`	`+`
`17`	`28`	`protected function getFunctionName(): string`
`18`	`29`	`{`
`19`	`30`	`return 'regexp_like';`
`20`	`31`	`}`
`21`	`32`
`22`		`- protected function getParameterCount(): int`
	`33`	`+ protected function getMinArgumentCount(): int`
`23`	`34`	`{`
`24`	`35`	`return 2;`
`25`	`36`	`}`
	`37`	`+`
	`38`	`+ protected function getMaxArgumentCount(): int`
	`39`	`+ {`
	`40`	`+ return 3;`
	`41`	`+ }`
`26`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,20 +7,36 @@`
`7`	`7`	`/**`
`8`	`8`	`* Implementation of PostgreSQL REGEXP_MATCH().`
`9`	`9`	`*`
`10`		`- * @see https://www.postgresql.org/docs/15/functions-matching.html#FUNCTIONS-POSIX-REGEXP`
	`10`	`+ * Returns the first substring(s) that match a POSIX regular expression pattern, or NULL if there is no match.`
	`11`	`+ *`
	`12`	`+ * @see https://www.postgresql.org/docs/17/functions-matching.html#FUNCTIONS-POSIX-REGEXP`
`11`	`13`	`* @since 2.0`
`12`	`14`	`*`
`13`	`15`	`* @author Martin Georgiev <martin.georgiev@gmail.com>`
	`16`	`+ *`
	`17`	`+ * @example Using it in DQL: "SELECT REGEXP_MATCH(e.text, 'pattern', 'i') FROM Entity e"`
`14`	`18`	`*/`
`15`		`-class RegexpMatch extends BaseRegexpFunction`
	`19`	`+class RegexpMatch extends BaseVariadicFunction`
`16`	`20`	`{`
	`21`	`+ protected function getNodeMappingPattern(): array`
	`22`	`+ {`
	`23`	`+ return [`
	`24`	`+ 'StringPrimary',`
	`25`	`+ ];`
	`26`	`+ }`
	`27`	`+`
`17`	`28`	`protected function getFunctionName(): string`
`18`	`29`	`{`
`19`	`30`	`return 'regexp_match';`
`20`	`31`	`}`
`21`	`32`
`22`		`- protected function getParameterCount(): int`
	`33`	`+ protected function getMinArgumentCount(): int`
`23`	`34`	`{`
`24`	`35`	`return 2;`
`25`	`36`	`}`
	`37`	`+`
	`38`	`+ protected function getMaxArgumentCount(): int`
	`39`	`+ {`
	`40`	`+ return 3;`
	`41`	`+ }`
`26`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,14 +12,14 @@ class FlaggedRegexpLikeTest extends TestCase`
`12`	`12`	`protected function getStringFunctions(): array`
`13`	`13`	`{`
`14`	`14`	`return [`
`15`		`- 'FLAGGED_REGEXP_LIKE' => FlaggedRegexpLike::class,`
	`15`	`+ 'FLAGGED_REGEXP_LIKE' => FlaggedRegexpLike::class, // @phpstan-ignore-line`
`16`	`16`	`];`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`protected function getExpectedSqlStatements(): array`
`20`	`20`	`{`
`21`	`21`	`return [`
`22`		`- "SELECT regexp_like(c0_.text1, 'pattern', 1, 'i') AS sclr_0 FROM ContainsTexts c0_",`
	`22`	`+ "SELECT regexp_like(c0_.text1, 'pattern', 'i') AS sclr_0 FROM ContainsTexts c0_",`
`23`	`23`	`];`
`24`	`24`	`}`
`25`	`25`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ class FlaggedRegexpMatchTest extends TestCase`
`12`	`12`	`protected function getStringFunctions(): array`
`13`	`13`	`{`
`14`	`14`	`return [`
`15`		`- 'FLAGGED_REGEXP_MATCH' => FlaggedRegexpMatch::class,`
	`15`	`+ 'FLAGGED_REGEXP_MATCH' => FlaggedRegexpMatch::class, // @phpstan-ignore-line`
`16`	`16`	`];`
`17`	`17`	`}`
`18`	`18`