feat: improve other sql error msg

LuckyFBB · LuckyFBB · commit 37440cf4dffc · 2024-03-28T17:48:39.000+08:00
diff --git a/src/parser/common/basicSQL.ts b/src/parser/common/basicSQL.ts
@@ -15,7 +15,7 @@ import { SQLParserBase } from '../../lib/SQLParserBase';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord, WordRange, TextSlice } from './textAndWord';
 import { CaretPosition, Suggestions, SyntaxSuggestion } from './types';
-import { ParseError, ErrorListener, ParseErrorListener } from './parseErrorListener';
+import { ParseError, ErrorListener } from './parseErrorListener';
 import { ErrorStrategy } from './errorStrategy';
 import type { SplitListener } from './splitListener';
 import type { EntityCollector } from './entityCollector';
@@ -82,7 +82,7 @@ export abstract class BasicSQL<
     /**
      * Get a new errorListener instance.
      */
-    protected abstract createErrorListener(errorListener: ErrorListener<any>): ANTLRErrorListener;
+    protected abstract createErrorListener(errorListener: ErrorListener): ANTLRErrorListener;
 
     /**
      * Get a new entityCollector instance.
diff --git a/src/parser/flink/flinkErrorListener.ts b/src/parser/flink/flinkErrorListener.ts
@@ -0,0 +1,78 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { Parser, Token } from 'antlr4ng';
+import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
+
+export class FlinkErrorListener extends ParseErrorListener {
+    private preferredRules: Set<number>;
+
+    private objectNames: Map<number, string> = new Map([
+        [FlinkSqlParser.RULE_catalogPath, 'catalog'],
+        [FlinkSqlParser.RULE_databasePath, 'database'],
+        [FlinkSqlParser.RULE_databasePathCreate, 'database'],
+        [FlinkSqlParser.RULE_tablePath, 'table'],
+        [FlinkSqlParser.RULE_tablePathCreate, 'table'],
+        [FlinkSqlParser.RULE_viewPath, 'view'],
+        [FlinkSqlParser.RULE_viewPathCreate, 'view'],
+        [FlinkSqlParser.RULE_functionName, 'function'],
+        [FlinkSqlParser.RULE_functionNameCreate, 'function'],
+        [FlinkSqlParser.RULE_columnName, 'column'],
+        [FlinkSqlParser.RULE_columnNameCreate, 'column'],
+    ]);
+
+    constructor(errorListener: ErrorListener, preferredRules: Set<number>) {
+        super(errorListener);
+        this.preferredRules = preferredRules;
+    }
+
+    public getExpectedText(parser: Parser, token: Token) {
+        let expectedText = '';
+
+        let currentContext = parser.context ?? undefined;
+        while (currentContext?.parent) {
+            currentContext = currentContext.parent;
+        }
+
+        const core = new CodeCompletionCore(parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+
+        if (candidates.rules.size) {
+            // get expectedText as collect rules first
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case FlinkSqlParser.RULE_databasePath:
+                    case FlinkSqlParser.RULE_tablePath:
+                    case FlinkSqlParser.RULE_viewPath:
+                    case FlinkSqlParser.RULE_functionName:
+                    case FlinkSqlParser.RULE_columnName: {
+                        if (!name) {
+                            expectedText = 'a new object name';
+                        } else {
+                            expectedText = `a new ${name} name`;
+                        }
+                        break;
+                    }
+                    case FlinkSqlParser.RULE_databasePathCreate:
+                    case FlinkSqlParser.RULE_tablePathCreate:
+                    case FlinkSqlParser.RULE_functionNameCreate:
+                    case FlinkSqlParser.RULE_viewPathCreate:
+                    case FlinkSqlParser.RULE_columnNameCreate: {
+                        if (!name) {
+                            expectedText = 'an existing object';
+                        } else {
+                            expectedText = `an existing ${name}`;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? ' or a keyword' : 'a keyword';
+        }
+        return expectedText;
+    }
+}
diff --git a/src/parser/flink/index.ts b/src/parser/flink/index.ts
@@ -7,6 +7,8 @@ import { BasicSQL } from '../common/basicSQL';
 import { StmtContextType } from '../common/entityCollector';
 import { FlinkSqlSplitListener } from './flinkSplitListener';
 import { FlinkEntityCollector } from './flinkEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { FlinkErrorListener } from './flinkErrorListener';
 
 export { FlinkSqlSplitListener, FlinkEntityCollector };
 
@@ -37,6 +39,10 @@ export class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlPa
         return new FlinkSqlSplitListener();
     }
 
+    protected createErrorListener(_errorListener: ErrorListener) {
+        return new FlinkErrorListener(_errorListener, this.preferredRules);
+    }
+
     protected createEntityCollector(input: string, caretTokenIndex?: number) {
         return new FlinkEntityCollector(input, caretTokenIndex);
     }
diff --git a/src/parser/hive/hiveErrorListener.ts b/src/parser/hive/hiveErrorListener.ts
@@ -0,0 +1,79 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { Parser, Token } from 'antlr4ng';
+import { HiveSqlParser } from '../../lib/hive/HiveSqlParser';
+
+export class HiveErrorListener extends ParseErrorListener {
+    private preferredRules: Set<number>;
+
+    private objectNames: Map<number, string> = new Map([
+        [HiveSqlParser.RULE_dbSchemaName, 'database'],
+        [HiveSqlParser.RULE_dbSchemaNameCreate, 'database'],
+        [HiveSqlParser.RULE_tableName, 'table'],
+        [HiveSqlParser.RULE_tableNameCreate, 'table'],
+        [HiveSqlParser.RULE_viewName, 'view'],
+        [HiveSqlParser.RULE_viewNameCreate, 'view'],
+        [HiveSqlParser.RULE_functionNameForDDL, 'function'],
+        [HiveSqlParser.RULE_functionNameForInvoke, 'function'],
+        [HiveSqlParser.RULE_functionNameCreate, 'function'],
+        [HiveSqlParser.RULE_columnName, 'column'],
+        [HiveSqlParser.RULE_columnNameCreate, 'column'],
+    ]);
+
+    constructor(errorListener: ErrorListener, preferredRules: Set<number>) {
+        super(errorListener);
+        this.preferredRules = preferredRules;
+    }
+
+    public getExpectedText(parser: Parser, token: Token) {
+        let expectedText = '';
+
+        let currentContext = parser.context ?? undefined;
+        while (currentContext?.parent) {
+            currentContext = currentContext.parent;
+        }
+
+        const core = new CodeCompletionCore(parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+
+        if (candidates.rules.size) {
+            // get expectedText as collect rules first
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case HiveSqlParser.RULE_dbSchemaName:
+                    case HiveSqlParser.RULE_tableName:
+                    case HiveSqlParser.RULE_viewName:
+                    case HiveSqlParser.RULE_functionNameForDDL:
+                    case HiveSqlParser.RULE_functionNameForInvoke:
+                    case HiveSqlParser.RULE_columnName: {
+                        if (!name) {
+                            expectedText = 'a new object name';
+                        } else {
+                            expectedText = `a new ${name} name`;
+                        }
+                        break;
+                    }
+                    case HiveSqlParser.RULE_dbSchemaNameCreate:
+                    case HiveSqlParser.RULE_tableNameCreate:
+                    case HiveSqlParser.RULE_functionNameCreate:
+                    case HiveSqlParser.RULE_viewNameCreate:
+                    case HiveSqlParser.RULE_columnNameCreate: {
+                        if (!name) {
+                            expectedText = 'an existing object';
+                        } else {
+                            expectedText = `an existing ${name}`;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? ' or a keyword' : 'a keyword';
+        }
+        return expectedText;
+    }
+}
diff --git a/src/parser/hive/index.ts b/src/parser/hive/index.ts
@@ -8,6 +8,8 @@ import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/type
 import { StmtContextType } from '../common/entityCollector';
 import { HiveSqlSplitListener } from './hiveSplitListener';
 import { HiveEntityCollector } from './hiveEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { HiveErrorListener } from './hiveErrorListener';
 
 export { HiveEntityCollector, HiveSqlSplitListener };
 
@@ -38,6 +40,10 @@ export class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, HiveSqlParse
         return new HiveSqlSplitListener();
     }
 
+    protected createErrorListener(_errorListener: ErrorListener) {
+        return new HiveErrorListener(_errorListener, this.preferredRules);
+    }
+
     protected createEntityCollector(input: string, caretTokenIndex?: number) {
         return new HiveEntityCollector(input, caretTokenIndex);
     }
diff --git a/src/parser/impala/ImpalaErrorListener.ts b/src/parser/impala/ImpalaErrorListener.ts
@@ -0,0 +1,77 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { Parser, Token } from 'antlr4ng';
+import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
+
+export class ImpalaErrorListener extends ParseErrorListener {
+    private preferredRules: Set<number>;
+
+    private objectNames: Map<number, string> = new Map([
+        [ImpalaSqlParser.RULE_databaseNamePath, 'database'],
+        [ImpalaSqlParser.RULE_databaseNameCreate, 'database'],
+        [ImpalaSqlParser.RULE_tableNamePath, 'table'],
+        [ImpalaSqlParser.RULE_tableNameCreate, 'table'],
+        [ImpalaSqlParser.RULE_viewNamePath, 'view'],
+        [ImpalaSqlParser.RULE_viewNameCreate, 'view'],
+        [ImpalaSqlParser.RULE_functionNamePath, 'function'],
+        [ImpalaSqlParser.RULE_functionNameCreate, 'function'],
+        [ImpalaSqlParser.RULE_columnNamePath, 'column'],
+        [ImpalaSqlParser.RULE_columnNamePathCreate, 'column'],
+    ]);
+
+    constructor(errorListener: ErrorListener, preferredRules: Set<number>) {
+        super(errorListener);
+        this.preferredRules = preferredRules;
+    }
+
+    public getExpectedText(parser: Parser, token: Token) {
+        let expectedText = '';
+
+        let currentContext = parser.context ?? undefined;
+        while (currentContext?.parent) {
+            currentContext = currentContext.parent;
+        }
+
+        const core = new CodeCompletionCore(parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+
+        if (candidates.rules.size) {
+            // get expectedText as collect rules first
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case ImpalaSqlParser.RULE_databaseNamePath:
+                    case ImpalaSqlParser.RULE_tableNamePath:
+                    case ImpalaSqlParser.RULE_functionNamePath:
+                    case ImpalaSqlParser.RULE_viewNamePath:
+                    case ImpalaSqlParser.RULE_columnNamePath: {
+                        if (!name) {
+                            expectedText = 'a new object name';
+                        } else {
+                            expectedText = `a new ${name} name`;
+                        }
+                        break;
+                    }
+                    case ImpalaSqlParser.RULE_databaseNameCreate:
+                    case ImpalaSqlParser.RULE_tableNameCreate:
+                    case ImpalaSqlParser.RULE_functionNameCreate:
+                    case ImpalaSqlParser.RULE_viewNameCreate:
+                    case ImpalaSqlParser.RULE_columnNamePathCreate: {
+                        if (!name) {
+                            expectedText = 'an existing object';
+                        } else {
+                            expectedText = `an existing ${name}`;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? ' or a keyword' : 'a keyword';
+        }
+        return expectedText;
+    }
+}
diff --git a/src/parser/impala/index.ts b/src/parser/impala/index.ts
@@ -7,6 +7,8 @@ import { EntityContextType, Suggestions, SyntaxSuggestion } from '../common/type
 import { StmtContextType } from '../common/entityCollector';
 import { ImpalaSqlSplitListener } from './impalaSplitListener';
 import { ImpalaEntityCollector } from './impalaEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { ImpalaErrorListener } from './ImpalaErrorListener';
 
 export { ImpalaEntityCollector, ImpalaSqlSplitListener };
 
@@ -36,6 +38,10 @@ export class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSq
         return new ImpalaSqlSplitListener();
     }
 
+    protected createErrorListener(_errorListener: ErrorListener) {
+        return new ImpalaErrorListener(_errorListener, this.preferredRules);
+    }
+
     protected createEntityCollector(input: string, caretTokenIndex?: number) {
         return new ImpalaEntityCollector(input, caretTokenIndex);
     }
diff --git a/src/parser/mysql/index.ts b/src/parser/mysql/index.ts
@@ -38,7 +38,7 @@ export class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
         return new MysqlSplitListener();
     }
 
-    protected createErrorListener(_errorListener: ErrorListener<any>) {
+    protected createErrorListener(_errorListener: ErrorListener) {
         return new MysqlErrorListener(_errorListener, this.preferredRules);
     }
 
diff --git a/src/parser/mysql/mysqlErrorListener.ts b/src/parser/mysql/mysqlErrorListener.ts
@@ -1,5 +1,5 @@
 import { CodeCompletionCore } from 'antlr4-c3';
-import { ParseErrorListener } from '../common/parseErrorListener';
+import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
 import { Parser, Token } from 'antlr4ng';
 import { MySqlParser } from '../../lib/mysql/MySqlParser';
 
@@ -19,15 +19,15 @@ export class MysqlErrorListener extends ParseErrorListener {
         [MySqlParser.RULE_columnNameCreate, 'column'],
     ]);
 
-    constructor(errorListener, preferredRules) {
+    constructor(errorListener: ErrorListener, preferredRules: Set<number>) {
         super(errorListener);
         this.preferredRules = preferredRules;
     }
 
     public getExpectedText(parser: Parser, token: Token) {
         let expectedText = '';
 
-        let currentContext = parser.context;
+        let currentContext = parser.context ?? undefined;
         while (currentContext?.parent) {
             currentContext = currentContext.parent;
         }
@@ -45,7 +45,8 @@ export class MysqlErrorListener extends ParseErrorListener {
                     case MySqlParser.RULE_databaseName:
                     case MySqlParser.RULE_tableName:
                     case MySqlParser.RULE_functionName:
-                    case MySqlParser.RULE_viewName: {
+                    case MySqlParser.RULE_viewName:
+                    case MySqlParser.RULE_columnName: {
                         if (!name) {
                             expectedText = 'a new object name';
                         } else {
@@ -56,7 +57,8 @@ export class MysqlErrorListener extends ParseErrorListener {
                     case MySqlParser.RULE_databaseNameCreate:
                     case MySqlParser.RULE_tableNameCreate:
                     case MySqlParser.RULE_functionNameCreate:
-                    case MySqlParser.RULE_viewNameCreate: {
+                    case MySqlParser.RULE_viewNameCreate:
+                    case MySqlParser.RULE_columnNameCreate: {
                         if (!name) {
                             expectedText = 'an existing object';
                         } else {
diff --git a/src/parser/plsql.ts b/src/parser/plsql.ts
@@ -24,6 +24,10 @@ export class PLSQL extends BasicSQL<PlSqlLexer, ProgramContext, PlSqlParser> {
         return null as any;
     }
 
+    protected createErrorListener() {
+        return null as any;
+    }
+
     protected processCandidates(
         candidates: CandidatesCollection,
         allTokens: Token[],
diff --git a/src/parser/postgresql/index.ts b/src/parser/postgresql/index.ts
@@ -8,6 +8,8 @@ import { BasicSQL } from '../common/basicSQL';
 import { StmtContextType } from '../common/entityCollector';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
+import { ErrorListener } from '../common/parseErrorListener';
+import { PostgreSqlErrorListener } from './postgreErrorListener';
 
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 
@@ -41,6 +43,10 @@ export class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, Postgr
         return new PostgreSqlSplitListener();
     }
 
+    protected createErrorListener(_errorListener: ErrorListener) {
+        return new PostgreSqlErrorListener(_errorListener, this.preferredRules);
+    }
+
     protected createEntityCollector(input: string, caretTokenIndex?: number) {
         return new PostgreSqlEntityCollector(input, caretTokenIndex);
     }
diff --git a/src/parser/postgresql/postgreErrorListener.ts b/src/parser/postgresql/postgreErrorListener.ts
diff --git a/src/parser/spark/index.ts b/src/parser/spark/index.ts
diff --git a/src/parser/spark/sparkErrorListener.ts b/src/parser/spark/sparkErrorListener.ts
diff --git a/src/parser/trino/index.ts b/src/parser/trino/index.ts
diff --git a/src/parser/trino/trinoErrorListener.ts b/src/parser/trino/trinoErrorListener.ts

Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ export class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {`
`38`	`38`	`return new MysqlSplitListener();`
`39`	`39`	`}`
`40`	`40`
`41`		`- protected createErrorListener(_errorListener: ErrorListener<any>) {`
	`41`	`+ protected createErrorListener(_errorListener: ErrorListener) {`
`42`	`42`	`return new MysqlErrorListener(_errorListener, this.preferredRules);`
`43`	`43`	`}`
`44`	`44`