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

package/dist/parser/mysql/mysqlEntityCollector.js

@@ -0,0 +1,96 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class MySqlEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitDatabaseName(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitDatabaseNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+    }
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE);
+    }
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+    }
+    exitViewName(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW);
+    }
+    exitViewNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+    }
+    exitFunctionNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    }
+    exitColumnNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterQueryCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitQueryCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterColumnCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitColumnCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterCopyCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCopyCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateView(ctx) {
+        this.popStmt();
+    }
+    enterSimpleSelect(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitSimpleSelect(ctx) {
+        this.popStmt();
+    }
+    enterUnionAndLateralSelect(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitUnionAndLateralSelect(ctx) {
+        this.popStmt();
+    }
+    enterSelectExpression(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitSelectExpression(ctx) {
+        this.popStmt();
+    }
+    enterInsertStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateDatabase(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateDatabase(ctx) {
+        this.popStmt();
+    }
+    enterCreateFunction(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateFunction(ctx) {
+        this.popStmt();
+    }
+}

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

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

package/dist/parser/mysql/mysqlSplitListener.js

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

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

@@ -0,0 +1,17 @@
+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 { Suggestions } from '../common/types';
+import { BasicSQL } from '../common/basicSQL';
+import { PostgreSqlEntityCollector } from './postgreEntityCollector';
+import { PostgreSqlSplitListener } from './postgreSplitListener';
+export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
+export declare class PostgreSQL extends BasicSQL<PostgreSqlLexer, ProgramContext, PostgreSqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): PostgreSqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): PostgreSqlParser;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): PostgreSqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): PostgreSqlEntityCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

package/dist/parser/postgresql/index.js

@@ -0,0 +1,130 @@
+import { PostgreSqlLexer } from '../../lib/postgresql/PostgreSqlLexer';
+import { PostgreSqlParser } from '../../lib/postgresql/PostgreSqlParser';
+import { EntityContextType } from '../common/types';
+import { BasicSQL } from '../common/basicSQL';
+import { PostgreSqlEntityCollector } from './postgreEntityCollector';
+import { PostgreSqlSplitListener } from './postgreSplitListener';
+export { PostgreSqlEntityCollector, PostgreSqlSplitListener };
+export class PostgreSQL extends BasicSQL {
+    constructor() {
+        super(...arguments);
+        this.preferredRules = new Set([
+            PostgreSqlParser.RULE_table_name_create,
+            PostgreSqlParser.RULE_table_name,
+            PostgreSqlParser.RULE_function_name,
+            PostgreSqlParser.RULE_function_name_create,
+            PostgreSqlParser.RULE_schema_name_create,
+            PostgreSqlParser.RULE_schema_name,
+            PostgreSqlParser.RULE_view_name_create,
+            PostgreSqlParser.RULE_view_name,
+            PostgreSqlParser.RULE_database_name_create,
+            PostgreSqlParser.RULE_database_name,
+            PostgreSqlParser.RULE_procedure_name_create,
+            PostgreSqlParser.RULE_procedure_name,
+            PostgreSqlParser.RULE_column_name_create,
+            PostgreSqlParser.RULE_column_name, // column name
+        ]);
+    }
+    createLexerFromCharStream(charStreams) {
+        return new PostgreSqlLexer(charStreams);
+    }
+    createParserFromTokenStream(tokenStream) {
+        return new PostgreSqlParser(tokenStream);
+    }
+    get splitListener() {
+        return new PostgreSqlSplitListener();
+    }
+    createEntityCollector(input, caretTokenIndex) {
+        return new PostgreSqlEntityCollector(input, caretTokenIndex);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
+        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);
+            let syntaxContextType = void 0;
+            switch (ruleType) {
+                case PostgreSqlParser.RULE_table_name_create: {
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_table_name: {
+                    syntaxContextType = EntityContextType.TABLE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_function_name_create: {
+                    syntaxContextType = EntityContextType.FUNCTION_CREATE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_function_name: {
+                    syntaxContextType = EntityContextType.FUNCTION;
+                    break;
+                }
+                case PostgreSqlParser.RULE_schema_name_create: {
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_schema_name: {
+                    syntaxContextType = EntityContextType.DATABASE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_view_name_create: {
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_view_name: {
+                    syntaxContextType = EntityContextType.VIEW;
+                    break;
+                }
+                case PostgreSqlParser.RULE_database_name_create: {
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_database_name: {
+                    syntaxContextType = EntityContextType.DATABASE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_procedure_name_create: {
+                    syntaxContextType = EntityContextType.PROCEDURE_CREATE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_procedure_name: {
+                    syntaxContextType = EntityContextType.PROCEDURE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_column_name_create: {
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
+                    break;
+                }
+                case PostgreSqlParser.RULE_column_name: {
+                    syntaxContextType = EntityContextType.COLUMN;
+                    break;
+                }
+                default:
+                    break;
+            }
+            if (syntaxContextType) {
+                originalSyntaxSuggestions.push({
+                    syntaxContextType,
+                    wordRanges: tokenRanges,
+                });
+            }
+        }
+        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);
+            }
+        }
+        return {
+            syntax: originalSyntaxSuggestions,
+            keywords,
+        };
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { ColumnCreateTableContext, ColumnNameCreateContext, CreateDatabaseContext, CreateForeignTableContext, CreateMaterializedViewContext, CreatePartitionForeignTableContext, CreateViewContext, CreatefunctionstmtContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectStatementContext, SingleStmtContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/postgresql/PostgreSqlParser';
+import type { PostgreSqlParserListener } from '../../lib/postgresql/PostgreSqlParserListener';
+import { EntityCollector } from '../common/entityCollector';
+export declare class PostgreSqlEntityCollector extends EntityCollector implements PostgreSqlParserListener {
+    /** ====== 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: SingleStmtContext): void;
+    exitSingleStatement(ctx: SingleStmtContext): void;
+    enterCreateDatabase(ctx: CreateDatabaseContext): void;
+    exitCreateDatabase(ctx: CreateDatabaseContext): void;
+    enterQueryCreateTable(ctx: QueryCreateTableContext): void;
+    exitQueryCreateTable(ctx: QueryCreateTableContext): void;
+    enterColumnCreateTable(ctx: ColumnCreateTableContext): void;
+    exitColumnCreateTable(ctx: ColumnCreateTableContext): void;
+    enterCreateForeignTable(ctx: CreateForeignTableContext): void;
+    exitCreateForeignTable(ctx: CreateForeignTableContext): void;
+    enterCreatePartitionForeignTable(ctx: CreatePartitionForeignTableContext): void;
+    exitCreatePartitionForeignTable(ctx: CreatePartitionForeignTableContext): void;
+    enterCreateView(ctx: CreateViewContext): void;
+    exitCreateView(ctx: CreateViewContext): void;
+    enterCreateMaterializedView(ctx: CreateMaterializedViewContext): void;
+    exitCreateMaterializedView(ctx: CreateMaterializedViewContext): void;
+    enterSelectStatement(ctx: SelectStatementContext): void;
+    exitSelectStatement(ctx: SelectStatementContext): void;
+    enterInsertStatement(ctx: InsertStatementContext): void;
+    exitInsertStatement(ctx: InsertStatementContext): void;
+    enterCreatefunctionstmt(ctx: CreatefunctionstmtContext): void;
+    exitCreatefunctionstmt(ctx: CreatefunctionstmtContext): void;
+}

package/dist/parser/postgresql/postgreEntityCollector.js

@@ -0,0 +1,96 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class PostgreSqlEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitDatabaseName(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitDatabaseNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+    }
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE);
+    }
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+    }
+    exitViewName(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW);
+    }
+    exitViewNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+    }
+    exitFunctionNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    }
+    exitColumnNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateDatabase(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateDatabase(ctx) {
+        this.popStmt();
+    }
+    enterQueryCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitQueryCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterColumnCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitColumnCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateForeignTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateForeignTable(ctx) {
+        this.popStmt();
+    }
+    enterCreatePartitionForeignTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreatePartitionForeignTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateView(ctx) {
+        this.popStmt();
+    }
+    enterCreateMaterializedView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateMaterializedView(ctx) {
+        this.popStmt();
+    }
+    enterSelectStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitSelectStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsertStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreatefunctionstmt(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreatefunctionstmt(ctx) {
+        this.popStmt();
+    }
+}

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

@@ -0,0 +1,6 @@
+import { SingleStmtContext } from '../../lib/postgresql/PostgreSqlParser';
+import { PostgreSqlParserListener } from '../../lib/postgresql/PostgreSqlParserListener';
+import { SplitListener } from '../common/splitListener';
+export declare class PostgreSqlSplitListener extends SplitListener<SingleStmtContext> implements PostgreSqlParserListener {
+    exitSingleStmt(ctx: SingleStmtContext): void;
+}

package/dist/parser/postgresql/postgreSplitListener.js

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

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

@@ -0,0 +1,17 @@
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
+import { SparkSqlParser, ProgramContext } from '../../lib/spark/SparkSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions } from '../common/types';
+import { SparkSqlSplitListener } from './sparkSplitListener';
+import { SparkEntityCollector } from './sparkEntityCollector';
+export { SparkSqlSplitListener, SparkEntityCollector };
+export declare class SparkSQL extends BasicSQL<SparkSqlLexer, ProgramContext, SparkSqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): SparkSqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): SparkSqlParser;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): SparkSqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): SparkEntityCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

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

@@ -1,13 +1,16 @@
-import { SparkSqlLexer } from '../lib/spark/SparkSqlLexer';
-import { SparkSqlParser, } from '../lib/spark/SparkSqlParser';
-import BasicParser from './common/basicParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-export default class SparkSQL extends BasicParser {
+import { SparkSqlLexer } from '../../lib/spark/SparkSqlLexer';
+import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType } from '../common/types';
+import { SparkSqlSplitListener } from './sparkSplitListener';
+import { SparkEntityCollector } from './sparkEntityCollector';
+export { SparkSqlSplitListener, SparkEntityCollector };
+export class SparkSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
-            SparkSqlParser.RULE_dbSchemaName,
-            SparkSqlParser.RULE_dbSchemaNameCreate,
+            SparkSqlParser.RULE_namespaceName,
+            SparkSqlParser.RULE_namespaceNameCreate,
             SparkSqlParser.RULE_tableName,
             SparkSqlParser.RULE_tableNameCreate,
             SparkSqlParser.RULE_viewName,
@@ -19,16 +22,17 @@ export default class SparkSQL extends BasicParser {
         ]);
     }
     createLexerFromCharStream(charStreams) {
-        const lexer = new SparkSqlLexer(charStreams);
-        return lexer;
+        return new SparkSqlLexer(charStreams);
     }
     createParserFromTokenStream(tokenStream) {
-        const parser = new SparkSqlParser(tokenStream);
-        return parser;
+        return new SparkSqlParser(tokenStream);
     }
     get splitListener() {
         return new SparkSqlSplitListener();
     }
+    createEntityCollector(input, caretTokenIndex) {
+        return new SparkEntityCollector(input, caretTokenIndex);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
@@ -36,46 +40,46 @@ export default class SparkSQL 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 SparkSqlParser.RULE_dbSchemaName: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
+                case SparkSqlParser.RULE_namespaceName: {
+                    syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
-                case SparkSqlParser.RULE_dbSchemaNameCreate: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
+                case SparkSqlParser.RULE_namespaceNameCreate: {
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
                 case SparkSqlParser.RULE_tableName: {
-                    syntaxContextType = SyntaxContextType.TABLE;
+                    syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
                 case SparkSqlParser.RULE_tableNameCreate: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
                 case SparkSqlParser.RULE_viewName: {
-                    syntaxContextType = SyntaxContextType.VIEW;
+                    syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
                 case SparkSqlParser.RULE_viewNameCreate: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
                 case SparkSqlParser.RULE_functionName: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 case SparkSqlParser.RULE_functionNameCreate: {
-                    syntaxContextType = SyntaxContextType.FUNCTION_CREATE;
+                    syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
                 case SparkSqlParser.RULE_columnName: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
+                    syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
                 case SparkSqlParser.RULE_columnNameCreate: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
                 default:
@@ -91,7 +95,7 @@ export default class SparkSQL 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;
@@ -104,18 +108,3 @@ export default class SparkSQL extends BasicParser {
         };
     }
 }
-export class SparkSqlSplitListener {
-    constructor() {
-        this._statementsContext = [];
-        this.exitSingleStatement = (ctx) => {
-            this._statementsContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementsContext;
-    }
-}

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

@@ -0,0 +1,37 @@
+import type { NamespaceNameContext, NamespaceNameCreateContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, FunctionNameCreateContext, ColumnNameCreateContext, CreateTableContext, CreateTableLikeContext, ReplaceTableContext, QueryStatementContext, InsertFromQueryContext, MultipleInsertContext, CreateViewContext, CreateTempViewUsingContext, CreateNamespaceContext, CreateFunctionContext } from '../../lib/spark/SparkSqlParser';
+import type { SparkSqlParserListener } from '../../lib/spark/SparkSqlParserListener';
+import { EntityCollector } from '../common/entityCollector';
+export declare class SparkEntityCollector extends EntityCollector implements SparkSqlParserListener {
+    /** ====== Entity Begin */
+    exitNamespaceName(ctx: NamespaceNameContext): void;
+    exitNamespaceNameCreate(ctx: NamespaceNameCreateContext): 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;
+    enterCreateTable(ctx: CreateTableContext): void;
+    exitCreateTable(ctx: CreateTableContext): void;
+    enterCreateTableLike(ctx: CreateTableLikeContext): void;
+    exitCreateTableLike(ctx: CreateTableLikeContext): void;
+    enterReplaceTable(ctx: ReplaceTableContext): void;
+    exitReplaceTable(ctx: ReplaceTableContext): void;
+    enterCreateView(ctx: CreateViewContext): void;
+    exitCreateView(ctx: CreateViewContext): void;
+    enterCreateTempViewUsing(ctx: CreateTempViewUsingContext): void;
+    exitCreateTempViewUsing(ctx: CreateTempViewUsingContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterInsertFromQuery(ctx: InsertFromQueryContext): void;
+    exitInsertFromQuery(ctx: InsertFromQueryContext): void;
+    enterMultipleInsert(ctx: MultipleInsertContext): void;
+    exitMultipleInsert(ctx: MultipleInsertContext): void;
+    enterCreateNamespace(ctx: CreateNamespaceContext): void;
+    exitCreateNamespace(ctx: CreateNamespaceContext): void;
+    enterCreateFunction(ctx: CreateFunctionContext): void;
+    exitCreateFunction(ctx: CreateFunctionContext): void;
+}