fix(parser): #283 collect errors from all erroneous statements in multi-statement input

Author: liuxy0551

src/parser/common/basicSQL.ts

@@ -215,14 +215,92 @@ export abstract class BasicSQL<
 
     /**
      * Validate input string and return syntax errors if exists.
+     * When input contains multiple statements separated by semicolons
+     * and the initial parse doesn't capture all errors, each statement
+     * is validated independently to collect all errors.
      * @param input source string
      * @returns syntax errors
      */
     public validate(input: string): ParseError[] {
         this.parseWithCache(input);
+
+        if (this._parseErrors.length > 0) {
+            const statements = this.splitStatements(input);
+            if (statements.length > 1) {
+                const splitErrors = this.validateStatements(statements);
+                if (splitErrors.length > this._parseErrors.length) {
+                    this._parseErrors = splitErrors;
+                }
+            }
+        }
+
         return this._parseErrors;
     }
 
+    /**
+     * Validate each statement fragment independently and collect all errors.
+     */
+    private validateStatements(statements: { text: string; start: number }[]): ParseError[] {
+        const allErrors: ParseError[] = [];
+        let lineOffset = 0;
+        for (const statement of statements) {
+            if (!statement.text.trim()) {
+                const newlines = (statement.text.match(/\n/g) || []).length;
+                lineOffset += newlines;
+                continue;
+            }
+            const parser = this.createParser(statement.text);
+            const errors: ParseError[] = [];
+            parser.removeErrorListeners();
+            parser.addErrorListener(
+                this.createErrorListener((error) => {
+                    errors.push({
+                        startLine: error.startLine + lineOffset,
+                        endLine: error.endLine + lineOffset,
+                        startColumn: error.startColumn,
+                        endColumn: error.endColumn,
+                        message: error.message,
+                    });
+                })
+            );
+            parser.errorHandler = new ErrorStrategy();
+            parser.program();
+            allErrors.push(...errors);
+            const newlines = (statement.text.match(/\n/g) || []).length;
+            lineOffset += newlines;
+        }
+        return allErrors;
+    }
+
+    /**
+     * Split input into individual statement strings by semicolons.
+     * Handles semicolons inside quoted strings correctly.
+     */
+    private splitStatements(input: string): { text: string; start: number }[] {
+        const statements: { text: string; start: number }[] = [];
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let lastSplit = 0;
+
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            if (ch === "'" && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+            } else if (ch === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+            } else if (ch === ';' && !inSingleQuote && !inDoubleQuote) {
+                statements.push({ text: input.slice(lastSplit, i + 1), start: lastSplit });
+                lastSplit = i + 1;
+            }
+        }
+
+        if (lastSplit < input.length) {
+            statements.push({ text: input.slice(lastSplit), start: lastSplit });
+        }
+
+        return statements;
+    }
+
     /**
      * Get the input string that has been parsed.
      */