dt-sql-parser 4.1.2-beta.1 → 4.3.0

package/dist/parser/mysql/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
 import { MySqlParser } from '../../lib/mysql/MySqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { MySqlEntityCollector } from './mysqlEntityCollector';
 import { MysqlErrorListener } from './mysqlErrorListener';
 import { MysqlSplitListener } from './mysqlSplitListener';
+import { MySqlSemanticContextCollector } from '../mysql/mysqlSemanticContextCollector';
 export { MySqlEntityCollector, MysqlSplitListener };
 export class MySQL extends BasicSQL {
     constructor() {
@@ -38,13 +40,15 @@ export class MySQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new MySqlEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new MySqlSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (const candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case MySqlParser.RULE_databaseName: {
@@ -97,16 +101,8 @@ export class MySQL extends BasicSQL {
                 });
             }
         }
-        for (const candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

package/dist/parser/mysql/mysqlErrorListener.js

@@ -49,7 +49,9 @@ export class MysqlErrorListener extends ParseErrorListener {
                     case MySqlParser.RULE_functionName:
                     case MySqlParser.RULE_viewName:
                     case MySqlParser.RULE_columnName: {
-                        result.push(`{existing}${name}`);
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case MySqlParser.RULE_databaseNameCreate:
@@ -57,7 +59,9 @@ export class MysqlErrorListener extends ParseErrorListener {
                     case MySqlParser.RULE_functionNameCreate:
                     case MySqlParser.RULE_viewNameCreate:
                     case MySqlParser.RULE_columnNameCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

package/dist/parser/mysql/mysqlSemanticContextCollector.d.ts

@@ -0,0 +1,9 @@
+import { MySqlParserListener } from '../../lib';
+import { SingleStatementContext } from '../../lib/mysql/MySqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class MySqlSemanticContextCollector extends SemanticContextCollector implements MySqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStatement(ctx: SingleStatementContext): void;
+}
+export { MySqlSemanticContextCollector };

package/dist/parser/mysql/mysqlSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { MySqlParser } from '../../lib/mysql/MySqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class MySqlSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return MySqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return MySqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { MySqlSemanticContextCollector };

package/dist/parser/postgresql/index.d.ts

@@ -2,12 +2,13 @@ import { CandidatesCollection } from 'antlr4-c3';
 import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser, ProgramContext } from '../../lib/postgresql/PostgreSqlParser';
+import { CaretPosition, SemanticCollectOptions, Suggestions } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
+import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): PostgreSqlLexer;
@@ -16,5 +17,6 @@ export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext
     protected get splitListener(): PostgreSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): PostgreSqlErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): PostgreSqlEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): PostgreSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/postgresql/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
 import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
+import { EntityContextType, } from '../common/types';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
 import { PostgreSqlEntityCollector } from './postgreEntityCollector';
 import { PostgreSqlErrorListener } from './postgreErrorListener';
 import { PostgreSqlSplitListener } from './postgreSplitListener';
+import { PostgreSemanticContextCollector } from './postgreSemanticContextCollector';
 export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
 export class PostgreSQL extends BasicSQL {
     constructor() {
@@ -24,6 +26,7 @@ export class PostgreSQL extends BasicSQL {
             PostgreSqlParser.RULE_procedureName, // procedure name
             PostgreSqlParser.RULE_columnNameCreate, // column name that will be created
             PostgreSqlParser.RULE_columnName, // column name
+            PostgreSqlParser.RULE_columnNamePath, // column name
         ]);
     }
     createLexerFromCharStream(charStreams) {
@@ -42,13 +45,15 @@ export class PostgreSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new PostgreSqlEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new PostgreSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case PostgreSqlParser.RULE_tableNameCreate: {
@@ -107,6 +112,18 @@ export class PostgreSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
+                case PostgreSqlParser.RULE_columnNamePath: {
+                    if (candidateRule.ruleList.includes(PostgreSqlParser.RULE_groupClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_sortClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_limitClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_windowClause) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_triggerWhen)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                    break;
+                }
                 default:
                     break;
             }
@@ -117,16 +134,8 @@ export class PostgreSQL extends BasicSQL {
                 });
             }
         }
-        for (let candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

package/dist/parser/postgresql/postgreErrorListener.js

@@ -15,6 +15,7 @@ export class PostgreSqlErrorListener extends ParseErrorListener {
             [PostgreSqlParser.RULE_functionNameCreate, 'function'],
             [PostgreSqlParser.RULE_columnName, 'column'],
             [PostgreSqlParser.RULE_columnNameCreate, 'column'],
+            [PostgreSqlParser.RULE_columnNamePath, 'column'],
             [PostgreSqlParser.RULE_schemaNameCreate, 'schema'],
             [PostgreSqlParser.RULE_schemaName, 'schema'],
             [PostgreSqlParser.RULE_procedureNameCreate, 'procedure'],
@@ -54,8 +55,11 @@ export class PostgreSqlErrorListener extends ParseErrorListener {
                     case PostgreSqlParser.RULE_viewName:
                     case PostgreSqlParser.RULE_databaseName:
                     case PostgreSqlParser.RULE_procedureName:
-                    case PostgreSqlParser.RULE_columnName: {
-                        result.push(`{existing}${name}`);
+                    case PostgreSqlParser.RULE_columnName:
+                    case PostgreSqlParser.RULE_columnNamePath: {
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case PostgreSqlParser.RULE_tableNameCreate:
@@ -65,7 +69,9 @@ export class PostgreSqlErrorListener extends ParseErrorListener {
                     case PostgreSqlParser.RULE_databaseNameCreate:
                     case PostgreSqlParser.RULE_procedureNameCreate:
                     case PostgreSqlParser.RULE_columnNameCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

package/dist/parser/postgresql/postgreSemanticContextCollector.d.ts

@@ -0,0 +1,9 @@
+import { PostgreSqlParserListener } from '../../lib';
+import { SingleStmtContext } from '../../lib/postgresql/PostgreSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class PostgreSemanticContextCollector extends SemanticContextCollector implements PostgreSqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStmt(ctx: SingleStmtContext): void;
+}
+export { PostgreSemanticContextCollector };

package/dist/parser/postgresql/postgreSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class PostgreSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return PostgreSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return PostgreSqlParser.RULE_singleStmt;
+    }
+    enterSingleStmt(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { PostgreSemanticContextCollector };

package/dist/parser/spark/index.d.ts

@@ -3,11 +3,12 @@ import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
 import { ProgramContext, SparkSqlParser } from '../../lib/spark/SparkSqlParser';
 import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { SparkEntityCollector } from './sparkEntityCollector';
 import { SparkErrorListener } from './sparkErrorListener';
 import { SparkSqlSplitListener } from './sparkSplitListener';
+import { SparkSemanticContextCollector } from './sparkSemanticContextCollector';
 export { SparkEntityCollector, SparkSqlSplitListener };
 export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, SparkSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): SparkSqlLexer;
@@ -16,5 +17,6 @@ export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, Sp
     protected get splitListener(): SparkSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): SparkErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): SparkEntityCollector;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): SparkSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/spark/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
 import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { SparkEntityCollector } from './sparkEntityCollector';
 import { SparkErrorListener } from './sparkErrorListener';
 import { SparkSqlSplitListener } from './sparkSplitListener';
+import { SparkSemanticContextCollector } from './sparkSemanticContextCollector';
 export { SparkEntityCollector, SparkSqlSplitListener };
 export class SparkSQL extends BasicSQL {
     constructor() {
@@ -19,6 +21,7 @@ export class SparkSQL extends BasicSQL {
             SparkSqlParser.RULE_functionName,
             SparkSqlParser.RULE_functionNameCreate,
             SparkSqlParser.RULE_columnName,
+            SparkSqlParser.RULE_columnNamePath,
             SparkSqlParser.RULE_columnNameCreate,
         ]);
     }
@@ -38,13 +41,15 @@ export class SparkSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new SparkEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new SparkSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (const candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case SparkSqlParser.RULE_namespaceName: {
@@ -87,6 +92,21 @@ export class SparkSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
+                case SparkSqlParser.RULE_columnNamePath: {
+                    if (candidateRule.ruleList.includes(SparkSqlParser.RULE_whenClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_joinRelation) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_orderOrSortByClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_groupByClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_aggregationClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_windowClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_selectClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_limitClause) ||
+                        candidateRule.ruleList.includes(SparkSqlParser.RULE_clusterOrDistributeBy)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                }
                 default:
                     break;
             }
@@ -97,16 +117,8 @@ export class SparkSQL extends BasicSQL {
                 });
             }
         }
-        for (const candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

package/dist/parser/spark/sparkErrorListener.js

@@ -14,6 +14,7 @@ export class SparkErrorListener extends ParseErrorListener {
             [SparkSqlParser.RULE_functionName, 'function'],
             [SparkSqlParser.RULE_functionNameCreate, 'function'],
             [SparkSqlParser.RULE_columnName, 'column'],
+            [SparkSqlParser.RULE_columnNamePath, 'column'],
             [SparkSqlParser.RULE_columnNameCreate, 'column'],
         ]);
     }
@@ -48,8 +49,11 @@ export class SparkErrorListener extends ParseErrorListener {
                     case SparkSqlParser.RULE_tableName:
                     case SparkSqlParser.RULE_viewName:
                     case SparkSqlParser.RULE_functionName:
-                    case SparkSqlParser.RULE_columnName: {
-                        result.push(`{existing}${name}`);
+                    case SparkSqlParser.RULE_columnName:
+                    case SparkSqlParser.RULE_columnNamePath: {
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case SparkSqlParser.RULE_namespaceNameCreate:
@@ -57,7 +61,9 @@ export class SparkErrorListener extends ParseErrorListener {
                     case SparkSqlParser.RULE_functionNameCreate:
                     case SparkSqlParser.RULE_viewNameCreate:
                     case SparkSqlParser.RULE_columnNameCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

package/dist/parser/spark/sparkSemanticContextCollector.d.ts

@@ -0,0 +1,9 @@
+import { SparkSqlParserListener } from '../../lib';
+import { SingleStatementContext } from '../../lib/spark/SparkSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class SparkSemanticContextCollector extends SemanticContextCollector implements SparkSqlParserListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterSingleStatement(ctx: SingleStatementContext): void;
+}
+export { SparkSemanticContextCollector };

package/dist/parser/spark/sparkSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class SparkSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return SparkSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return SparkSqlParser.RULE_singleStatement;
+    }
+    enterSingleStatement(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { SparkSemanticContextCollector };

package/dist/parser/trino/index.d.ts

@@ -3,11 +3,12 @@ import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
 import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
 import { ProgramContext, TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
 import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
 import { ErrorListener } from '../common/parseErrorListener';
-import { Suggestions } from '../common/types';
 import { TrinoEntityCollector } from './trinoEntityCollector';
 import { TrinoErrorListener } from './trinoErrorListener';
 import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { TrinoSemanticContextCollector } from './trinoSemanticContextCollector';
 export { TrinoEntityCollector, TrinoSqlSplitListener };
 export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): TrinoSqlLexer;
@@ -15,6 +16,7 @@ export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, Tr
     protected get splitListener(): TrinoSqlSplitListener;
     protected createErrorListener(_errorListener: ErrorListener): TrinoErrorListener;
     protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): TrinoEntityCollector;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): TrinoSemanticContextCollector;
     protected preferredRules: Set<number>;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
 }

package/dist/parser/trino/index.js

@@ -1,10 +1,12 @@
+import { processTokenCandidates } from '../common/tokenUtils';
 import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
 import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
 import { BasicSQL } from '../common/basicSQL';
-import { EntityContextType } from '../common/types';
+import { EntityContextType, } from '../common/types';
 import { TrinoEntityCollector } from './trinoEntityCollector';
 import { TrinoErrorListener } from './trinoErrorListener';
 import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { TrinoSemanticContextCollector } from './trinoSemanticContextCollector';
 export { TrinoEntityCollector, TrinoSqlSplitListener };
 export class TrinoSQL extends BasicSQL {
     constructor() {
@@ -21,6 +23,7 @@ export class TrinoSQL extends BasicSQL {
             TrinoSqlParser.RULE_functionName,
             TrinoSqlParser.RULE_functionNameCreate,
             TrinoSqlParser.RULE_columnRef,
+            TrinoSqlParser.RULE_columnName,
             TrinoSqlParser.RULE_columnNameCreate,
         ]);
     }
@@ -40,13 +43,15 @@ export class TrinoSQL extends BasicSQL {
     createEntityCollector(input, allTokens, caretTokenIndex) {
         return new TrinoEntityCollector(input, allTokens, caretTokenIndex);
     }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new TrinoSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case TrinoSqlParser.RULE_catalogRef: {
@@ -97,6 +102,17 @@ export class TrinoSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
+                case TrinoSqlParser.RULE_columnName: {
+                    if (candidateRule.ruleList.includes(TrinoSqlParser.RULE_groupBy) ||
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_sortItem) ||
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_whereClause) ||
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_partitionBy) ||
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_whenClause) ||
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_relation)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                }
                 default:
                     break;
             }
@@ -107,16 +123,8 @@ export class TrinoSQL extends BasicSQL {
                 });
             }
         }
-        for (let candidate of candidates.tokens) {
-            const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
-            const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
         return {
             syntax: originalSyntaxSuggestions,
             keywords,

package/dist/parser/trino/trinoErrorListener.js

@@ -15,6 +15,7 @@ export class TrinoErrorListener extends ParseErrorListener {
             [TrinoSqlParser.RULE_schemaNameCreate, 'schema'],
             [TrinoSqlParser.RULE_functionName, 'function'],
             [TrinoSqlParser.RULE_columnRef, 'column'],
+            [TrinoSqlParser.RULE_columnName, 'column'],
             [TrinoSqlParser.RULE_columnNameCreate, 'column'],
         ]);
     }
@@ -50,8 +51,11 @@ export class TrinoErrorListener extends ParseErrorListener {
                     case TrinoSqlParser.RULE_tableRef:
                     case TrinoSqlParser.RULE_viewRef:
                     case TrinoSqlParser.RULE_functionName:
-                    case TrinoSqlParser.RULE_columnRef: {
-                        result.push(`{existing}${name}`);
+                    case TrinoSqlParser.RULE_columnRef:
+                    case TrinoSqlParser.RULE_columnName: {
+                        if (!result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
                         break;
                     }
                     case TrinoSqlParser.RULE_catalogNameCreate:
@@ -59,7 +63,9 @@ export class TrinoErrorListener extends ParseErrorListener {
                     case TrinoSqlParser.RULE_schemaNameCreate:
                     case TrinoSqlParser.RULE_viewNameCreate:
                     case TrinoSqlParser.RULE_tableNameCreate: {
-                        result.push(`{new}${name}`);
+                        if (!result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
                         break;
                     }
                 }

package/dist/parser/trino/trinoSemanticContextCollector.d.ts

@@ -0,0 +1,9 @@
+import { TrinoSqlListener } from '../../lib';
+import { StatementsContext } from '../../lib/trino/TrinoSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class TrinoSemanticContextCollector extends SemanticContextCollector implements TrinoSqlListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterStatements(ctx: StatementsContext): void;
+}
+export { TrinoSemanticContextCollector };

package/dist/parser/trino/trinoSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class TrinoSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return TrinoSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return TrinoSqlParser.RULE_statements;
+    }
+    enterStatements(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { TrinoSemanticContextCollector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-sql-parser",
-  "version": "4.1.2-beta.1",
+  "version": "4.3.0",
   "authors": "DTStack Corporation",
   "description": "SQL Parsers for BigData, built with antlr4",
   "keywords": [
@@ -27,6 +27,7 @@
     "prepublishOnly": "npm run build",
     "antlr4": "node ./scripts/antlr4.js",
     "build": "rm -rf dist && tsc",
+    "watch": "tsc -w",
     "check-types": "tsc -p ./tsconfig.json && tsc -p ./test/tsconfig.json",
     "test": "NODE_OPTIONS=--max_old_space_size=4096 && jest",
     "release": "node ./scripts/release.js",