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

package/dist/parser/common/simpleStack.js

@@ -0,0 +1,23 @@
+export class SimpleStack {
+    constructor() {
+        this.stack = [];
+    }
+    push(item) {
+        this.stack.push(item);
+    }
+    pop() {
+        return this.stack.pop();
+    }
+    peek() {
+        return this.stack[this.stack.length - 1];
+    }
+    clear() {
+        this.stack = [];
+    }
+    size() {
+        return this.stack.length;
+    }
+    isEmpty() {
+        return this.stack.length === 0;
+    }
+}

package/dist/parser/common/splitListener.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class SplitListener<T> {
+    protected _statementsContext: T[];
+    visitTerminal(): void;
+    visitErrorNode(): void;
+    enterEveryRule(): void;
+    exitEveryRule(): void;
+    get statementsContext(): T[];
+}

package/dist/parser/common/splitListener.js

@@ -0,0 +1,12 @@
+export class SplitListener {
+    constructor() {
+        this._statementsContext = [];
+    }
+    visitTerminal() { }
+    visitErrorNode() { }
+    enterEveryRule() { }
+    exitEveryRule() { }
+    get statementsContext() {
+        return this._statementsContext;
+    }
+}

package/dist/parser/common/textAndWord.d.ts

@@ -0,0 +1,52 @@
+import type { ParserRuleContext, Token } from 'antlr4ng';
+export interface WordPosition {
+    /** start at 0 */
+    readonly startIndex: number;
+    /** end at ..n-1 */
+    readonly endIndex: number;
+    /** start at 1 */
+    readonly line: number;
+    /** start at 1 */
+    readonly startColumn: number;
+    /** end at ..n + 1 */
+    readonly endColumn: number;
+}
+export interface WordRange extends WordPosition {
+    /** content of word */
+    readonly text: string;
+}
+export interface TextPosition {
+    /** start at 0 */
+    readonly startIndex: number;
+    /** end at ..n-1 */
+    readonly endIndex: number;
+    /** start at 1 */
+    readonly startLine: number;
+    /** end at ..n */
+    readonly endLine: number;
+    /** start at 1 */
+    readonly startColumn: number;
+    /** end at ..n + 1 */
+    readonly endColumn: number;
+}
+export interface TextSlice extends TextPosition {
+    readonly text: string;
+}
+/**
+ * Convert Token to Word
+ */
+export declare function tokenToWord(token: Token, input: string): WordPosition & {
+    text: string;
+};
+/**
+ * Convert ParserRuleContext to Word
+ */
+export declare function ctxToWord(ctx: ParserRuleContext, input: string): (WordPosition & {
+    text: string;
+}) | null;
+/**
+ * Convert ParserRuleContext to Text
+ */
+export declare function ctxToText(ctx: ParserRuleContext, input: string): (TextPosition & {
+    text: string;
+}) | null;

package/dist/parser/common/textAndWord.js

@@ -0,0 +1,58 @@
+/**
+ * Convert Token to Word
+ */
+export function tokenToWord(token, input) {
+    var _a;
+    const startIndex = token.start;
+    const endIndex = token.stop;
+    const text = (_a = token.text) !== null && _a !== void 0 ? _a : '';
+    return {
+        text,
+        line: token.line,
+        startIndex,
+        endIndex,
+        startColumn: token.column + 1,
+        endColumn: token.column + 1 + text.length,
+    };
+}
+/**
+ * Convert ParserRuleContext to Word
+ */
+export function ctxToWord(ctx, input) {
+    var _a, _b;
+    if (!ctx.start || !ctx.stop) {
+        return null;
+    }
+    const startIndex = ctx.start.start;
+    const endIndex = ctx.stop.stop;
+    const text = input.slice(startIndex, endIndex + 1);
+    return {
+        text,
+        line: ctx.start.line,
+        startIndex,
+        endIndex,
+        startColumn: ctx.start.column + 1,
+        endColumn: ctx.stop.column + 1 + ((_b = (_a = ctx.stop.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0),
+    };
+}
+/**
+ * Convert ParserRuleContext to Text
+ */
+export function ctxToText(ctx, input) {
+    var _a, _b;
+    if (!ctx.start || !ctx.stop) {
+        return null;
+    }
+    const startIndex = ctx.start.start;
+    const endIndex = ctx.stop.stop;
+    const text = input.slice(startIndex, endIndex + 1);
+    return {
+        text,
+        startLine: ctx.start.line,
+        endLine: ctx.stop.line,
+        startIndex,
+        endIndex,
+        startColumn: ctx.start.column + 1,
+        endColumn: ctx.stop.column + 1 + ((_b = (_a = ctx.stop.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0),
+    };
+}

package/dist/parser/common/{basic-parser-types.d.ts → types.d.ts}

@@ -1,3 +1,5 @@
+import { WordRange } from './textAndWord';
+import { StmtContextType } from './entityCollector';
 /**
  * The insertion position of the candidate list.
  * Such as cursor position
@@ -11,7 +13,7 @@ export interface CaretPosition {
 /**
  * Syntax context type at caret position
  */
-export declare enum SyntaxContextType {
+export declare enum EntityContextType {
     /** catalog name */
     CATALOG = "catalog",
     /** catalog name that will be created  */
@@ -41,25 +43,11 @@ export declare enum SyntaxContextType {
     /** column name that will be created */
     COLUMN_CREATE = "columnCreate"
 }
-export interface WordRange {
-    /** content of word */
-    readonly text: string;
-    /** start at 0 */
-    readonly startIndex: number;
-    /** end at ..n-1 */
-    readonly endIndex: number;
-    /** start at 1 */
-    readonly line: number;
-    /** start at 1 */
-    readonly startColumn: number;
-    /** end at ..n + 1 */
-    readonly stopColumn: number;
-}
 /**
  * Suggested information analyzed from the input
  */
 export interface SyntaxSuggestion<T = WordRange> {
-    readonly syntaxContextType: SyntaxContextType;
+    readonly syntaxContextType: EntityContextType | StmtContextType;
     readonly wordRanges: T[];
 }
 /**
@@ -75,18 +63,3 @@ export interface Suggestions<T = WordRange> {
      */
     readonly keywords: string[];
 }
-export interface TextSlice {
-    /** start at 0 */
-    readonly startIndex: number;
-    /** end at ..n-1 */
-    readonly endIndex: number;
-    /** start at 1 */
-    readonly startLine: number;
-    /** end at ..n */
-    readonly endLine: number;
-    /** start at 1 */
-    readonly startColumn: number;
-    /** end at ..n + 1 */
-    readonly endColumn: number;
-    readonly text: string;
-}

package/dist/parser/common/types.js

@@ -0,0 +1,34 @@
+/**
+ * Syntax context type at caret position
+ */
+export var EntityContextType;
+(function (EntityContextType) {
+    /** catalog name */
+    EntityContextType["CATALOG"] = "catalog";
+    /** catalog name that will be created  */
+    EntityContextType["CATALOG_CREATE"] = "catalogCreate";
+    /** database name path, such as catalog.db */
+    EntityContextType["DATABASE"] = "database";
+    /** database name path that will be created  */
+    EntityContextType["DATABASE_CREATE"] = "databaseCreate";
+    /** table name path, such as catalog.db.tb */
+    EntityContextType["TABLE"] = "table";
+    /** table name path that will be created */
+    EntityContextType["TABLE_CREATE"] = "tableCreate";
+    /** view name path, such as db.tb.view */
+    EntityContextType["VIEW"] = "view";
+    /** view name path that will be created */
+    EntityContextType["VIEW_CREATE"] = "viewCreate";
+    /** function name */
+    EntityContextType["FUNCTION"] = "function";
+    /** function name that will be created */
+    EntityContextType["FUNCTION_CREATE"] = "functionCreate";
+    /** procedure name */
+    EntityContextType["PROCEDURE"] = "procedure";
+    /** procedure name that will be created */
+    EntityContextType["PROCEDURE_CREATE"] = "procedureCreate";
+    /** column name */
+    EntityContextType["COLUMN"] = "column";
+    /** column name that will be created */
+    EntityContextType["COLUMN_CREATE"] = "columnCreate";
+})(EntityContextType || (EntityContextType = {}));

package/dist/parser/flink/flinkEntityCollector.d.ts

@@ -0,0 +1,33 @@
+import { CatalogPathContext, CatalogPathCreateContext, ColumnNameCreateContext, CreateCatalogContext, CreateDatabaseContext, CreateFunctionContext, CreateTableContext, CreateViewContext, DatabasePathContext, DatabasePathCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SqlStatementContext, TablePathContext, TablePathCreateContext, ViewPathContext, ViewPathCreateContext } from '../../lib/flink/FlinkSqlParser';
+import { FlinkSqlParserListener } from '../../lib/flink/FlinkSqlParserListener';
+import { EntityCollector } from '../common/entityCollector';
+export declare class FlinkEntityCollector extends EntityCollector implements FlinkSqlParserListener {
+    /** ====== Entity Begin */
+    exitCatalogPathCreate(ctx: CatalogPathCreateContext): void;
+    exitCatalogPath(ctx: CatalogPathContext): void;
+    exitDatabasePathCreate(ctx: DatabasePathCreateContext): void;
+    exitDatabasePath(ctx: DatabasePathContext): void;
+    exitTablePath(ctx: TablePathContext): void;
+    exitTablePathCreate(ctx: TablePathCreateContext): void;
+    exitViewPath(ctx: ViewPathContext): void;
+    exitViewPathCreate(ctx: ViewPathCreateContext): void;
+    exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    /** ===== Statement begin */
+    enterSqlStatement(ctx: SqlStatementContext): void;
+    exitSqlStatement(ctx: SqlStatementContext): void;
+    enterCreateCatalog(ctx: CreateCatalogContext): void;
+    exitCreateCatalog(ctx: CreateCatalogContext): void;
+    enterCreateDatabase(ctx: CreateDatabaseContext): void;
+    exitCreateDatabase(ctx: CreateDatabaseContext): void;
+    enterCreateTable(ctx: CreateTableContext): void;
+    exitCreateTable(ctx: CreateTableContext): void;
+    enterCreateView(ctx: CreateViewContext): void;
+    exitCreateView(ctx: CreateViewContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterCreateFunction(ctx: CreateFunctionContext): void;
+    exitCreateFunction(ctx: CreateFunctionContext): void;
+    enterInsertStatement(ctx: InsertStatementContext): void;
+    exitInsertStatement(ctx: InsertStatementContext): void;
+}

package/dist/parser/flink/flinkEntityCollector.js

@@ -0,0 +1,84 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class FlinkEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitCatalogPathCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.CATALOG_CREATE);
+    }
+    exitCatalogPath(ctx) {
+        this.pushEntity(ctx, EntityContextType.CATALOG);
+    }
+    exitDatabasePathCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+    }
+    exitDatabasePath(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitTablePath(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE);
+    }
+    exitTablePathCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+    }
+    exitViewPath(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW);
+    }
+    exitViewPathCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+    }
+    exitColumnNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    exitFunctionNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    }
+    /** ===== Statement begin */
+    enterSqlStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSqlStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateCatalog(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_CATALOG_STMT);
+    }
+    exitCreateCatalog(ctx) {
+        this.popStmt();
+    }
+    enterCreateDatabase(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateDatabase(ctx) {
+        this.popStmt();
+    }
+    enterCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateView(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateFunction(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateFunction(ctx) {
+        this.popStmt();
+    }
+    enterInsertStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertStatement(ctx) {
+        this.popStmt();
+    }
+}

package/dist/parser/flink/flinkSplitListener.d.ts

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

package/dist/parser/flink/flinkSplitListener.js

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

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

@@ -0,0 +1,17 @@
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
+import { FlinkSqlParser, ProgramContext } from '../../lib/flink/FlinkSqlParser';
+import { Suggestions } from '../common/types';
+import { BasicSQL } from '../common/basicSQL';
+import { FlinkSqlSplitListener } from './flinkSplitListener';
+import { FlinkEntityCollector } from './flinkEntityCollector';
+export { FlinkSqlSplitListener, FlinkEntityCollector };
+export declare class FlinkSQL extends BasicSQL<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): FlinkSqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): FlinkSqlParser;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): FlinkSqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): FlinkEntityCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

package/dist/parser/{flinksql.js → flink/index.js}

@@ -1,8 +1,11 @@
-import { FlinkSqlLexer } from '../lib/flinksql/FlinkSqlLexer';
-import { FlinkSqlParser, } from '../lib/flinksql/FlinkSqlParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-import BasicParser from './common/basicParser';
-export default class FlinkSQL extends BasicParser {
+import { FlinkSqlLexer } from '../../lib/flink/FlinkSqlLexer';
+import { FlinkSqlParser } from '../../lib/flink/FlinkSqlParser';
+import { EntityContextType } from '../common/types';
+import { BasicSQL } from '../common/basicSQL';
+import { FlinkSqlSplitListener } from './flinkSplitListener';
+import { FlinkEntityCollector } from './flinkEntityCollector';
+export { FlinkSqlSplitListener, FlinkEntityCollector };
+export class FlinkSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
@@ -20,16 +23,17 @@ export default class FlinkSQL extends BasicParser {
         ]);
     }
     createLexerFromCharStream(charStreams) {
-        const lexer = new FlinkSqlLexer(charStreams);
-        return lexer;
+        return new FlinkSqlLexer(charStreams);
     }
     createParserFromTokenStream(tokenStream) {
-        const parser = new FlinkSqlParser(tokenStream);
-        return parser;
+        return new FlinkSqlParser(tokenStream);
     }
     get splitListener() {
         return new FlinkSqlSplitListener();
     }
+    createEntityCollector(input, caretTokenIndex) {
+        return new FlinkEntityCollector(input, caretTokenIndex);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
@@ -37,50 +41,50 @@ export default class FlinkSQL 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 FlinkSqlParser.RULE_catalogPath: {
-                    syntaxContextType = SyntaxContextType.CATALOG;
+                    syntaxContextType = EntityContextType.CATALOG;
                     break;
                 }
                 case FlinkSqlParser.RULE_databasePath: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
+                    syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
                 case FlinkSqlParser.RULE_databasePathCreate: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
                 case FlinkSqlParser.RULE_tablePath: {
-                    syntaxContextType = SyntaxContextType.TABLE;
+                    syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
                 case FlinkSqlParser.RULE_tablePathCreate: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
                 case FlinkSqlParser.RULE_viewPath: {
-                    syntaxContextType = SyntaxContextType.VIEW;
+                    syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
                 case FlinkSqlParser.RULE_viewPathCreate: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
                 case FlinkSqlParser.RULE_functionName: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 case FlinkSqlParser.RULE_functionNameCreate: {
-                    syntaxContextType = SyntaxContextType.FUNCTION_CREATE;
+                    syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
                 case FlinkSqlParser.RULE_columnName: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
+                    syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
                 case FlinkSqlParser.RULE_columnNameCreate: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
                 default:
@@ -96,7 +100,7 @@ export default class FlinkSQL 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;
@@ -109,18 +113,3 @@ export default class FlinkSQL extends BasicParser {
         };
     }
 }
-export class FlinkSqlSplitListener {
-    constructor() {
-        this._statementsContext = [];
-        this.exitSingleStatement = (ctx) => {
-            this._statementsContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementsContext;
-    }
-}

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

@@ -0,0 +1,35 @@
+import { HiveSqlParserListener } from '../../lib';
+import { ColumnNameCreateContext, CreateDatabaseStatementContext, CreateFunctionStatementContext, CreateMaterializedViewStatementContext, CreateTableStatementContext, CreateViewStatementContext, DbSchemaNameContext, DbSchemaNameCreateContext, FromInsertStmtContext, FromSelectStmtContext, FunctionNameCreateContext, InsertStmtContext, SelectStatementContext, StatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/hive/HiveSqlParser';
+import { EntityCollector } from '../common/entityCollector';
+export declare class HiveEntityCollector extends EntityCollector implements HiveSqlParserListener {
+    /** ====== Entity Begin */
+    exitTableNameCreate(ctx: TableNameCreateContext): void;
+    exitTableName(ctx: TableNameContext): void;
+    exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    exitViewNameCreate(ctx: ViewNameCreateContext): void;
+    exitViewName(ctx: ViewNameContext): void;
+    exitDbSchemaNameCreate(ctx: DbSchemaNameCreateContext): void;
+    exitDbSchemaName(ctx: DbSchemaNameContext): void;
+    exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    /** ==== Statement begin */
+    enterStatement(ctx: StatementContext): void;
+    exitStatement(): void;
+    enterCreateTableStatement(ctx: CreateTableStatementContext): void;
+    exitCreateTableStatement(): void;
+    enterSelectStatement(ctx: SelectStatementContext): void;
+    exitSelectStatement(ctx: SelectStatementContext): void;
+    enterFromSelectStmt(ctx: FromSelectStmtContext): void;
+    exitFromSelectStmt(ctx: FromSelectStmtContext): void;
+    enterCreateViewStatement(ctx: CreateViewStatementContext): void;
+    exitCreateViewStatement(ctx: CreateViewStatementContext): void;
+    enterCreateMaterializedViewStatement(ctx: CreateMaterializedViewStatementContext): void;
+    exitCreateMaterializedViewStatement(ctx: CreateMaterializedViewStatementContext): void;
+    enterInsertStmt(ctx: InsertStmtContext): void;
+    exitInsertStmt(ctx: InsertStmtContext): void;
+    enterFromInsertStmt(ctx: FromInsertStmtContext): void;
+    exitFromInsertStmt(ctx: FromInsertStmtContext): void;
+    enterCreateDatabaseStatement(ctx: CreateDatabaseStatementContext): void;
+    exitCreateDatabaseStatement(ctx: CreateDatabaseStatementContext): void;
+    enterFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    exitCreateFunctionStatement(ctx: CreateFunctionStatementContext): void;
+}

package/dist/parser/hive/hiveEntityCollector.js

@@ -0,0 +1,90 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class HiveEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+    }
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE);
+    }
+    exitColumnNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    exitViewNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+    }
+    exitViewName(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW);
+    }
+    exitDbSchemaNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+    }
+    exitDbSchemaName(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitFunctionNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    }
+    /** ==== Statement begin */
+    enterStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitStatement() {
+        this.popStmt();
+    }
+    enterCreateTableStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTableStatement() {
+        this.popStmt();
+    }
+    enterSelectStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitSelectStatement(ctx) {
+        this.popStmt();
+    }
+    enterFromSelectStmt(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitFromSelectStmt(ctx) {
+        this.popStmt();
+    }
+    enterCreateViewStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateViewStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateMaterializedViewStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateMaterializedViewStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsertStmt(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertStmt(ctx) {
+        this.popStmt();
+    }
+    enterFromInsertStmt(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitFromInsertStmt(ctx) {
+        this.popStmt();
+    }
+    enterCreateDatabaseStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateDatabaseStatement(ctx) {
+        this.popStmt();
+    }
+    enterFunctionNameCreate(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateFunctionStatement(ctx) {
+        this.popStmt();
+    }
+}

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

@@ -0,0 +1,6 @@
+import { StatementContext } from '../../lib/hive/HiveSqlParser';
+import { HiveSqlParserListener } from '../../lib/hive/HiveSqlParserListener';
+import { SplitListener } from '../common/splitListener';
+export declare class HiveSqlSplitListener extends SplitListener<StatementContext> implements HiveSqlParserListener {
+    exitStatement(ctx: StatementContext): void;
+}