dt-sql-parser 4.5.0-beta.2 → 4.5.0

package/README.md

@@ -26,6 +26,7 @@ Additionally, it provides advanced features such as **SQL Validation**, **Code C
 - PostgreSQL
 - Trino
 - Impala
+- GenericSQL
 
 >[!TIP]
 >This project is the default for Typescript target, also you can try to compile it to other languages if you need.
@@ -53,7 +54,7 @@ yarn add dt-sql-parser
 ## Usage
 We recommend learning the fundamentals usage before continuing. The dt-sql-parser library provides SQL classes for different types of SQL.
 ```javascript
-import { MySQL, FlinkSQL, SparkSQL, HiveSQL, PostgreSQL, TrinoSQL, ImpalaSQL } from 'dt-sql-parser';
+import { MySQL, FlinkSQL, SparkSQL, HiveSQL, PostgreSQL, TrinoSQL, ImpalaSQL, GenericSQL } from 'dt-sql-parser';
 ```
 
 Before using syntax validation, code completion, and other features, it is necessary to instantiate the Parser of the relevant SQL type.

package/dist/lib/SQLParserBase.d.ts

@@ -4,5 +4,17 @@ export declare abstract class SQLParserBase<T = antlr.ParserRuleContext> extends
     abstract program(): T;
     caretTokenIndex: number;
     entityCollecting: boolean;
-    shouldMatchEmpty(): boolean;
+    /**
+     * Semantic predicate to determine whether to match empty column.
+     *
+     * Key design:
+     * 1. Only match empty column in entityCollecting mode
+     * 2. Check if caret position is at the empty column position
+     * 3. In validate mode (entityCollecting=false), this predicate returns false
+     *    and reports an error to ensure incomplete SQL is caught
+     *
+     * IMPORTANT: This predicate should be used carefully to avoid affecting
+     * prediction in non-entity-collecting contexts.
+     */
+    shouldMatchEmpty(ruleName?: string): boolean;
 }

package/dist/lib/SQLParserBase.js

@@ -5,10 +5,45 @@ export class SQLParserBase extends antlr.Parser {
         this.caretTokenIndex = -1;
         this.entityCollecting = false;
     }
-    shouldMatchEmpty() {
-        var _a, _b, _c, _d;
-        return this.entityCollecting
-            && ((_b = (_a = this.tokenStream.LT(-1)) === null || _a === void 0 ? void 0 : _a.tokenIndex) !== null && _b !== void 0 ? _b : Infinity) <= this.caretTokenIndex
-            && ((_d = (_c = this.tokenStream.LT(1)) === null || _c === void 0 ? void 0 : _c.tokenIndex) !== null && _d !== void 0 ? _d : -Infinity) >= this.caretTokenIndex;
+    /**
+     * Semantic predicate to determine whether to match empty column.
+     *
+     * Key design:
+     * 1. Only match empty column in entityCollecting mode
+     * 2. Check if caret position is at the empty column position
+     * 3. In validate mode (entityCollecting=false), this predicate returns false
+     *    and reports an error to ensure incomplete SQL is caught
+     *
+     * IMPORTANT: This predicate should be used carefully to avoid affecting
+     * prediction in non-entity-collecting contexts.
+     */
+    shouldMatchEmpty(ruleName) {
+        var _a, _b;
+        // Only match in entityCollecting mode or when caret position is specified (suggestion mode)
+        if (this.entityCollecting || this.caretTokenIndex >= 0) {
+            // If no caret position specified, match all empty columns
+            if (this.caretTokenIndex < 0) {
+                return true;
+            }
+            // Check if caret is at the position where empty column would be
+            const prevTokenIndex = (_a = this.tokenStream.LT(-1)) === null || _a === void 0 ? void 0 : _a.tokenIndex;
+            const nextTokenIndex = (_b = this.tokenStream.LT(1)) === null || _b === void 0 ? void 0 : _b.tokenIndex;
+            // Match if caret is between previous and next token
+            if (prevTokenIndex !== undefined && nextTokenIndex !== undefined) {
+                return prevTokenIndex <= this.caretTokenIndex && nextTokenIndex >= this.caretTokenIndex;
+            }
+            // If only previous token exists, match if caret is after it
+            if (prevTokenIndex !== undefined) {
+                return prevTokenIndex <= this.caretTokenIndex;
+            }
+            // If only next token exists, match if caret is before it
+            if (nextTokenIndex !== undefined) {
+                return nextTokenIndex >= this.caretTokenIndex;
+            }
+            return false;
+        }
+        // In pure validate mode, don't match empty columns
+        // This allows ANTLR to report errors naturally
+        return false;
     }
 }