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

package/dist/lib/{trinosql → trino}/TrinoSqlVisitor.d.ts

@@ -79,7 +79,7 @@ import { UpdateContext } from "./TrinoSqlParser.js";
 import { MergeContext } from "./TrinoSqlParser.js";
 import { ShowTableCommentContext } from "./TrinoSqlParser.js";
 import { ShowColumnCommentContext } from "./TrinoSqlParser.js";
-import { QueryContext } from "./TrinoSqlParser.js";
+import { QueryStatementContext } from "./TrinoSqlParser.js";
 import { WithContext } from "./TrinoSqlParser.js";
 import { TableElementContext } from "./TrinoSqlParser.js";
 import { ColumnDefinitionContext } from "./TrinoSqlParser.js";
@@ -838,11 +838,12 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      */
     visitShowColumnComment?: (ctx: ShowColumnCommentContext) => Result;
     /**
-     * Visit a parse tree produced by `TrinoSqlParser.query`.
+     * Visit a parse tree produced by the `queryStatement`
+     * labeled alternative in `TrinoSqlParser.query`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitQuery?: (ctx: QueryContext) => Result;
+    visitQueryStatement?: (ctx: QueryStatementContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.with`.
      * @param ctx the parse tree

package/dist/lib/{trinosql → trino}/TrinoSqlVisitor.js

@@ -1,4 +1,5 @@
-// Generated from dt-sql-parser/src/grammar/trinosql/TrinoSql.g4 by ANTLR 4.13.1
+// Generated from dt-sql-parser/src/grammar/trino/TrinoSql.g4 by ANTLR 4.13.1
+// @ts-nocheck
 import { AbstractParseTreeVisitor } from "antlr4ng";
 /**
  * This interface defines a complete generic visitor for a parse tree produced

package/dist/parser/common/{basicParser.d.ts → basicSQL.d.ts}

@@ -1,23 +1,22 @@
-import { Parser, Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener } from 'antlr4ng';
+import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
-import { CaretPosition, Suggestions, TextSlice } from './basic-parser-types';
+import { SQLParserBase } from '../../lib/SQLParserBase';
+import { TextSlice } from './textAndWord';
+import { CaretPosition, Suggestions } from './types';
 import { ParseError, ErrorListener } from './parseErrorListener';
-interface IParser<IParserRuleContext extends ParserRuleContext> extends Parser {
-    program(): IParserRuleContext;
-}
-interface SplitListener extends ParseTreeListener {
-    statementsContext: ParserRuleContext[];
-}
+import type { SplitListener } from './splitListener';
+import type { EntityCollector } from './entityCollector';
+import { EntityContext } from './entityCollector';
 /**
- * Custom Parser class, subclass needs extends it.
+ * Basic SQL class, every sql needs extends it.
  */
-export default abstract class BasicParser<L extends Lexer = Lexer, PRC extends ParserRuleContext = ParserRuleContext, P extends IParser<PRC> = IParser<PRC>> {
+export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends ParserRuleContext = ParserRuleContext, P extends SQLParserBase<PRC> = SQLParserBase<PRC>> {
     /** members for cache start */
     protected _charStreams: CharStream;
     protected _lexer: L;
     protected _tokenStream: CommonTokenStream;
     protected _parser: P;
-    protected _parseTree: PRC;
+    protected _parseTree: PRC | null;
     protected _parsedInput: string;
     protected _parseErrors: ParseError[];
     /** members for cache end */
@@ -45,26 +44,30 @@ export default abstract class BasicParser<L extends Lexer = Lexer, PRC extends P
      */
     protected abstract processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
     /**
-     * Get splitListener instance.
+     * Get a new splitListener instance.
+     */
+    protected abstract get splitListener(): SplitListener<ParserRuleContext>;
+    /**
+     * Get a new entityCollector instance.
      */
-    protected abstract get splitListener(): SplitListener;
+    protected abstract createEntityCollector(input: string, caretTokenIndex?: number): EntityCollector;
     /**
      * Create an antlr4 lexer from input.
      * @param input string
      */
-    createLexer(input: string, errorListener?: ErrorListener<any>): L;
+    createLexer(input: string, errorListener?: ErrorListener): L;
     /**
      * Create an antlr4 parser from input.
      * @param input string
      */
-    createParser(input: string, errorListener?: ErrorListener<any>): P;
+    createParser(input: string, errorListener?: ErrorListener): P;
     /**
      * Parse input string and return parseTree.
      * @param input string
      * @param errorListener listen parse errors and lexer errors.
      * @returns parseTree
      */
-    parse(input: string, errorListener?: ErrorListener<any>): PRC;
+    parse(input: string, errorListener?: ErrorListener): PRC;
     /**
      * Create an antlr4 parser from input.
      * And the instances will be cache.
@@ -96,13 +99,13 @@ export default abstract class BasicParser<L extends Lexer = Lexer, PRC extends P
      * @param listener Listener instance extends ParserListener
      * @param parseTree parser Tree
      */
-    listen<PTL extends ParseTreeListener = ParseTreeListener>(listener: PTL, parseTree: PRC): void;
+    listen<PTL extends ParseTreeListener = ParseTreeListener>(listener: PTL, parseTree: ParserRuleContext): void;
     /**
      * Split input into statements.
      * If exist syntax error it will return null.
      * @param input source string
      */
-    splitSQLByStatement(input: any): TextSlice[];
+    splitSQLByStatement(input: string): TextSlice[] | null;
     /**
      * Get suggestions of syntax and token at caretPosition
      * @param input source string
@@ -110,5 +113,5 @@ export default abstract class BasicParser<L extends Lexer = Lexer, PRC extends P
      * @returns suggestion
      */
     getSuggestionAtCaretPosition(input: string, caretPosition: CaretPosition): Suggestions | null;
+    getAllEntities(input: string, caretPosition?: CaretPosition): EntityContext[] | null;
 }
-export {};

package/dist/parser/common/{basicParser.js → basicSQL.js}

@@ -1,14 +1,14 @@
-import { CharStreams, CommonTokenStream, ParseTreeWalker, } from 'antlr4ng';
+import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
 import { CodeCompletionCore } from 'antlr4-c3';
-import { findCaretTokenIndex } from './utils/findCaretTokenIndex';
-import ParseErrorListener from './parseErrorListener';
+import { findCaretTokenIndex } from './findCaretTokenIndex';
+import { ctxToText, tokenToWord } from './textAndWord';
+import { ParseErrorListener } from './parseErrorListener';
 import { ErrorStrategy } from './errorStrategy';
 /**
- * Custom Parser class, subclass needs extends it.
+ * Basic SQL class, every sql needs extends it.
  */
-export default class BasicParser {
+export class BasicSQL {
     constructor() {
-        this._parsedInput = null;
         this._parseErrors = [];
         /** members for cache end */
         this._errorListener = (error) => {
@@ -36,6 +36,7 @@ export default class BasicParser {
         const lexer = this.createLexer(input, errorListener);
         const tokenStream = new CommonTokenStream(lexer);
         const parser = this.createParserFromTokenStream(tokenStream);
+        parser.interpreter.predictionMode = PredictionMode.SLL;
         if (errorListener) {
             parser.removeErrorListeners();
             parser.addErrorListener(new ParseErrorListener(errorListener));
@@ -73,6 +74,7 @@ export default class BasicParser {
          */
         this._tokenStream.fill();
         this._parser = this.createParserFromTokenStream(this._tokenStream);
+        this._parser.interpreter.predictionMode = PredictionMode.SLL;
         this._parser.buildParseTrees = true;
         this._parser.errorHandler = new ErrorStrategy();
         return this._parser;
@@ -87,7 +89,7 @@ export default class BasicParser {
      */
     parseWithCache(input, errorListener) {
         // Avoid parsing the same input repeatedly.
-        if (this._parsedInput === input && !errorListener) {
+        if (this._parsedInput === input && !errorListener && this._parseTree) {
             return this._parseTree;
         }
         this._parseErrors = [];
@@ -134,26 +136,19 @@ export default class BasicParser {
      */
     splitSQLByStatement(input) {
         const errors = this.validate(input);
-        if (errors.length) {
+        if (errors.length || !this._parseTree) {
             return null;
         }
         const splitListener = this.splitListener;
-        // TODO: add splitListener to all sqlParser implements add remove following if
+        // TODO: add splitListener to all sqlParser implements and remove following if
         if (!splitListener)
             return null;
         this.listen(splitListener, this._parseTree);
-        const res = splitListener.statementsContext.map((context) => {
-            const { start, stop } = context;
-            return {
-                startIndex: start.start,
-                endIndex: stop.stop,
-                startLine: start.line,
-                endLine: stop.line,
-                startColumn: start.column + 1,
-                endColumn: stop.column + 1 + stop.text.length,
-                text: this._parsedInput.slice(start.start, stop.stop + 1),
-            };
-        });
+        const res = splitListener.statementsContext
+            .map((context) => {
+            return ctxToText(context, this._parsedInput);
+        })
+            .filter(Boolean);
         return res;
     }
     /**
@@ -165,10 +160,12 @@ export default class BasicParser {
     getSuggestionAtCaretPosition(input, caretPosition) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const splitListener = this.splitListener;
-        // TODO: add splitListener to all sqlParser implements add remove following if
+        // TODO: add splitListener to all sqlParser implements and remove following if
         if (!splitListener)
             return null;
         this.parseWithCache(input);
+        if (!this._parseTree)
+            return null;
         let sqlParserIns = this._parser;
         const allTokens = this.getAllTokens(input);
         let caretTokenIndex = findCaretTokenIndex(caretPosition, allTokens);
@@ -190,8 +187,8 @@ export default class BasicParser {
              * The boundaries of this range must be statements with no syntax errors.
              * This can ensure the stable performance of the C3.
              */
-            let startStatement;
-            let stopStatement;
+            let startStatement = null;
+            let stopStatement = null;
             for (let index = 0; index < statementCount; index++) {
                 const ctx = statementsContext[index];
                 const isCurrentCtxValid = !ctx.exception;
@@ -203,10 +200,13 @@ export default class BasicParser {
                  */
                 const isPrevCtxValid = index === 0 || !((_b = statementsContext[index - 1]) === null || _b === void 0 ? void 0 : _b.exception);
                 const isNextCtxValid = index === statementCount - 1 || !((_c = statementsContext[index + 1]) === null || _c === void 0 ? void 0 : _c.exception);
-                if (ctx.stop.tokenIndex < caretTokenIndex && isPrevCtxValid) {
+                if (ctx.stop && ctx.stop.tokenIndex < caretTokenIndex && isPrevCtxValid) {
                     startStatement = ctx;
                 }
-                if (!stopStatement && ctx.start.tokenIndex > caretTokenIndex && isNextCtxValid) {
+                if (ctx.start &&
+                    !stopStatement &&
+                    ctx.start.tokenIndex > caretTokenIndex &&
+                    isNextCtxValid) {
                     stopStatement = ctx;
                     break;
                 }
@@ -230,6 +230,7 @@ export default class BasicParser {
             const tokenStream = new CommonTokenStream(lexer);
             tokenStream.fill();
             const parser = this.createParserFromTokenStream(tokenStream);
+            parser.interpreter.predictionMode = PredictionMode.SLL;
             parser.removeErrorListeners();
             parser.buildParseTrees = true;
             parser.errorHandler = new ErrorStrategy();
@@ -242,14 +243,7 @@ export default class BasicParser {
         const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {
             const wordRanges = syntaxCtx.wordRanges.map((token) => {
-                return {
-                    text: this._parsedInput.slice(token.start, token.stop + 1),
-                    startIndex: token.start,
-                    endIndex: token.stop,
-                    line: token.line,
-                    startColumn: token.column + 1,
-                    stopColumn: token.column + 1 + token.text.length,
-                };
+                return tokenToWord(token, this._parsedInput);
             });
             return {
                 syntaxContextType: syntaxCtx.syntaxContextType,
@@ -261,4 +255,28 @@ export default class BasicParser {
             keywords: originalSuggestions.keywords,
         };
     }
+    getAllEntities(input, caretPosition) {
+        const allTokens = this.getAllTokens(input);
+        const caretTokenIndex = caretPosition
+            ? findCaretTokenIndex(caretPosition, allTokens)
+            : void 0;
+        const collectListener = this.createEntityCollector(input, caretTokenIndex);
+        // TODO: add entityCollector to all sqlParser implements and remove following if
+        if (!collectListener) {
+            return null;
+        }
+        // const parser = this.createParserWithCache(input);
+        // parser.entityCollecting = true;
+        // if(caretPosition) {
+        //     const allTokens = this.getAllTokens(input);
+        //     const tokenIndex = findCaretTokenIndex(caretPosition, allTokens);
+        //     parser.caretTokenIndex = tokenIndex;
+        // }
+        // const parseTree = parser.program();
+        const parseTree = this.parseWithCache(input);
+        this.listen(collectListener, parseTree);
+        // parser.caretTokenIndex = -1;
+        // parser.entityCollecting = false;
+        return collectListener.getEntities();
+    }
 }

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

@@ -0,0 +1,78 @@
+import { ParserRuleContext } from 'antlr4ng';
+import { EntityContextType } from './types';
+import { WordPosition, TextPosition } from './textAndWord';
+/**
+ * TODO: more stmt type should be supported.
+ */
+export declare enum StmtContextType {
+    /** A self-contained and complete statement */
+    COMMON_STMT = "commonStmt",
+    CREATE_CATALOG_STMT = "createCatalogStmt",
+    CREATE_DATABASE_STMT = "createDatabaseStmt",
+    CREATE_TABLE_STMT = "createTableStmt",
+    CREATE_VIEW_STMT = "createViewStmt",
+    SELECT_STMT = "selectStmt",
+    INSERT_STMT = "insertStmt",
+    CREATE_FUNCTION_STMT = "createFunctionStmt"
+}
+export interface StmtContext {
+    readonly stmtContextType: StmtContextType;
+    readonly position: TextPosition;
+    readonly rootStmt: StmtContext | null;
+    readonly parentStmt: StmtContext | null;
+    readonly isContainCaret?: boolean;
+}
+export declare function toStmtContext(ctx: ParserRuleContext, type: StmtContextType, input: string, rootStmt: StmtContext | null, parentStmt: StmtContext | null, isContainCaret?: boolean): StmtContext | null;
+export interface BaseAliasContext {
+    readonly isAlias: boolean;
+    alias?: string | EntityContext | null;
+    origin?: string | EntityContext | StmtContext | null;
+}
+export interface EntityContext extends BaseAliasContext {
+    readonly entityContextType: EntityContextType;
+    readonly text: string;
+    readonly position: WordPosition;
+    readonly belongStmt: StmtContext;
+    relatedEntities: EntityContext[] | null;
+    columns: EntityContext[] | null;
+}
+export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, alias?: BaseAliasContext): EntityContext | null;
+/**
+ * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
+ * @todo: [may be need] Combine the entities in each clause.
+ */
+export declare abstract class EntityCollector {
+    constructor(input: string, caretTokenIndex?: number);
+    private readonly _input;
+    private readonly _caretTokenIndex;
+    private readonly _entitiesSet;
+    /** Staging statements that have already entered. */
+    private readonly _stmtStack;
+    /** Staging entities inside a single statement or clause. */
+    private readonly _entityStack;
+    /**
+     * Always point to the first non-commonStmt at the bottom of the _stmtStack,
+     * unless there are only commonStmts in the _stmtStack.
+     * */
+    private _rootStmt;
+    visitTerminal(): void;
+    visitErrorNode(): void;
+    enterEveryRule(): void;
+    exitEveryRule(): void;
+    getEntities(): EntityContext[];
+    enterProgram(): void;
+    protected pushStmt(ctx: ParserRuleContext, type: StmtContextType): StmtContext | null;
+    protected popStmt(): StmtContext;
+    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, alias?: BaseAliasContext): EntityContext | null;
+    /**
+     * Combine entities that inside a single statement.
+     * e.g. combine tableName and column if they are inside a same createTableStatement.
+     * Then add combined entities into result.
+     */
+    private combineEntitiesAndAdd;
+    /**
+     * Combined all entities under a rootStmt.
+     */
+    protected combineRootStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
+    protected combineCreateTableOrViewStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
+}

package/dist/parser/common/entityCollector.js

@@ -0,0 +1,191 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { EntityContextType } from './types';
+import { ctxToText, ctxToWord } from './textAndWord';
+import { SimpleStack } from './simpleStack';
+/**
+ * TODO: more stmt type should be supported.
+ */
+export var StmtContextType;
+(function (StmtContextType) {
+    /** A self-contained and complete statement */
+    StmtContextType["COMMON_STMT"] = "commonStmt";
+    StmtContextType["CREATE_CATALOG_STMT"] = "createCatalogStmt";
+    StmtContextType["CREATE_DATABASE_STMT"] = "createDatabaseStmt";
+    StmtContextType["CREATE_TABLE_STMT"] = "createTableStmt";
+    StmtContextType["CREATE_VIEW_STMT"] = "createViewStmt";
+    StmtContextType["SELECT_STMT"] = "selectStmt";
+    StmtContextType["INSERT_STMT"] = "insertStmt";
+    StmtContextType["CREATE_FUNCTION_STMT"] = "createFunctionStmt";
+})(StmtContextType || (StmtContextType = {}));
+export function toStmtContext(ctx, type, input, rootStmt, parentStmt, isContainCaret) {
+    const text = ctxToText(ctx, input);
+    if (!text)
+        return null;
+    const { text: _ } = text, position = __rest(text, ["text"]);
+    return {
+        stmtContextType: type,
+        position,
+        rootStmt: rootStmt !== null && rootStmt !== void 0 ? rootStmt : null,
+        parentStmt: parentStmt !== null && parentStmt !== void 0 ? parentStmt : null,
+        isContainCaret,
+    };
+}
+const baseAlias = {
+    isAlias: false,
+    origin: null,
+    alias: null,
+};
+export function toEntityContext(ctx, type, input, belongStmt, alias) {
+    const word = ctxToWord(ctx, input);
+    if (!word)
+        return null;
+    const { text } = word, position = __rest(word, ["text"]);
+    const finalAlias = Object.assign({}, baseAlias, alias !== null && alias !== void 0 ? alias : {});
+    return Object.assign({ entityContextType: type, text,
+        position,
+        belongStmt, relatedEntities: null, columns: null }, finalAlias);
+}
+/**
+ * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
+ * @todo: [may be need] Combine the entities in each clause.
+ */
+export class EntityCollector {
+    constructor(input, caretTokenIndex) {
+        this._input = input;
+        this._caretTokenIndex = caretTokenIndex !== null && caretTokenIndex !== void 0 ? caretTokenIndex : -1;
+        this._entitiesSet = new Set();
+        this._stmtStack = new SimpleStack();
+        this._entityStack = new SimpleStack();
+        this._rootStmt = null;
+    }
+    visitTerminal() { }
+    visitErrorNode() { }
+    enterEveryRule() { }
+    exitEveryRule() { }
+    getEntities() {
+        return Array.from(this._entitiesSet);
+    }
+    enterProgram() {
+        this._entitiesSet.clear();
+        this._stmtStack.clear();
+        this._entityStack.clear();
+        this._rootStmt = null;
+    }
+    pushStmt(ctx, type) {
+        var _a;
+        let isContainCaret;
+        if (this._caretTokenIndex >= 0) {
+            isContainCaret =
+                !!ctx.start &&
+                    !!ctx.stop &&
+                    ctx.start.tokenIndex <= this._caretTokenIndex &&
+                    ctx.stop.tokenIndex >= this._caretTokenIndex;
+        }
+        const stmtContext = toStmtContext(ctx, type, this._input, this._rootStmt, this._stmtStack.peek(), isContainCaret);
+        if (stmtContext) {
+            if (this._stmtStack.isEmpty() ||
+                ((_a = this._stmtStack.peek()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.COMMON_STMT) {
+                this._rootStmt = stmtContext;
+            }
+            this._stmtStack.push(stmtContext);
+        }
+        return stmtContext;
+    }
+    popStmt() {
+        const stmtContext = this._stmtStack.pop();
+        if (stmtContext && this._rootStmt === stmtContext) {
+            this._rootStmt = this._stmtStack.peek();
+            if (!this._entityStack.isEmpty()) {
+                this.combineEntitiesAndAdd(stmtContext);
+            }
+        }
+        return stmtContext;
+    }
+    pushEntity(ctx, type, alias) {
+        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), alias);
+        if (entityContext) {
+            if (this._stmtStack.isEmpty()) {
+                this._entitiesSet.add(entityContext);
+            }
+            else {
+                // If is inside a statement
+                this._entityStack.push(entityContext);
+            }
+        }
+        return entityContext;
+    }
+    /**
+     * Combine entities that inside a single statement.
+     * e.g. combine tableName and column if they are inside a same createTableStatement.
+     * Then add combined entities into result.
+     */
+    combineEntitiesAndAdd(stmtContext) {
+        const entitiesInsideStmt = [];
+        while (!this._entityStack.isEmpty() &&
+            (this._entityStack.peek().belongStmt === stmtContext ||
+                this._entityStack.peek().belongStmt.rootStmt === stmtContext)) {
+            entitiesInsideStmt.unshift(this._entityStack.pop());
+        }
+        const combinedEntities = this.combineRootStmtEntities(stmtContext, entitiesInsideStmt);
+        while (combinedEntities.length) {
+            const entity = combinedEntities.shift();
+            entity && this._entitiesSet.add(entity);
+        }
+    }
+    /**
+     * Combined all entities under a rootStmt.
+     */
+    combineRootStmtEntities(stmtContext, entitiesInsideStmt) {
+        if (stmtContext.stmtContextType === StmtContextType.CREATE_VIEW_STMT ||
+            stmtContext.stmtContextType === StmtContextType.CREATE_TABLE_STMT) {
+            return this.combineCreateTableOrViewStmtEntities(stmtContext, entitiesInsideStmt);
+        }
+        return entitiesInsideStmt;
+    }
+    combineCreateTableOrViewStmtEntities(stmtContext, entitiesInsideStmt) {
+        const columns = [];
+        const relatedEntities = [];
+        let mainEntity = null;
+        const finalEntities = entitiesInsideStmt.reduce((result, entity) => {
+            if (entity.belongStmt !== stmtContext) {
+                if (entity.entityContextType !== EntityContextType.COLUMN &&
+                    entity.entityContextType !== EntityContextType.COLUMN_CREATE) {
+                    relatedEntities.push(entity);
+                    result.push(entity);
+                }
+                return result;
+            }
+            if (entity.entityContextType === EntityContextType.COLUMN_CREATE) {
+                columns.push(entity);
+            }
+            else if (entity.entityContextType === EntityContextType.TABLE_CREATE ||
+                entity.entityContextType === EntityContextType.VIEW_CREATE) {
+                mainEntity = entity;
+                result.push(entity);
+                return result;
+            }
+            else if (entity.entityContextType !== EntityContextType.COLUMN) {
+                relatedEntities.push(entity);
+                result.push(entity);
+            }
+            return result;
+        }, []);
+        if (mainEntity && columns.length) {
+            mainEntity.columns = columns;
+        }
+        if (mainEntity && relatedEntities.length) {
+            mainEntity.relatedEntities = relatedEntities;
+        }
+        return finalEntities;
+    }
+}

package/dist/parser/common/{utils/findCaretTokenIndex.d.ts → findCaretTokenIndex.d.ts}

@@ -1,9 +1,9 @@
 import { Token } from 'antlr4ng';
-import { CaretPosition } from '../basic-parser-types';
+import { CaretPosition } from './types';
 /**
  * find token index via caret position (cursor position)
  * @param caretPosition
  * @param allTokens all the tokens
  * @returns caretTokenIndex
  */
-export declare function findCaretTokenIndex(caretPosition: CaretPosition, allTokens: Token[]): number;
+export declare function findCaretTokenIndex(caretPosition: CaretPosition, allTokens: Token[]): number | undefined;

package/dist/parser/common/{utils/findCaretTokenIndex.js → findCaretTokenIndex.js}

@@ -5,6 +5,7 @@
  * @returns caretTokenIndex
  */
 export function findCaretTokenIndex(caretPosition, allTokens) {
+    var _a, _b;
     const { lineNumber: caretLine, column: caretCol } = caretPosition;
     let left = 0;
     let right = allTokens.length - 1;
@@ -15,12 +16,12 @@ export function findCaretTokenIndex(caretPosition, allTokens) {
             right = mid - 1;
         }
         else if (token.line < caretLine ||
-            (token.line === caretLine && token.column + token.text.length + 1 < caretCol)) {
+            (token.line === caretLine && token.column + ((_b = (_a = token.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + 1 < caretCol)) {
             left = mid + 1;
         }
         else {
             return allTokens[mid].tokenIndex;
         }
     }
-    return null;
+    return void 0;
 }

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

@@ -16,9 +16,9 @@ export interface ParseError {
 /**
  * The type of error resulting from lexical parsing and parsing.
  */
-export interface SyntaxError<T> {
+export interface SyntaxError {
     readonly recognizer: Recognizer<ATNSimulator>;
-    readonly offendingSymbol: Token;
+    readonly offendingSymbol: Token | null;
     readonly line: number;
     readonly charPositionInLine: number;
     readonly msg: string;
@@ -28,12 +28,12 @@ export interface SyntaxError<T> {
  * ErrorListener will be invoked when it encounters a parsing error.
  * Includes lexical errors and parsing errors.
  */
-export type ErrorListener<T> = (parseError: ParseError, originalError: SyntaxError<T>) => void;
-export default class ParseErrorListener implements ANTLRErrorListener {
+export type ErrorListener = (parseError: ParseError, originalError: SyntaxError) => void;
+export declare class ParseErrorListener implements ANTLRErrorListener {
     private _errorListener;
-    constructor(errorListener: ErrorListener<Token>);
+    constructor(errorListener: ErrorListener);
     reportAmbiguity(): void;
     reportAttemptingFullContext(): void;
     reportContextSensitivity(): void;
-    syntaxError(recognizer: Recognizer<ATNSimulator>, offendingSymbol: any, line: number, charPositionInLine: number, msg: string, e: RecognitionException): void;
+    syntaxError(recognizer: Recognizer<ATNSimulator>, offendingSymbol: Token | null, line: number, charPositionInLine: number, msg: string, e: RecognitionException): void;
 }

package/dist/parser/common/parseErrorListener.js

@@ -1,4 +1,4 @@
-export default class ParseErrorListener {
+export class ParseErrorListener {
     constructor(errorListener) {
         this._errorListener = errorListener;
     }

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

@@ -0,0 +1,10 @@
+export declare class SimpleStack<T> {
+    constructor();
+    private stack;
+    push(item: T): void;
+    pop(): T;
+    peek(): T;
+    clear(): void;
+    size(): number;
+    isEmpty(): boolean;
+}