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

package/dist/parser/spark/sparkEntityCollector.js

@@ -0,0 +1,96 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class SparkEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitNamespaceName(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitNamespaceNameCreate(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();
+    }
+    enterCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateTableLike(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTableLike(ctx) {
+        this.popStmt();
+    }
+    enterReplaceTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitReplaceTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateView(ctx) {
+        this.popStmt();
+    }
+    enterCreateTempViewUsing(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateTempViewUsing(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsertFromQuery(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertFromQuery(ctx) {
+        this.popStmt();
+    }
+    enterMultipleInsert(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitMultipleInsert(ctx) {
+        this.popStmt();
+    }
+    enterCreateNamespace(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateNamespace(ctx) {
+        this.popStmt();
+    }
+    enterCreateFunction(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateFunction(ctx) {
+        this.popStmt();
+    }
+}

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

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

package/dist/parser/spark/sparkSplitListener.js

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

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

@@ -0,0 +1,17 @@
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
+import { TrinoSqlParser, ProgramContext } from '../../lib/trino/TrinoSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions } from '../common/types';
+import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { TrinoEntityCollector } from './trinoEntityCollector';
+export { TrinoSqlSplitListener, TrinoEntityCollector };
+export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): TrinoSqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): TrinoSqlParser;
+    protected get splitListener(): TrinoSqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): TrinoEntityCollector;
+    protected preferredRules: Set<number>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

package/dist/parser/{trinosql.js → trino/index.js}

@@ -1,8 +1,11 @@
-import { TrinoSqlLexer } from '../lib/trinosql/TrinoSqlLexer';
-import { TrinoSqlParser, } from '../lib/trinosql/TrinoSqlParser';
-import BasicParser from './common/basicParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-export default class TrinoSQL extends BasicParser {
+import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
+import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType } from '../common/types';
+import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { TrinoEntityCollector } from './trinoEntityCollector';
+export { TrinoSqlSplitListener, TrinoEntityCollector };
+export class TrinoSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
@@ -20,16 +23,17 @@ export default class TrinoSQL extends BasicParser {
         ]);
     }
     createLexerFromCharStream(charStreams) {
-        const lexer = new TrinoSqlLexer(charStreams);
-        return lexer;
+        return new TrinoSqlLexer(charStreams);
     }
     createParserFromTokenStream(tokenStream) {
-        const parser = new TrinoSqlParser(tokenStream);
-        return parser;
+        return new TrinoSqlParser(tokenStream);
     }
     get splitListener() {
         return new TrinoSqlSplitListener();
     }
+    createEntityCollector(input, caretTokenIndex) {
+        return new TrinoEntityCollector(input, caretTokenIndex);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
@@ -37,46 +41,46 @@ export default class TrinoSQL 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 TrinoSqlParser.RULE_catalogName: {
-                    syntaxContextType = SyntaxContextType.CATALOG;
+                    syntaxContextType = EntityContextType.CATALOG;
                     break;
                 }
                 case TrinoSqlParser.RULE_schemaName: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
+                    syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
                 case TrinoSqlParser.RULE_schemaNameCreate: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_tableName: {
-                    syntaxContextType = SyntaxContextType.TABLE;
+                    syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
                 case TrinoSqlParser.RULE_tableNameCreate: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_viewName: {
-                    syntaxContextType = SyntaxContextType.VIEW;
+                    syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
                 case TrinoSqlParser.RULE_viewNameCreate: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_functionName: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 case TrinoSqlParser.RULE_columnNameCreate: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_columnName: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
+                    syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
                 default:
@@ -92,7 +96,7 @@ export default class TrinoSQL 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 +109,3 @@ export default class TrinoSQL extends BasicParser {
         };
     }
 }
-export class TrinoSqlSplitListener {
-    constructor() {
-        this._statementsContext = [];
-        this.exitSingleStatement = (ctx) => {
-            this._statementsContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementsContext;
-    }
-}

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

@@ -0,0 +1,30 @@
+import type { ColumnNameCreateContext, CreateMaterializedViewContext, CreateSchemaContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, InsertIntoContext, QueryStatementContext, SchemaNameContext, SchemaNameCreateContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/trino/TrinoSqlParser';
+import type { TrinoSqlListener } from '../../lib/trino/TrinoSqlListener';
+import { EntityCollector } from '../common/entityCollector';
+export declare class TrinoEntityCollector extends EntityCollector implements TrinoSqlListener {
+    /** ====== Entity Begin */
+    exitSchemaName(ctx: SchemaNameContext): void;
+    exitSchemaNameCreate(ctx: SchemaNameCreateContext): void;
+    exitTableName(ctx: TableNameContext): void;
+    exitTableNameCreate(ctx: TableNameCreateContext): void;
+    exitViewName(ctx: ViewNameContext): void;
+    exitViewNameCreate(ctx: ViewNameCreateContext): void;
+    exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    /** ===== Statement begin */
+    enterSingleStatement(ctx: SingleStatementContext): void;
+    exitSingleStatement(ctx: SingleStatementContext): void;
+    enterCreateSchema(ctx: CreateSchemaContext): void;
+    exitCreateSchema(ctx: CreateSchemaContext): void;
+    enterCreateTableAsSelect(ctx: CreateTableAsSelectContext): void;
+    exitCreateTableAsSelect(ctx: CreateTableAsSelectContext): void;
+    enterCreateTable(ctx: CreateTableContext): void;
+    exitCreateTable(ctx: CreateTableContext): void;
+    enterCreateView(ctx: CreateViewContext): void;
+    exitCreateView(ctx: CreateViewContext): void;
+    enterCreateMaterializedView(ctx: CreateMaterializedViewContext): void;
+    exitCreateMaterializedView(ctx: CreateMaterializedViewContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterInsertInto(ctx: InsertIntoContext): void;
+    exitInsertInto(ctx: InsertIntoContext): void;
+}

package/dist/parser/trino/trinoEntityCollector.js

@@ -0,0 +1,75 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class TrinoEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitSchemaName(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitSchemaNameCreate(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);
+    }
+    exitColumnNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateSchema(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateSchema(ctx) {
+        this.popStmt();
+    }
+    enterCreateTableAsSelect(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTableAsSelect(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();
+    }
+    enterCreateMaterializedView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateMaterializedView(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsertInto(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertInto(ctx) {
+        this.popStmt();
+    }
+}

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

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

package/dist/parser/trino/trinoSplitListener.js

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

package/dist/utils/index.d.ts

@@ -9,7 +9,7 @@ declare function legacy_lexer(input: string): Legacy_Token[];
  * @param {String} sql
  * @deprecated use parser.splitSQLByStatement() instead.
  */
-declare function legacy_splitSql(sql: string): any[];
+declare function legacy_splitSql(sql: string): string[];
 /**
  * clean comment
  * @param {String} sql

package/dist/utils/token.d.ts

@@ -39,7 +39,7 @@ export declare enum Legacy_TokenType {
 export interface Legacy_Token {
     type: Legacy_TokenType;
     value: string;
-    start: number;
+    start?: number;
     end: number;
     lineNumber: number;
     message?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-sql-parser",
-  "version": "4.0.0-ng.1",
+  "version": "4.0.0",
   "authors": "DTStack Corporation",
   "description": "SQL Parsers for BigData, built with antlr4",
   "keywords": [
@@ -60,8 +60,8 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "antlr4-c3": "3.3.6",
-    "antlr4ng": "2.0.10"
+    "antlr4-c3": "3.3.7",
+    "antlr4ng": "2.0.11"
   },
   "sideEffects": false
 }

package/dist/parser/common/basic-parser-types.js

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

package/dist/parser/flinksql.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { FlinkSqlLexer } from '../lib/flinksql/FlinkSqlLexer';
-import { FlinkSqlParser, ProgramContext, SingleStatementContext } from '../lib/flinksql/FlinkSqlParser';
-import { FlinkSqlParserListener } from '../lib/flinksql/FlinkSqlParserListener';
-import { Suggestions } from './common/basic-parser-types';
-import BasicParser from './common/basicParser';
-export default class FlinkSQL extends BasicParser<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): FlinkSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): FlinkSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): FlinkSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class FlinkSqlSplitListener implements FlinkSqlParserListener {
-    private _statementsContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/parser/hive.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { HiveSqlLexer } from '../lib/hive/HiveSqlLexer';
-import { HiveSqlParser, ProgramContext, StatementContext } from '../lib/hive/HiveSqlParser';
-import BasicParser from './common/basicParser';
-import { HiveSqlParserListener } from '../lib/hive/HiveSqlParserListener';
-import { Suggestions } from './common/basic-parser-types';
-export default class HiveSQL extends BasicParser<HiveSqlLexer, ProgramContext, HiveSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): HiveSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): HiveSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): HiveSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class HiveSqlSplitListener implements HiveSqlParserListener {
-    private _statementContext;
-    exitStatement: (ctx: StatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): StatementContext[];
-}

package/dist/parser/impala.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { ImpalaSqlLexer } from '../lib/impala/ImpalaSqlLexer';
-import { ImpalaSqlParser, ProgramContext, SingleStatementContext } from '../lib/impala/ImpalaSqlParser';
-import BasicParser from './common/basicParser';
-import { ImpalaSqlParserListener } from '../lib/impala/ImpalaSqlParserListener';
-import { Suggestions } from './common/basic-parser-types';
-export default class ImpalaSQL extends BasicParser<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): ImpalaSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): ImpalaSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): ImpalaSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class ImpalaSqlSplitListener implements ImpalaSqlParserListener {
-    private _statementContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/parser/mysql.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { MySqlLexer } from '../lib/mysql/MySqlLexer';
-import { MySqlParser, ProgramContext, SingleStatementContext } from '../lib/mysql/MySqlParser';
-import BasicParser from './common/basicParser';
-import { Suggestions } from './common/basic-parser-types';
-import { MySqlParserListener } from '../lib/mysql/MySqlParserListener';
-export default class MySQL extends BasicParser<MySqlLexer, ProgramContext, MySqlParser> {
-    protected createLexerFromCharStream(charStreams: any): MySqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): MySqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): MysqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class MysqlSplitListener implements MySqlParserListener {
-    private _statementsContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/parser/pgsql.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { PostgreSQLLexer } from '../lib/pgsql/PostgreSQLLexer';
-import { PostgreSQLParser, ProgramContext, SingleStmtContext } from '../lib/pgsql/PostgreSQLParser';
-import BasicParser from './common/basicParser';
-import { PostgreSQLParserListener } from '../lib/pgsql/PostgreSQLParserListener';
-import { Suggestions } from './common/basic-parser-types';
-export default class PostgresSQL extends BasicParser<PostgreSQLLexer, ProgramContext, PostgreSQLParser> {
-    protected createLexerFromCharStream(charStreams: any): PostgreSQLLexer;
-    protected createParserFromTokenStream(tokenStream: any): PostgreSQLParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): PgSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class PgSqlSplitListener implements PostgreSQLParserListener {
-    private _statementsContext;
-    exitSingleStmt: (ctx: SingleStmtContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStmtContext[];
-}