dt-sql-parser 4.0.0-ng.2 → 4.0.0

package/dist/parser/hive/hiveSplitListener.js

@@ -0,0 +1,6 @@
+import { SplitListener } from '../common/splitListener';
+export class HiveSqlSplitListener extends SplitListener {
+    exitStatement(ctx) {
+        this._statementsContext.push(ctx);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+import { HiveSqlLexer } from '../../lib/hive/HiveSqlLexer';
+import { HiveSqlParser, ProgramContext } from '../../lib/hive/HiveSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions } from '../common/types';
+import { HiveSqlSplitListener } from './hiveSplitListener';
+import { HiveEntityCollector } from './hiveEntityCollector';
+export { HiveEntityCollector, HiveSqlSplitListener };
+export declare class HiveSQL extends BasicSQL<HiveSqlLexer, ProgramContext, HiveSqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): HiveSqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): HiveSqlParser;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): HiveSqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): HiveEntityCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

package/dist/parser/{hive.js → hive/index.js}

@@ -1,8 +1,11 @@
-import { HiveSqlLexer } from '../lib/hive/HiveSqlLexer';
-import { HiveSqlParser } from '../lib/hive/HiveSqlParser';
-import BasicParser from './common/basicParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-export default class HiveSQL extends BasicParser {
+import { HiveSqlLexer } from '../../lib/hive/HiveSqlLexer';
+import { HiveSqlParser } from '../../lib/hive/HiveSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType } from '../common/types';
+import { HiveSqlSplitListener } from './hiveSplitListener';
+import { HiveEntityCollector } from './hiveEntityCollector';
+export { HiveEntityCollector, HiveSqlSplitListener };
+export class HiveSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
@@ -20,8 +23,7 @@ export default class HiveSQL extends BasicParser {
         ]);
     }
     createLexerFromCharStream(charStreams) {
-        const lexer = new HiveSqlLexer(charStreams);
-        return lexer;
+        return new HiveSqlLexer(charStreams);
     }
     createParserFromTokenStream(tokenStream) {
         return new HiveSqlParser(tokenStream);
@@ -29,6 +31,9 @@ export default class HiveSQL extends BasicParser {
     get splitListener() {
         return new HiveSqlSplitListener();
     }
+    createEntityCollector(input, caretTokenIndex) {
+        return new HiveEntityCollector(input, caretTokenIndex);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
@@ -36,47 +41,47 @@ export default class HiveSQL extends BasicParser {
             const [ruleType, candidateRule] = candidate;
             const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
             const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
-            let syntaxContextType;
+            let syntaxContextType = void 0;
             switch (ruleType) {
                 case HiveSqlParser.RULE_dbSchemaName: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
+                    syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
                 case HiveSqlParser.RULE_dbSchemaNameCreate: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
                 case HiveSqlParser.RULE_tableName: {
-                    syntaxContextType = SyntaxContextType.TABLE;
+                    syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
                 case HiveSqlParser.RULE_tableNameCreate: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
                 case HiveSqlParser.RULE_viewName: {
-                    syntaxContextType = SyntaxContextType.VIEW;
+                    syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
                 case HiveSqlParser.RULE_viewNameCreate: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
                 case HiveSqlParser.RULE_functionNameForDDL:
                 case HiveSqlParser.RULE_functionNameForInvoke: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 case HiveSqlParser.RULE_functionNameCreate: {
-                    syntaxContextType = SyntaxContextType.FUNCTION_CREATE;
+                    syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
                 case HiveSqlParser.RULE_columnName: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
+                    syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
                 case HiveSqlParser.RULE_columnNameCreate: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
                 default:
@@ -92,7 +97,7 @@ export default class HiveSQL extends BasicParser {
         for (let candidate of candidates.tokens) {
             const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
             const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (symbolicName && symbolicName.startsWith('KW_')) {
+            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
                 const keyword = displayName.startsWith("'") && displayName.endsWith("'")
                     ? displayName.slice(1, -1)
                     : displayName;
@@ -105,18 +110,3 @@ export default class HiveSQL extends BasicParser {
         };
     }
 }
-export class HiveSqlSplitListener {
-    constructor() {
-        this._statementContext = [];
-        this.exitStatement = (ctx) => {
-            this._statementContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementContext;
-    }
-}

package/dist/parser/impala/impalaEntityCollector.d.ts

@@ -0,0 +1,35 @@
+import { ImpalaSqlParserListener } from '../../lib';
+import { ColumnNamePathCreateContext, CreateAggregateFunctionContext, CreateFunctionContext, CreateKuduTableAsSelectContext, CreateSchemaContext, CreateTableLikeContext, CreateTableSelectContext, CreateViewContext, DatabaseNameCreateContext, DatabaseNamePathContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SingleStatementContext, TableNameCreateContext, TableNamePathContext, ViewNameCreateContext, ViewNamePathContext } from '../../lib/impala/ImpalaSqlParser';
+import { EntityCollector } from '../common/entityCollector';
+export declare class ImpalaEntityCollector extends EntityCollector implements ImpalaSqlParserListener {
+    /** ===== Entity begin */
+    exitTableNameCreate(ctx: TableNameCreateContext): void;
+    exitTableNamePath(ctx: TableNamePathContext): void;
+    exitColumnNamePathCreate(ctx: ColumnNamePathCreateContext): void;
+    exitViewNameCreate(ctx: ViewNameCreateContext): void;
+    exitViewNamePath(ctx: ViewNamePathContext): void;
+    exitDatabaseNamePath(ctx: DatabaseNamePathContext): void;
+    exitDatabaseNameCreate(ctx: DatabaseNameCreateContext): void;
+    exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    /** ===== Statement begin */
+    enterSingleStatement(ctx: SingleStatementContext): void;
+    exitSingleStatement(ctx: SingleStatementContext): void;
+    enterCreateTableLike(ctx: CreateTableLikeContext): void;
+    exitCreateTableLike(ctx: CreateTableLikeContext): void;
+    enterCreateTableSelect(ctx: CreateTableSelectContext): void;
+    exitCreateTableSelect(ctx: CreateTableSelectContext): void;
+    enterCreateKuduTableAsSelect(ctx: CreateKuduTableAsSelectContext): void;
+    exitCreateKuduTableAsSelect(ctx: CreateKuduTableAsSelectContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterCreateView(ctx: CreateViewContext): void;
+    exitCreateView(ctx: CreateViewContext): void;
+    enterInsertStatement(ctx: InsertStatementContext): void;
+    exitInsertStatement(ctx: InsertStatementContext): void;
+    enterCreateSchema(ctx: CreateSchemaContext): void;
+    exitCreateSchema(ctx: CreateSchemaContext): void;
+    enterCreateAggregateFunction(ctx: CreateAggregateFunctionContext): void;
+    exitCreateAggregateFunction(ctx: CreateAggregateFunctionContext): void;
+    enterCreateFunction(ctx: CreateFunctionContext): void;
+    exitCreateFunction(ctx: CreateFunctionContext): void;
+}

package/dist/parser/impala/impalaEntityCollector.js

@@ -0,0 +1,90 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class ImpalaEntityCollector extends EntityCollector {
+    /** ===== Entity begin */
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+    }
+    exitTableNamePath(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE);
+    }
+    exitColumnNamePathCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    exitViewNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+    }
+    exitViewNamePath(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW);
+    }
+    exitDatabaseNamePath(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitDatabaseNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+    }
+    exitFunctionNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateTableLike(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTableLike(ctx) {
+        this.popStmt();
+    }
+    enterCreateTableSelect(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTableSelect(ctx) {
+        this.popStmt();
+    }
+    enterCreateKuduTableAsSelect(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateKuduTableAsSelect(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateView(ctx) {
+        this.popStmt();
+    }
+    enterInsertStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateSchema(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateSchema(ctx) {
+        this.popStmt();
+    }
+    enterCreateAggregateFunction(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateAggregateFunction(ctx) {
+        this.popStmt();
+    }
+    enterCreateFunction(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateFunction(ctx) {
+        this.popStmt();
+    }
+}

package/dist/parser/impala/impalaSplitListener.d.ts

@@ -0,0 +1,6 @@
+import { SingleStatementContext } from '../../lib/impala/ImpalaSqlParser';
+import { ImpalaSqlParserListener } from '../../lib/impala/ImpalaSqlParserListener';
+import { SplitListener } from '../common/splitListener';
+export declare class ImpalaSqlSplitListener extends SplitListener<SingleStatementContext> implements ImpalaSqlParserListener {
+    exitSingleStatement(ctx: SingleStatementContext): void;
+}

package/dist/parser/impala/impalaSplitListener.js

@@ -0,0 +1,6 @@
+import { SplitListener } from '../common/splitListener';
+export class ImpalaSqlSplitListener extends SplitListener {
+    exitSingleStatement(ctx) {
+        this._statementsContext.push(ctx);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
+import { ImpalaSqlParser, ProgramContext } from '../../lib/impala/ImpalaSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions } from '../common/types';
+import { ImpalaSqlSplitListener } from './impalaSplitListener';
+import { ImpalaEntityCollector } from './impalaEntityCollector';
+export { ImpalaEntityCollector, ImpalaSqlSplitListener };
+export declare class ImpalaSQL extends BasicSQL<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): ImpalaSqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): ImpalaSqlParser;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): ImpalaSqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): ImpalaEntityCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

package/dist/parser/{impala.js → impala/index.js}

@@ -1,8 +1,11 @@
-import { ImpalaSqlLexer } from '../lib/impala/ImpalaSqlLexer';
-import { ImpalaSqlParser, } from '../lib/impala/ImpalaSqlParser';
-import BasicParser from './common/basicParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-export default class ImpalaSQL extends BasicParser {
+import { ImpalaSqlLexer } from '../../lib/impala/ImpalaSqlLexer';
+import { ImpalaSqlParser } from '../../lib/impala/ImpalaSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType } from '../common/types';
+import { ImpalaSqlSplitListener } from './impalaSplitListener';
+import { ImpalaEntityCollector } from './impalaEntityCollector';
+export { ImpalaEntityCollector, ImpalaSqlSplitListener };
+export class ImpalaSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
@@ -19,8 +22,7 @@ export default class ImpalaSQL extends BasicParser {
         ]);
     }
     createLexerFromCharStream(charStreams) {
-        const lexer = new ImpalaSqlLexer(charStreams);
-        return lexer;
+        return new ImpalaSqlLexer(charStreams);
     }
     createParserFromTokenStream(tokenStream) {
         return new ImpalaSqlParser(tokenStream);
@@ -28,6 +30,9 @@ export default class ImpalaSQL extends BasicParser {
     get splitListener() {
         return new ImpalaSqlSplitListener();
     }
+    createEntityCollector(input, caretTokenIndex) {
+        return new ImpalaEntityCollector(input, caretTokenIndex);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
@@ -35,46 +40,46 @@ export default class ImpalaSQL extends BasicParser {
             const [ruleType, candidateRule] = candidate;
             const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
             const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
-            let syntaxContextType;
+            let syntaxContextType = void 0;
             switch (ruleType) {
                 case ImpalaSqlParser.RULE_functionNameCreate: {
-                    syntaxContextType = SyntaxContextType.FUNCTION_CREATE;
+                    syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
                 case ImpalaSqlParser.RULE_tableNameCreate: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
                 case ImpalaSqlParser.RULE_databaseNameCreate: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
                 case ImpalaSqlParser.RULE_viewNameCreate: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
                 case ImpalaSqlParser.RULE_columnNamePathCreate: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
                 case ImpalaSqlParser.RULE_databaseNamePath: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
+                    syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
                 case ImpalaSqlParser.RULE_tableNamePath: {
-                    syntaxContextType = SyntaxContextType.TABLE;
+                    syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
                 case ImpalaSqlParser.RULE_viewNamePath: {
-                    syntaxContextType = SyntaxContextType.VIEW;
+                    syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
                 case ImpalaSqlParser.RULE_functionNamePath: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 case ImpalaSqlParser.RULE_columnNamePath: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
+                    syntaxContextType = EntityContextType.COLUMN;
                 }
                 default:
                     break;
@@ -89,7 +94,7 @@ export default class ImpalaSQL extends BasicParser {
         for (let candidate of candidates.tokens) {
             const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
             const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (symbolicName && symbolicName.startsWith('KW_')) {
+            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
                 const keyword = displayName.startsWith("'") && displayName.endsWith("'")
                     ? displayName.slice(1, -1)
                     : displayName;
@@ -102,18 +107,3 @@ export default class ImpalaSQL extends BasicParser {
         };
     }
 }
-export class ImpalaSqlSplitListener {
-    constructor() {
-        this._statementContext = [];
-        this.exitSingleStatement = (ctx) => {
-            this._statementContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementContext;
-    }
-}

package/dist/parser/index.d.ts

@@ -1,8 +1,8 @@
-export { default as MySQL } from './mysql';
-export { default as PLSQL } from './plsql';
-export { default as HiveSQL } from './hive';
-export { default as FlinkSQL } from './flinksql';
-export { default as SparkSQL } from './spark';
-export { default as PostgresSQL } from './pgsql';
-export { default as TrinoSQL } from './trinosql';
-export { default as ImpalaSQL } from './impala';
+export { MySQL } from './mysql';
+export { PLSQL } from './plsql';
+export { HiveSQL } from './hive';
+export { FlinkSQL } from './flink';
+export { SparkSQL } from './spark';
+export { PostgreSQL } from './postgresql';
+export { TrinoSQL } from './trino';
+export { ImpalaSQL } from './impala';

package/dist/parser/index.js

@@ -1,8 +1,8 @@
-export { default as MySQL } from './mysql';
-export { default as PLSQL } from './plsql';
-export { default as HiveSQL } from './hive';
-export { default as FlinkSQL } from './flinksql';
-export { default as SparkSQL } from './spark';
-export { default as PostgresSQL } from './pgsql';
-export { default as TrinoSQL } from './trinosql';
-export { default as ImpalaSQL } from './impala';
+export { MySQL } from './mysql';
+export { PLSQL } from './plsql';
+export { HiveSQL } from './hive';
+export { FlinkSQL } from './flink';
+export { SparkSQL } from './spark';
+export { PostgreSQL } from './postgresql';
+export { TrinoSQL } from './trino';
+export { ImpalaSQL } from './impala';

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

@@ -0,0 +1,17 @@
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
+import { MySqlParser, ProgramContext } from '../../lib/mysql/MySqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions } from '../common/types';
+import { MysqlSplitListener } from './mysqlSplitListener';
+import { MySqlEntityCollector } from './mysqlEntityCollector';
+export { MySqlEntityCollector, MysqlSplitListener };
+export declare class MySQL extends BasicSQL<MySqlLexer, ProgramContext, MySqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): MySqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): MySqlParser;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): MysqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): MySqlEntityCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

package/dist/parser/{mysql.js → mysql/index.js}

@@ -1,8 +1,11 @@
-import { MySqlLexer } from '../lib/mysql/MySqlLexer';
-import { MySqlParser } from '../lib/mysql/MySqlParser';
-import BasicParser from './common/basicParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-export default class MySQL extends BasicParser {
+import { MySqlLexer } from '../../lib/mysql/MySqlLexer';
+import { MySqlParser } from '../../lib/mysql/MySqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType } from '../common/types';
+import { MysqlSplitListener } from './mysqlSplitListener';
+import { MySqlEntityCollector } from './mysqlEntityCollector';
+export { MySqlEntityCollector, MysqlSplitListener };
+export class MySQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
@@ -19,8 +22,7 @@ export default class MySQL extends BasicParser {
         ]);
     }
     createLexerFromCharStream(charStreams) {
-        const lexer = new MySqlLexer(charStreams);
-        return lexer;
+        return new MySqlLexer(charStreams);
     }
     createParserFromTokenStream(tokenStream) {
         return new MySqlParser(tokenStream);
@@ -28,6 +30,9 @@ export default class MySQL extends BasicParser {
     get splitListener() {
         return new MysqlSplitListener();
     }
+    createEntityCollector(input, caretTokenIndex) {
+        return new MySqlEntityCollector(input, caretTokenIndex);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
@@ -35,46 +40,46 @@ export default class MySQL extends BasicParser {
             const [ruleType, candidateRule] = candidate;
             const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
             const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
-            let syntaxContextType;
+            let syntaxContextType = void 0;
             switch (ruleType) {
                 case MySqlParser.RULE_databaseName: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
+                    syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
                 case MySqlParser.RULE_databaseNameCreate: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
                 case MySqlParser.RULE_tableName: {
-                    syntaxContextType = SyntaxContextType.TABLE;
+                    syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
                 case MySqlParser.RULE_tableNameCreate: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
                 case MySqlParser.RULE_viewName: {
-                    syntaxContextType = SyntaxContextType.VIEW;
+                    syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
                 case MySqlParser.RULE_viewNameCreate: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
                 case MySqlParser.RULE_functionName: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 case MySqlParser.RULE_functionNameCreate: {
-                    syntaxContextType = SyntaxContextType.FUNCTION_CREATE;
+                    syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
                 case MySqlParser.RULE_columnName: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
+                    syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
                 case MySqlParser.RULE_columnNameCreate: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
                 default:
@@ -90,7 +95,7 @@ export default class MySQL extends BasicParser {
         for (const candidate of candidates.tokens) {
             const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
             const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (symbolicName && symbolicName.startsWith('KW_')) {
+            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
                 const keyword = displayName.startsWith("'") && displayName.endsWith("'")
                     ? displayName.slice(1, -1)
                     : displayName;
@@ -103,18 +108,3 @@ export default class MySQL extends BasicParser {
         };
     }
 }
-export class MysqlSplitListener {
-    constructor() {
-        this._statementsContext = [];
-        this.exitSingleStatement = (ctx) => {
-            this._statementsContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementsContext;
-    }
-}

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

@@ -0,0 +1,37 @@
+import type { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/mysql/MySqlParser';
+import type { MySqlParserListener } from '../../lib/mysql/MySqlParserListener';
+import { EntityCollector } from '../common/entityCollector';
+export declare class MySqlEntityCollector extends EntityCollector implements MySqlParserListener {
+    /** ====== Entity Begin */
+    exitDatabaseName(ctx: DatabaseNameContext): void;
+    exitDatabaseNameCreate(ctx: DatabaseNameCreateContext): void;
+    exitTableName(ctx: TableNameContext): void;
+    exitTableNameCreate(ctx: TableNameCreateContext): void;
+    exitViewName(ctx: ViewNameContext): void;
+    exitViewNameCreate(ctx: ViewNameCreateContext): void;
+    exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    /** ===== Statement begin */
+    enterSingleStatement(ctx: SingleStatementContext): void;
+    exitSingleStatement(ctx: SingleStatementContext): void;
+    enterQueryCreateTable(ctx: QueryCreateTableContext): void;
+    exitQueryCreateTable(ctx: QueryCreateTableContext): void;
+    enterColumnCreateTable(ctx: ColumnCreateTableContext): void;
+    exitColumnCreateTable(ctx: ColumnCreateTableContext): void;
+    enterCopyCreateTable(ctx: CopyCreateTableContext): void;
+    exitCopyCreateTable(ctx: CopyCreateTableContext): void;
+    enterCreateView(ctx: CreateViewContext): void;
+    exitCreateView(ctx: CreateViewContext): void;
+    enterSimpleSelect(ctx: SelectStatementContext): void;
+    exitSimpleSelect(ctx: SelectStatementContext): void;
+    enterUnionAndLateralSelect(ctx: SelectStatementContext): void;
+    exitUnionAndLateralSelect(ctx: SelectStatementContext): void;
+    enterSelectExpression(ctx: SelectStatementContext): void;
+    exitSelectExpression(ctx: SelectStatementContext): void;
+    enterInsertStatement(ctx: InsertStatementContext): void;
+    exitInsertStatement(ctx: InsertStatementContext): void;
+    enterCreateDatabase(ctx: CreateDatabaseContext): void;
+    exitCreateDatabase(ctx: CreateDatabaseContext): void;
+    enterCreateFunction(ctx: CreateFunctionContext): void;
+    exitCreateFunction(ctx: CreateFunctionContext): void;
+}