Replace \z fallbacks with (*PRUNE) for chunk boundary handling

Instead of adding \z to every closing delimiter to make incomplete
constructs extend to end-of-buffer, use PCRE's (*PRUNE) verb after
each opening delimiter. Once the opening delimiter matches (e.g. the
' that starts a string literal), (*PRUNE) commits the regex engine to
that construct — if the closing delimiter is absent (because it is in
a later chunk), the overall match fails rather than falling back to
the single-character alternative. PatternIterator then loads the next
chunk and retries with more data.

This is semantically cleaner: "once you enter a construct, you must
finish it." It also avoids cross-construct interactions — the \z
approach required a PostgreSQL-specific workaround where adding \z to
standard string closings broke E-string parsing.

Behavioral change: malformed SQL with genuinely unclosed constructs at
end-of-input now produces a parse error instead of being silently
absorbed into a query.

Author: JanTvrdik

src/MySqlMultiQueryParser.php

@@ -32,7 +32,7 @@ private function getQueryPattern(string $delimiter): string
 		~
 			(?:
 					\\s
-				|   /\\*  (?: [^*]++ | \\*(?!/) )*+  (?:\\*/|\\z)
+				|   /\\* (*PRUNE) (?: [^*]++ | \\*(?!/) )*+  \\*/
 				|   --[^\\n]*+(?:\\n|\\z)
 			)*+
 
@@ -47,9 +47,9 @@ private function getQueryPattern(string $delimiter): string
 					(?<query>
 						(?:
 								[^$delimiterFirstBytePattern'\"/$-]++
-							|   '                                                     (?: \\\\.    | [^']            )*+ (?:'|\\z)
-							|   \"                                                    (?: \\\\.    | [^\"]           )*+ (?:\"|\\z)
-							|   /\\*                                                  (?: [^*]++   | \\*(?!/)        )*+ (?:\\*/|\\z)
+							|   ' (*PRUNE)                                            (?: \\\\.    | [^']            )*+ '
+							|   \" (*PRUNE)                                           (?: \\\\.    | [^\"]           )*+ \"
+							|   /\\* (*PRUNE)                                         (?: [^*]++   | \\*(?!/)        )*+ \\*/
 							|   --[^\\n]*+(?:\\n|\\z)
 							|   (?!$delimiterPattern) .
 						)*+

src/PatternIterator.php

@@ -20,14 +20,15 @@
  *
  * Pattern design constraint: patterns with opening/closing delimiter constructs (such as
  * string literals `'...'`, block comments `/*...* /`, or dollar-quoted strings `$$...$$`)
- * must include `\z` as a fallback for the closing delimiter, e.g. `' [^']* (?: ' | \z )`.
+ * must include `(*PRUNE)` after the opening delimiter, e.g. `' (*PRUNE) [^']* '`.
  * Without this, when a chunk boundary falls inside such a construct, the closing delimiter
  * is absent from the buffer, the construct fails to match, and the regex falls back to a
  * generic single-character alternative (e.g. `(?!;) .`). This exposes characters inside the
  * construct (like semicolons inside a string) as false delimiters, producing an incorrect
  * match that terminates in the middle of the buffer — where the safety mechanism cannot
- * detect the problem. The `\z` fallback ensures incomplete constructs extend to the end of
- * the buffer, triggering the safety mechanism to wait for more data.
+ * detect the problem. The `(*PRUNE)` verb ensures that once the opening delimiter matches,
+ * the regex engine commits to the construct — if the closing delimiter is missing (because
+ * it is in a later chunk), the overall match fails, causing the iterator to load more data.
  *
  * @implements IteratorAggregate<int, array<mixed>>
  */

src/PostgreSqlMultiQueryParser.php

@@ -27,7 +27,7 @@ private function getQueryPattern(): string
 		return /** @lang PhpRegExp */ '~
 			(?:
 					\\s
-				|   /\\*                                                            (?: [^*]++   | \\*(?!/)       )*+ (?:\\*/|\\z)
+				|   /\\* (*PRUNE)                                                   (?: [^*]++   | \\*(?!/)       )*+ \\*/
 				|   -- [^\\n]*+
 			)*+
 
@@ -36,11 +36,11 @@ private function getQueryPattern(): string
 					(?<query>
 						(?:
 								(?:[^;\'"/$eE-]|[eE](?!\'))++
-							|   \'                                                  (?: [^\']                     )*+ (?:\'|\\z)
-							|   [eE]\'                                              (?: \\\\.    | [^\']          )*+ (?:\'|\\z)
-							|   "                                                   (?: [^"]                      )*+ (?:"|\\z)
-							|   /\\*                                                (?: [^*]++   | \\*(?!/)       )*+ (?:\\*/|\\z)
-							|   (\\$(?:[a-zA-Z_\\x80-\\xFF][\\w\\x80-\\xFF]*+)?\\$) (?: [^$]++   | (?!\\g{-1})\\$ )*+ (?: \\g{-1} | \\z )
+							|   \' (*PRUNE)                                         (?: [^\']                     )*+ \'
+							|   [eE]\' (*PRUNE)                                     (?: \\\\.    | [^\']          )*+ \'
+							|   " (*PRUNE)                                          (?: [^"]                      )*+ "
+							|   /\\* (*PRUNE)                                       (?: [^*]++   | \\*(?!/)       )*+ \\*/
+							|   (\\$(?:[a-zA-Z_\\x80-\\xFF][\\w\\x80-\\xFF]*+)?\\$) (*PRUNE) (?: [^$]++   | (?!\\g{-1})\\$ )*+ \\g{-1}
 							|   -- [^\\n]*+
 							|   (?!;) .
 						)*+

src/SqlServerMultiQueryParser.php

@@ -24,15 +24,15 @@ private function getQueryPattern(): string
 		$simpleQuery = /** @lang PhpRegExp */ '~
 			(?:
 					\\s
-				|   /\\* (?: [^*]++   | \\*(?!/) )*+ (?:\\*/|\\z)
+				|   /\\* (*PRUNE) (?: [^*]++   | \\*(?!/) )*+ \\*/
 				|   -- [^\\n]*+
 			)*+
 			(?<simplequery>
 				(?:
 						[^;\'"[/-]++
-					|   \'                                                  (?: [^\']                     )*+ (?:\'|\\z)
-					|   "                                                   (?: [^"]                      )*+ (?:"|\\z)
-					|   /\\*                                                (?: [^*]++   | \\*(?!/)       )*+ (?:\\*/|\\z)
+					|   \' (*PRUNE)                                         (?: [^\']                     )*+ \'
+					|   " (*PRUNE)                                          (?: [^"]                      )*+ "
+					|   /\\* (*PRUNE)                                       (?: [^*]++   | \\*(?!/)       )*+ \\*/
 					|   -- [^\\n]*+
 					|   (?!;) .
 				)++
@@ -42,7 +42,7 @@ private function getQueryPattern(): string
 		return /** @lang PhpRegExp */ '~
 			(?:
 					\\s
-				|   /\\* (?: [^*]++   | \\*(?!/) )*+ (?:\\*/|\\z)
+				|   /\\* (*PRUNE) (?: [^*]++   | \\*(?!/) )*+ \\*/
 				|   -- [^\\n]*+
 			)*+
 
@@ -51,9 +51,9 @@ private function getQueryPattern(): string
 					(?<query>
 						(?:
 							 	[^B;\'"[/-]++
-							|   \'                                                  (?: [^\']                     )*+ (?:\'|\\z)
-							|   "                                                   (?: [^"]                      )*+ (?:"|\\z)
-							|   /\\*                                                (?: [^*]++   | \\*(?!/)       )*+ (?:\\*/|\\z)
+							|   \' (*PRUNE)                                         (?: [^\']                     )*+ \'
+							|   " (*PRUNE)                                          (?: [^"]                      )*+ "
+							|   /\\* (*PRUNE)                                       (?: [^*]++   | \\*(?!/)       )*+ \\*/
 							|   BEGIN (?: \s*END\s*| ' . substr($simpleQuery, 1, -2) . ')*
 							|   -- [^\\n]*+
 							|   (?!;) .