dt-sql-parser 4.0.2 → 4.1.0-beta.1

package/dist/locale/locale.d.ts

@@ -0,0 +1,41 @@
+declare const i18n: {
+    zh_CN: {
+        stmtInComplete: string;
+        noValidPosition: string;
+        expecting: string;
+        unfinishedMultilineComment: string;
+        unfinishedDoubleQuoted: string;
+        unfinishedSingleQuoted: string;
+        unfinishedTickQuoted: string;
+        noValidInput: string;
+        newObj: string;
+        existingObj: string;
+        new: string;
+        existing: string;
+        orKeyword: string;
+        keyword: string;
+        missing: string;
+        at: string;
+        or: string;
+    };
+    en_US: {
+        stmtInComplete: string;
+        noValidPosition: string;
+        expecting: string;
+        unfinishedMultilineComment: string;
+        unfinishedDoubleQuoted: string;
+        unfinishedSingleQuoted: string;
+        unfinishedTickQuoted: string;
+        noValidInput: string;
+        newObj: string;
+        existingObj: string;
+        new: string;
+        existing: string;
+        orKeyword: string;
+        keyword: string;
+        missing: string;
+        at: string;
+        or: string;
+    };
+};
+export { i18n };

package/dist/locale/locale.js

@@ -0,0 +1,43 @@
+const zh_CN = {
+    stmtInComplete: '语句不完整',
+    noValidPosition: '在此位置无效',
+    expecting: '，期望',
+    unfinishedMultilineComment: '未完成的多行注释',
+    unfinishedDoubleQuoted: '未完成的双引号字符串字变量',
+    unfinishedSingleQuoted: '未完成的单引号字符串字变量',
+    unfinishedTickQuoted: '未完成的反引号引用字符串字变量',
+    noValidInput: '没有有效的输入',
+    newObj: '一个新的对象',
+    existingObj: '一个存在的对象',
+    new: '一个新的',
+    existing: '一个存在的',
+    orKeyword: '或者一个关键字',
+    keyword: '一个关键字',
+    missing: '缺少',
+    at: '在',
+    or: '或者',
+};
+const en_US = {
+    stmtInComplete: 'Statement is incomplete',
+    noValidPosition: 'is not valid at this position',
+    expecting: ', expecting ',
+    unfinishedMultilineComment: 'Unfinished multiline comment',
+    unfinishedDoubleQuoted: 'Unfinished double quoted string literal',
+    unfinishedSingleQuoted: 'Unfinished single quoted string literal',
+    unfinishedTickQuoted: 'Unfinished back tick quoted string literal',
+    noValidInput: 'is no valid input at all',
+    newObj: 'a new object',
+    existingObj: 'an existing object',
+    new: 'a new ',
+    existing: 'an existing ',
+    orKeyword: ' or a keyword',
+    keyword: 'a keyword',
+    missing: 'missing ',
+    at: ' at ',
+    or: ' or ',
+};
+const i18n = {
+    zh_CN,
+    en_US,
+};
+export { i18n };

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

@@ -1,8 +1,8 @@
-import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener } from 'antlr4ng';
+import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener, ANTLRErrorListener } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
 import { SQLParserBase } from '../../lib/SQLParserBase';
 import { TextSlice } from './textAndWord';
-import { CaretPosition, Suggestions } from './types';
+import { CaretPosition, LOCALE_TYPE, Suggestions } from './types';
 import { ParseError, ErrorListener } from './parseErrorListener';
 import type { SplitListener } from './splitListener';
 import type { EntityCollector } from './entityCollector';
@@ -40,17 +40,21 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * @param candidates candidate list
      * @param allTokens all tokens from input
      * @param caretTokenIndex tokenIndex of caretPosition
-     * @param tokenIndexOffset offset of the tokenIndex in the candidates compared to the tokenIndex in allTokens
      */
-    protected abstract processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+    protected abstract processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
     /**
      * Get a new splitListener instance.
      */
     protected abstract get splitListener(): SplitListener<ParserRuleContext>;
+    /**
+     * Get a new errorListener instance.
+     */
+    protected abstract createErrorListener(errorListener: ErrorListener): ANTLRErrorListener;
     /**
      * Get a new entityCollector instance.
      */
     protected abstract createEntityCollector(input: string, caretTokenIndex?: number): EntityCollector;
+    locale: LOCALE_TYPE;
     /**
      * Create an antlr4 lexer from input.
      * @param input string
@@ -106,6 +110,7 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * @param input source string
      */
     splitSQLByStatement(input: string): TextSlice[] | null;
+    private splitInputBySeparator;
     /**
      * Get suggestions of syntax and token at caretPosition
      * @param input source string

package/dist/parser/common/basicSQL.js

@@ -2,8 +2,8 @@ import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from
 import { CodeCompletionCore } from 'antlr4-c3';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord } from './textAndWord';
-import { ParseErrorListener } from './parseErrorListener';
 import { ErrorStrategy } from './errorStrategy';
+const SEPARATOR = ';';
 /**
  * Basic SQL class, every sql needs extends it.
  */
@@ -14,6 +14,7 @@ export class BasicSQL {
         this._errorListener = (error) => {
             this._parseErrors.push(error);
         };
+        this.locale = 'en_US';
     }
     /**
      * Create an antlr4 lexer from input.
@@ -24,7 +25,7 @@ export class BasicSQL {
         const lexer = this.createLexerFromCharStream(charStreams);
         if (errorListener) {
             lexer.removeErrorListeners();
-            lexer.addErrorListener(new ParseErrorListener(errorListener));
+            lexer.addErrorListener(this.createErrorListener(errorListener));
         }
         return lexer;
     }
@@ -39,7 +40,7 @@ export class BasicSQL {
         parser.interpreter.predictionMode = PredictionMode.SLL;
         if (errorListener) {
             parser.removeErrorListeners();
-            parser.addErrorListener(new ParseErrorListener(errorListener));
+            parser.addErrorListener(this.createErrorListener(errorListener));
         }
         return parser;
     }
@@ -65,7 +66,7 @@ export class BasicSQL {
         this._charStreams = CharStreams.fromString(input);
         this._lexer = this.createLexerFromCharStream(this._charStreams);
         this._lexer.removeErrorListeners();
-        this._lexer.addErrorListener(new ParseErrorListener(this._errorListener));
+        this._lexer.addErrorListener(this.createErrorListener(this._errorListener));
         this._tokenStream = new CommonTokenStream(this._lexer);
         /**
          * All tokens are generated in advance.
@@ -96,7 +97,7 @@ export class BasicSQL {
         const parser = this.createParserWithCache(input);
         this._parsedInput = input;
         parser.removeErrorListeners();
-        parser.addErrorListener(new ParseErrorListener(this._errorListener));
+        parser.addErrorListener(this.createErrorListener(this._errorListener));
         this._parseTree = parser.program();
         return this._parseTree;
     }
@@ -140,9 +141,6 @@ export class BasicSQL {
             return null;
         }
         const splitListener = this.splitListener;
-        // 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) => {
@@ -151,6 +149,39 @@ export class BasicSQL {
             .filter(Boolean);
         return res;
     }
+    // 通过分隔符进一步切分语句
+    splitInputBySeparator(inputSlice, caretTokenIndex) {
+        const allTokens = this.getAllTokens(inputSlice);
+        /**
+         * set startToken
+         */
+        let startToken = null;
+        for (let tokenIndex = caretTokenIndex; tokenIndex >= 0; tokenIndex--) {
+            const token = allTokens[tokenIndex];
+            if ((token === null || token === void 0 ? void 0 : token.text) === SEPARATOR) {
+                startToken = allTokens[tokenIndex + 1];
+                break;
+            }
+        }
+        if (startToken === null) {
+            startToken = allTokens[0];
+        }
+        /**
+         * set stopToken
+         */
+        let stopToken = null;
+        for (let tokenIndex = caretTokenIndex; tokenIndex < allTokens.length; tokenIndex++) {
+            const token = allTokens[tokenIndex];
+            if ((token === null || token === void 0 ? void 0 : token.text) === SEPARATOR) {
+                stopToken = token;
+                break;
+            }
+        }
+        if (stopToken === null) {
+            stopToken = allTokens[allTokens.length - 1];
+        }
+        return { startToken, stopToken };
+    }
     /**
      * Get suggestions of syntax and token at caretPosition
      * @param input source string
@@ -158,16 +189,13 @@ export class BasicSQL {
      * @returns suggestion
      */
     getSuggestionAtCaretPosition(input, caretPosition) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         const splitListener = this.splitListener;
-        // 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 allTokens = this.getAllTokens(input);
         let caretTokenIndex = findCaretTokenIndex(caretPosition, allTokens);
         let c3Context = this._parseTree;
         let tokenIndexOffset = 0;
@@ -212,8 +240,8 @@ export class BasicSQL {
                 }
             }
             // A boundary consisting of the index of the input.
-            const startIndex = (_e = (_d = startStatement === null || startStatement === void 0 ? void 0 : startStatement.start) === null || _d === void 0 ? void 0 : _d.start) !== null && _e !== void 0 ? _e : 0;
-            const stopIndex = (_g = (_f = stopStatement === null || stopStatement === void 0 ? void 0 : stopStatement.stop) === null || _f === void 0 ? void 0 : _f.stop) !== null && _g !== void 0 ? _g : input.length - 1;
+            let startIndex = (_e = (_d = startStatement === null || startStatement === void 0 ? void 0 : startStatement.start) === null || _d === void 0 ? void 0 : _d.start) !== null && _e !== void 0 ? _e : 0;
+            let stopIndex = (_g = (_f = stopStatement === null || stopStatement === void 0 ? void 0 : stopStatement.stop) === null || _f === void 0 ? void 0 : _f.stop) !== null && _g !== void 0 ? _g : input.length - 1;
             /**
              * Save offset of the tokenIndex in the range of input
              * compared to the tokenIndex in the whole input
@@ -224,7 +252,26 @@ export class BasicSQL {
              * Reparse the input fragment，
              * and c3 will collect candidates in the newly generated parseTree.
              */
-            const inputSlice = input.slice(startIndex, stopIndex);
+            let inputSlice = input.slice(startIndex, stopIndex);
+            /**
+             * Split the inputSlice by separator.
+             */
+            if (inputSlice.includes(SEPARATOR)) {
+                const { startToken, stopToken } = this.splitInputBySeparator(inputSlice, caretTokenIndex);
+                startIndex = (_k = startToken === null || startToken === void 0 ? void 0 : startToken.start) !== null && _k !== void 0 ? _k : 0;
+                stopIndex = (_l = (stopToken === null || stopToken === void 0 ? void 0 : stopToken.stop) + 1) !== null && _l !== void 0 ? _l : input.length;
+                /**
+                 * Save offset of the tokenIndex in the range of input
+                 * compared to the tokenIndex in the whole input
+                 */
+                tokenIndexOffset = (_m = startToken === null || startToken === void 0 ? void 0 : startToken.tokenIndex) !== null && _m !== void 0 ? _m : 0;
+                caretTokenIndex = caretTokenIndex - tokenIndexOffset;
+                /**
+                 * Get the smaller range of inputSlice
+                 */
+                inputSlice = inputSlice.slice(startIndex, stopIndex);
+                allTokens = this.getAllTokens(inputSlice);
+            }
             const lexer = this.createLexer(inputSlice);
             lexer.removeErrorListeners();
             const tokenStream = new CommonTokenStream(lexer);
@@ -240,7 +287,7 @@ export class BasicSQL {
         const core = new CodeCompletionCore(sqlParserIns);
         core.preferredRules = this.preferredRules;
         const candidates = core.collectCandidates(caretTokenIndex, c3Context);
-        const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset);
+        const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {
             const wordRanges = syntaxCtx.wordRanges.map((token) => {
                 return tokenToWord(token, this._parsedInput);
@@ -261,10 +308,6 @@ export class BasicSQL {
             ? 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) {

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

@@ -1,6 +1,6 @@
-import { ParserRuleContext } from 'antlr4ng';
+import { ParserRuleContext, Token } from 'antlr4ng';
+import { TextPosition, WordPosition, WordRange } from './textAndWord';
 import { EntityContextType } from './types';
-import { WordPosition, TextPosition } from './textAndWord';
 /**
  * TODO: more stmt type should be supported.
  */
@@ -13,7 +13,8 @@ export declare enum StmtContextType {
     CREATE_VIEW_STMT = "createViewStmt",
     SELECT_STMT = "selectStmt",
     INSERT_STMT = "insertStmt",
-    CREATE_FUNCTION_STMT = "createFunctionStmt"
+    CREATE_FUNCTION_STMT = "createFunctionStmt",
+    ALTER_TABLE_STMT = "alterTableStmt"
 }
 export interface StmtContext {
     readonly stmtContextType: StmtContextType;
@@ -23,20 +24,65 @@ export interface StmtContext {
     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;
+/**
+ * entity's attribute
+ * @key comment: entity's comment attribute
+ * @key colType: column entity's type attribute
+ * @key alias: entity's alias attribute
+ * */
+export declare enum AttrName {
+    comment = "_comment",
+    colType = "_colType",
+    alias = "_alias"
 }
-export interface EntityContext extends BaseAliasContext {
+/**
+ * ParserRuleContext with custom attributes
+ * */
+type ParserRuleContextWithAttr = ParserRuleContext & {
+    [K in AttrName]?: Token;
+};
+/**
+ * Function's arguments
+ * */
+export interface Argument {
+    argMode?: WordRange;
+    argName?: WordRange;
+    argType: WordRange;
+}
+export interface BaseEntityContext {
     readonly entityContextType: EntityContextType;
     readonly text: string;
     readonly position: WordPosition;
     readonly belongStmt: StmtContext;
-    relatedEntities: EntityContext[] | null;
-    columns: EntityContext[] | null;
+    reference?: string | EntityContext;
+    [AttrName.comment]: WordRange | null;
+    [AttrName.alias]?: WordRange | null;
+}
+export interface CommonEntityContext extends BaseEntityContext {
+    relatedEntities: CommonEntityContext[] | null;
+    columns?: ColumnEntityContext[];
+}
+export interface ColumnEntityContext extends BaseEntityContext {
+    [AttrName.colType]: WordRange | null;
+}
+export interface FuncEntityContext extends BaseEntityContext {
+    relatedEntities: CommonEntityContext[] | null;
+    arguments: Argument[] | null;
+    returns?: Argument;
+}
+export type EntityContext = CommonEntityContext | FuncEntityContext | ColumnEntityContext;
+export declare function isCommonEntityContext(entity: EntityContext): entity is CommonEntityContext;
+export declare function isFuncEntityContext(entity: EntityContext): entity is FuncEntityContext;
+export declare function isColumnEntityContext(entity: EntityContext): entity is ColumnEntityContext;
+/**
+ *  what we need when collect attribute information
+ * */
+interface AttrInfo {
+    attrName: AttrName;
+    endContextList: string[];
 }
-export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, alias?: BaseAliasContext): EntityContext | null;
+export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, attrInfo?: AttrInfo[]): EntityContext | null;
+export declare function findAttribute(ctx: ParserRuleContextWithAttr | null, keyName: AttrName, endContextNameList: string[]): Token | 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.
@@ -59,11 +105,12 @@ export declare abstract class EntityCollector {
     visitErrorNode(): void;
     enterEveryRule(): void;
     exitEveryRule(): void;
+    getRootStmt(): StmtContext | null;
     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;
+    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[]): EntityContext | null;
     /**
      * Combine entities that inside a single statement.
      * e.g. combine tableName and column if they are inside a same createTableStatement.
@@ -76,3 +123,4 @@ export declare abstract class EntityCollector {
     protected combineRootStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
     protected combineCreateTableOrViewStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
 }
+export {};

package/dist/parser/common/entityCollector.js

@@ -9,9 +9,10 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { EntityContextType } from './types';
-import { ctxToText, ctxToWord } from './textAndWord';
+import { isToken } from 'antlr4ng';
 import { SimpleStack } from './simpleStack';
+import { ctxToText, isWordRange, tokenToWord, } from './textAndWord';
+import { EntityContextType } from './types';
 /**
  * TODO: more stmt type should be supported.
  */
@@ -26,6 +27,7 @@ export var StmtContextType;
     StmtContextType["SELECT_STMT"] = "selectStmt";
     StmtContextType["INSERT_STMT"] = "insertStmt";
     StmtContextType["CREATE_FUNCTION_STMT"] = "createFunctionStmt";
+    StmtContextType["ALTER_TABLE_STMT"] = "alterTableStmt";
 })(StmtContextType || (StmtContextType = {}));
 export function toStmtContext(ctx, type, input, rootStmt, parentStmt, isContainCaret) {
     const text = ctxToText(ctx, input);
@@ -40,20 +42,131 @@ export function toStmtContext(ctx, type, input, rootStmt, parentStmt, isContainC
         isContainCaret,
     };
 }
-const baseAlias = {
-    isAlias: false,
-    origin: null,
-    alias: null,
-};
-export function toEntityContext(ctx, type, input, belongStmt, alias) {
-    const word = ctxToWord(ctx, input);
+/**
+ * entity's attribute
+ * @key comment: entity's comment attribute
+ * @key colType: column entity's type attribute
+ * @key alias: entity's alias attribute
+ * */
+export var AttrName;
+(function (AttrName) {
+    AttrName["comment"] = "_comment";
+    AttrName["colType"] = "_colType";
+    AttrName["alias"] = "_alias";
+})(AttrName || (AttrName = {}));
+export function isCommonEntityContext(entity) {
+    if (!entity)
+        return false;
+    return 'relatedEntities' in entity && !('arguments' in entity);
+}
+export function isFuncEntityContext(entity) {
+    if (!entity)
+        return false;
+    return 'arguments' in entity;
+}
+export function isColumnEntityContext(entity) {
+    if (!entity)
+        return false;
+    return AttrName.colType in entity;
+}
+export function toEntityContext(ctx, type, input, belongStmt, attrInfo) {
+    var _a, _b;
+    const word = ctxToText(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,
+    const { text, startLine, endLine } = word, rest = __rest(word, ["text", "startLine", "endLine"]);
+    const position = Object.assign(Object.assign({}, rest), { line: startLine });
+    let entityInfo = {
+        entityContextType: type,
+        text,
         position,
-        belongStmt, relatedEntities: null, columns: null }, finalAlias);
+        belongStmt,
+        [AttrName.comment]: null,
+    };
+    switch (entityInfo.entityContextType) {
+        case EntityContextType.FUNCTION:
+        case EntityContextType.FUNCTION_CREATE: {
+            entityInfo.relatedEntities = null;
+            entityInfo.arguments = null;
+            break;
+        }
+        case EntityContextType.COLUMN:
+        case EntityContextType.COLUMN_CREATE:
+            entityInfo[AttrName.colType] = null;
+            break;
+        default:
+            entityInfo.relatedEntities = null;
+            break;
+    }
+    if (attrInfo) {
+        for (let k = 0; k < attrInfo.length; k++) {
+            const attributeName = (_a = attrInfo[k]) === null || _a === void 0 ? void 0 : _a.attrName;
+            const attrToken = findAttribute(ctx, attributeName, (_b = attrInfo[k]) === null || _b === void 0 ? void 0 : _b.endContextList);
+            if (attrToken) {
+                const attrVal = isToken(attrToken)
+                    ? tokenToWord(attrToken, input)
+                    : ctxToText(attrToken, input);
+                if (attrVal) {
+                    if (isWordRange(attrVal)) {
+                        entityInfo = Object.assign(entityInfo, {
+                            [attributeName]: attrVal,
+                        });
+                    }
+                    else {
+                        const { startIndex, endIndex, startColumn, endColumn, text } = attrVal, rest = __rest(attrVal, ["startIndex", "endIndex", "startColumn", "endColumn", "text"]);
+                        entityInfo = Object.assign(entityInfo, {
+                            [attributeName]: {
+                                startIndex,
+                                endIndex,
+                                startColumn,
+                                endColumn,
+                                text,
+                                line: rest === null || rest === void 0 ? void 0 : rest.startLine,
+                            },
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return entityInfo;
+}
+export function findAttribute(ctx, keyName, endContextNameList) {
+    var _a, _b;
+    const parent = (ctx === null || ctx === void 0 ? void 0 : ctx.parent) || null;
+    let attrVal = null;
+    if (parent === null || parent === void 0 ? void 0 : parent[keyName]) {
+        attrVal = (parent === null || parent === void 0 ? void 0 : parent[keyName]) || null;
+        return attrVal;
+    }
+    else {
+        if (((_a = parent === null || parent === void 0 ? void 0 : parent.constructor) === null || _a === void 0 ? void 0 : _a.name) && !endContextNameList.includes((_b = parent === null || parent === void 0 ? void 0 : parent.constructor) === null || _b === void 0 ? void 0 : _b.name)) {
+            attrVal = findAttribute(parent, keyName, endContextNameList);
+        }
+        if (!attrVal) {
+            if (parent === null || parent === void 0 ? void 0 : parent.children) {
+                attrVal = findAttributeChildren(parent, keyName);
+            }
+        }
+    }
+    return attrVal;
+}
+function findAttributeChildren(ctx, keyName) {
+    const visitChildren = (ctx === null || ctx === void 0 ? void 0 : ctx.children) || [];
+    let attrVal = null;
+    if (visitChildren.length) {
+        for (let i = 0; i < visitChildren.length; i++) {
+            const child = visitChildren[i] || null;
+            if (child === null || child === void 0 ? void 0 : child[keyName]) {
+                attrVal = (child === null || child === void 0 ? void 0 : child[keyName]) || null;
+                return attrVal;
+            }
+            else {
+                attrVal = findAttributeChildren(child, keyName);
+            }
+        }
+    }
+    return attrVal;
 }
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
@@ -72,6 +185,9 @@ export class EntityCollector {
     visitErrorNode() { }
     enterEveryRule() { }
     exitEveryRule() { }
+    getRootStmt() {
+        return this._rootStmt;
+    }
     getEntities() {
         return Array.from(this._entitiesSet);
     }
@@ -111,8 +227,8 @@ export class EntityCollector {
         }
         return stmtContext;
     }
-    pushEntity(ctx, type, alias) {
-        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), alias);
+    pushEntity(ctx, type, attrInfo) {
+        const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), attrInfo);
         if (entityContext) {
             if (this._stmtStack.isEmpty()) {
                 this._entitiesSet.add(entityContext);
@@ -181,10 +297,18 @@ export class EntityCollector {
             return result;
         }, []);
         if (mainEntity && columns.length) {
-            mainEntity.columns = columns;
+            if (isCommonEntityContext(mainEntity)) {
+                mainEntity = Object.assign(mainEntity, {
+                    columns,
+                });
+            }
         }
         if (mainEntity && relatedEntities.length) {
-            mainEntity.relatedEntities = relatedEntities;
+            if (isCommonEntityContext(mainEntity) || isFuncEntityContext(mainEntity)) {
+                mainEntity = Object.assign(mainEntity, {
+                    relatedEntities,
+                });
+            }
         }
         return finalEntities;
     }

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

@@ -1,4 +1,5 @@
-import { Token, Recognizer, ANTLRErrorListener, RecognitionException, ATNSimulator } from 'antlr4ng';
+import { Token, Recognizer, ANTLRErrorListener, RecognitionException, ATNSimulator, Parser } from 'antlr4ng';
+import { LOCALE_TYPE } from './types';
 /**
  * Converted from {@link SyntaxError}.
  */
@@ -29,11 +30,13 @@ export interface SyntaxError {
  * Includes lexical errors and parsing errors.
  */
 export type ErrorListener = (parseError: ParseError, originalError: SyntaxError) => void;
-export declare class ParseErrorListener implements ANTLRErrorListener {
+export declare abstract class ParseErrorListener implements ANTLRErrorListener {
     private _errorListener;
-    constructor(errorListener: ErrorListener);
+    private locale;
+    constructor(errorListener: ErrorListener, locale?: LOCALE_TYPE);
     reportAmbiguity(): void;
     reportAttemptingFullContext(): void;
     reportContextSensitivity(): void;
+    protected abstract getExpectedText(parser: Parser, token: Token): string;
     syntaxError(recognizer: Recognizer<ATNSimulator>, offendingSymbol: Token | null, line: number, charPositionInLine: number, msg: string, e: RecognitionException): void;
 }