dt-sql-parser 4.5.1-beta.3 → 4.5.2-beta.0

package/dist/lib/trino/TrinoSqlVisitor.d.ts

@@ -138,6 +138,8 @@ import { RelationDefaultContext } from "./TrinoSqlParser.js";
 import { JoinRelationContext } from "./TrinoSqlParser.js";
 import { JoinTypeContext } from "./TrinoSqlParser.js";
 import { JoinCriteriaContext } from "./TrinoSqlParser.js";
+import { JoinColumnEqualityContext } from "./TrinoSqlParser.js";
+import { JoinColumnReferenceContext } from "./TrinoSqlParser.js";
 import { SampledRelationContext } from "./TrinoSqlParser.js";
 import { SampleTypeContext } from "./TrinoSqlParser.js";
 import { TrimsSpecificationContext } from "./TrinoSqlParser.js";
@@ -356,6 +358,7 @@ import { CatalogNameCreateContext } from "./TrinoSqlParser.js";
 import { FunctionNameContext } from "./TrinoSqlParser.js";
 import { FunctionNameCreateContext } from "./TrinoSqlParser.js";
 import { ColumnRefContext } from "./TrinoSqlParser.js";
+import { EmptyColumnContext } from "./TrinoSqlParser.js";
 import { ColumnNameContext } from "./TrinoSqlParser.js";
 import { ColumnNameCreateContext } from "./TrinoSqlParser.js";
 import { QualifiedNameContext } from "./TrinoSqlParser.js";
@@ -1320,6 +1323,18 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitJoinCriteria?: (ctx: JoinCriteriaContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.joinColumnEquality`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitJoinColumnEquality?: (ctx: JoinColumnEqualityContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.joinColumnReference`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitJoinColumnReference?: (ctx: JoinColumnReferenceContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.sampledRelation`.
      * @param ctx the parse tree
@@ -2769,6 +2784,12 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitColumnRef?: (ctx: ColumnRefContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitEmptyColumn?: (ctx: EmptyColumnContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.columnName`.
      * @param ctx the parse tree

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

@@ -45,6 +45,7 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
      * @param caretTokenIndex tokenIndex of caretPosition
      */
     protected abstract processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
+    protected getCandidateTokenRanges(candidates: CandidatesCollection, candidateStartTokenIndex: number, allTokens: Token[], caretTokenIndex: number): Token[];
     /**
      * Get a new splitListener instance.
      */
@@ -169,6 +170,8 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
     } | null;
     /**
      * Get the minimum statement tree for collecting completion candidates
+     * Each supported grammar exposes one top-level statement per direct program child
+     * Keep the lookup shallow to avoid selecting nested statements or subqueries
      */
     private getSuggestionParseTree;
     /**

package/dist/parser/common/basicSQL.js

@@ -1,5 +1,5 @@
 import { CodeCompletionCore } from 'antlr4-c3';
-import { CharStreams, CommonTokenStream, ParserRuleContext, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
+import { CharStreams, CommonTokenStream, ParserRuleContext, ParseTreeWalker, PredictionMode, Token, } from 'antlr4ng';
 import { ErrorStrategy } from './errorStrategy';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord } from './textAndWord';
@@ -17,6 +17,49 @@ export class BasicSQL {
         };
         this.locale = 'en_US';
     }
+    getCandidateTokenRanges(candidates, candidateStartTokenIndex, allTokens, caretTokenIndex) {
+        var _a;
+        // antlr4-c3 may return both entity and alias candidates; use the nearest candidate's start index as boundary
+        const endTokenIndex = Array.from(candidates.rules.values()).reduce((nearestStartTokenIndex, candidateRule) => {
+            if (candidateRule.startTokenIndex <= candidateStartTokenIndex) {
+                return nearestStartTokenIndex;
+            }
+            return Math.min(nearestStartTokenIndex, candidateRule.startTokenIndex);
+        }, caretTokenIndex + 1);
+        const previousVisibleToken = allTokens
+            .slice(candidateStartTokenIndex, endTokenIndex)
+            .reverse()
+            .find((token) => token.channel === Token.DEFAULT_CHANNEL);
+        const visibleTokenIndexes = allTokens
+            .slice(endTokenIndex, caretTokenIndex + 1)
+            .reduce((indexes, token, offset) => {
+            if (token.channel === Token.DEFAULT_CHANNEL) {
+                indexes.push(endTokenIndex + offset);
+            }
+            return indexes;
+        }, []);
+        const firstVisibleToken = allTokens[visibleTokenIndexes[0]];
+        let rangeEndTokenIndex = endTokenIndex;
+        // candidate boundary may fall inside a multi-level qualified name; extend along the identifier and dot chain
+        if ((previousVisibleToken === null || previousVisibleToken === void 0 ? void 0 : previousVisibleToken.text) === '.' || (firstVisibleToken === null || firstVisibleToken === void 0 ? void 0 : firstVisibleToken.text) === '.') {
+            let visibleTokenOffset = 0;
+            if ((previousVisibleToken === null || previousVisibleToken === void 0 ? void 0 : previousVisibleToken.text) === '.' && firstVisibleToken) {
+                rangeEndTokenIndex = visibleTokenIndexes[visibleTokenOffset] + 1;
+                visibleTokenOffset += 1;
+            }
+            while (((_a = allTokens[visibleTokenIndexes[visibleTokenOffset]]) === null || _a === void 0 ? void 0 : _a.text) === '.') {
+                rangeEndTokenIndex = visibleTokenIndexes[visibleTokenOffset] + 1;
+                visibleTokenOffset += 1;
+                if (visibleTokenOffset < visibleTokenIndexes.length) {
+                    rangeEndTokenIndex = visibleTokenIndexes[visibleTokenOffset] + 1;
+                    visibleTokenOffset += 1;
+                }
+            }
+        }
+        return allTokens
+            .slice(candidateStartTokenIndex, rangeEndTokenIndex)
+            .filter((token) => token.channel === Token.DEFAULT_CHANNEL);
+    }
     /**
      * Create an antlr4 lexer from input.
      * @param input string
@@ -387,6 +430,8 @@ export class BasicSQL {
     }
     /**
      * Get the minimum statement tree for collecting completion candidates
+     * Each supported grammar exposes one top-level statement per direct program child
+     * Keep the lookup shallow to avoid selecting nested statements or subqueries
      */
     getSuggestionParseTree(parseTree, caretTokenIndex) {
         var _a, _b, _c;
@@ -421,6 +466,7 @@ export class BasicSQL {
         const suggestionParseTree = this.getSuggestionParseTree(parseTree, caretTokenIndex);
         if (suggestionParseTree === parseTree)
             return candidates;
+        // Keep the program candidates for outer rule paths and use statement candidates for isolation
         const statementCore = new CodeCompletionCore(parser);
         statementCore.preferredRules = this.preferredRules;
         const statementCandidates = statementCore.collectCandidates(caretTokenIndex, suggestionParseTree);

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

@@ -1,4 +1,4 @@
-import { ParserRuleContext, Token } from 'antlr4ng';
+import { ErrorNode, ParserRuleContext, Token } from 'antlr4ng';
 import { TextPosition, WordPosition, WordRange } from './textAndWord';
 import { EntityContextType } from './types';
 /**
@@ -144,10 +144,21 @@ export declare abstract class EntityCollector {
     private readonly _allTokens;
     private readonly _caretTokenIndex;
     private readonly _entitiesSet;
+    /**
+     * Contexts whose source slice contains a parse error.
+     * Error recovery can stretch a rule context across a whole clause, so `ctxToText`
+     * would return e.g. `JOIN myOwn\nORDER BY 1` where a name is expected.
+     */
+    private readonly _errorContexts;
     /** Staging statements that have already entered. */
     private readonly _stmtStack;
     /** Staging entities inside a single statement or clause. */
     private readonly _entityStack;
+    /**
+     * CTE definitions collected while walking.
+     * Visibility is sequential inside the WITH owner's range, and references bind to the nearest preceding CTE.
+     */
+    private _cteDefinitions;
     /**
      * The scope depth of the statement containing the caret.
      * This is used to determine the accessibility of entities.
@@ -164,7 +175,7 @@ export declare abstract class EntityCollector {
      * */
     private _rootStmt;
     visitTerminal(): void;
-    visitErrorNode(): void;
+    visitErrorNode(node: ErrorNode): void;
     enterEveryRule(): void;
     exitEveryRule(): void;
     getRootStmt(): StmtContext | null;
@@ -215,5 +226,29 @@ export declare abstract class EntityCollector {
     protected combineQueryResultStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
     protected combineFromTableSource(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
     protected combineCreateTableOrViewStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
+    /**
+     * Collect one CTE definition.
+     * `endTokenIndex` is the closing token of this item only (not a following CTE).
+     * Column names, when present, become the outward schema and do not replace the body query result.
+     */
+    protected collectCte(cteCtx: ParserRuleContext, nameCtx: ParserRuleContext | null, bodyCtx: ParserRuleContext | null, endTokenIndex: number, columnNameCtxs?: ParserRuleContext[], columnListCtx?: ParserRuleContext | null): void;
+    private cteScopeEndTokenIndex;
+    private extendUnclosedScope;
+    private finalizeCteDefinitions;
+    /**
+     * CTE outward schema defaults to the body query result itself.
+     * Override when that result's text covers more than the select list.
+     */
+    protected adaptOutwardQueryResult(entity: CommonEntityContext): CommonEntityContext;
+    protected sourceSlice(startIndex: number, endIndex: number): string;
+    private findOutwardQueryResult;
+    private columnTokens;
+    private createColumnListQueryResultFromTokens;
+    private createColumnListQueryResult;
+    private wrapOutwardColumns;
+    private bindCteReferences;
+    private markCteAccessibility;
+    /** Nearest preceding CTE whose scope covers `tokenIndex`. */
+    private resolveCte;
 }
 export {};

package/dist/parser/common/entityCollector.js

@@ -9,7 +9,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-import { isToken, Token } from 'antlr4ng';
+import { isToken, ParserRuleContext, TerminalNode, Token } from 'antlr4ng';
 import { SimpleStack } from './simpleStack';
 import { ctxToText, isWordRange, tokenToWord, } from './textAndWord';
 import { EntityContextType } from './types';
@@ -224,24 +224,63 @@ function isEntityInScope(entity, rangeEntity) {
         rangeStart <= entityStart &&
         rangeStop >= entityStop);
 }
+/**
+ * Parents of a single CTE item. The scope of that CTE is the query that owns this clause.
+ */
+const CTE_CLAUSE_CONTEXT_NAMES = new Set([
+    'WithClauseContext',
+    'WithStatementContext',
+    'CtesContext',
+    'WithContext',
+]);
+function normalizeIdent(text) {
+    let value = text.trim();
+    if ((value.startsWith('`') && value.endsWith('`') && value.length >= 2) ||
+        (value.startsWith('"') && value.endsWith('"') && value.length >= 2) ||
+        (value.startsWith('[') && value.endsWith(']') && value.length >= 2)) {
+        value = value.slice(1, -1);
+    }
+    return value.toLowerCase();
+}
+function sameIdent(left, right) {
+    return normalizeIdent(left) === normalizeIdent(right);
+}
 /**
  * @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, allTokens, caretTokenIndex) {
+        /**
+         * Contexts whose source slice contains a parse error.
+         * Error recovery can stretch a rule context across a whole clause, so `ctxToText`
+         * would return e.g. `JOIN myOwn\nORDER BY 1` where a name is expected.
+         */
+        this._errorContexts = new Set();
         this._input = input;
         this._allTokens = allTokens || [];
         this._caretTokenIndex = caretTokenIndex !== null && caretTokenIndex !== void 0 ? caretTokenIndex : -1;
         this._entitiesSet = new Set();
         this._stmtStack = new SimpleStack();
         this._entityStack = new SimpleStack();
+        this._cteDefinitions = [];
         this._rootStmt = null;
         this._caretStmtScopeDepth = 0;
         this._caretStmt = null;
     }
     visitTerminal() { }
-    visitErrorNode() { }
+    visitErrorNode(node) {
+        /**
+         * Mark every ancestor. An entity pushed on one of them would carry the
+         * error-tainted source slice as its `text`. Entities are always pushed from
+         * `exit<Rule>` callbacks, so this runs before the context is used.
+         */
+        let parent = node.parent;
+        while (parent) {
+            this._errorContexts.add(parent);
+            parent = parent.parent;
+        }
+    }
     enterEveryRule() { }
     exitEveryRule() { }
     getRootStmt() {
@@ -254,11 +293,16 @@ export class EntityCollector {
         this._entitiesSet.clear();
         this._stmtStack.clear();
         this._entityStack.clear();
+        this._cteDefinitions = [];
         this._rootStmt = null;
+        this._errorContexts.clear();
     }
     exitProgram() {
+        this.finalizeCteDefinitions();
+        this.bindCteReferences();
         const entities = Array.from(this._entitiesSet);
         if (this._caretTokenIndex !== -1) {
+            this.markCteAccessibility();
             this.attachAccessibleToEntities(entities);
         }
         this._entityStack.clear();
@@ -376,6 +420,11 @@ export class EntityCollector {
             if (!this._entityStack.isEmpty()) {
                 this.combineEntitiesAndAdd(stmtContext);
             }
+            // Statement-scoped walks never exit program. Finalize once the outermost statement pops.
+            if (this._stmtStack.isEmpty()) {
+                this.finalizeCteDefinitions();
+                this.bindCteReferences();
+            }
             // If the current statement contains the caret and its scope depth equals the caret statement's scope depth
             // then set it as the nearest statement containing the caret
             if (stmtContext.isContainCaret &&
@@ -386,6 +435,9 @@ export class EntityCollector {
         return stmtContext;
     }
     pushEntity(ctx, type, attrInfo, metaInfo) {
+        // A context containing a parse error has no usable `text`.
+        if (this._errorContexts.has(ctx))
+            return null;
         const entityContext = toEntityContext(ctx, type, this._input, this._stmtStack.peek(), attrInfo, metaInfo);
         if (entityContext) {
             if (this._stmtStack.isEmpty()) {
@@ -545,4 +597,253 @@ export class EntityCollector {
         }
         return finalEntities;
     }
+    /**
+     * Collect one CTE definition.
+     * `endTokenIndex` is the closing token of this item only (not a following CTE).
+     * Column names, when present, become the outward schema and do not replace the body query result.
+     */
+    collectCte(cteCtx, nameCtx, bodyCtx, endTokenIndex, columnNameCtxs = [], columnListCtx = null) {
+        if (!nameCtx || endTokenIndex < 0)
+            return;
+        const entity = this.pushEntity(nameCtx, EntityContextType.TABLE, undefined, {
+            declareType: TableDeclareType.EXPRESSION,
+        });
+        if (!entity || !isCommonEntityContext(entity))
+            return;
+        this._cteDefinitions.push({
+            entity,
+            name: entity.text,
+            body: bodyCtx,
+            columnNameCtxs,
+            columnListCtx,
+            endTokenIndex,
+            scopeEndTokenIndex: this.cteScopeEndTokenIndex(cteCtx, endTokenIndex),
+            outward: null,
+        });
+    }
+    cteScopeEndTokenIndex(cteCtx, endTokenIndex) {
+        var _a, _b, _c, _d, _e;
+        let scopeEnd = endTokenIndex;
+        let current = cteCtx.parent;
+        while (current) {
+            if (CTE_CLAUSE_CONTEXT_NAMES.has(current.constructor.name)) {
+                scopeEnd = (_c = (_b = (_a = current.parent) === null || _a === void 0 ? void 0 : _a.stop) === null || _b === void 0 ? void 0 : _b.tokenIndex) !== null && _c !== void 0 ? _c : endTokenIndex;
+                break;
+            }
+            current = current.parent;
+        }
+        if (!current) {
+            scopeEnd = (_e = (_d = this._stmtStack.peek()) === null || _d === void 0 ? void 0 : _d.position.endTokenIndex) !== null && _e !== void 0 ? _e : endTokenIndex;
+        }
+        // An incomplete FROM/JOIN stops the parsed query before the caret.
+        // Keep the CTE visible until a semicolon or a closing paren leaves this query.
+        return this.extendUnclosedScope(scopeEnd);
+    }
+    extendUnclosedScope(scopeEnd) {
+        var _a;
+        let depth = 0;
+        let end = scopeEnd;
+        for (let i = scopeEnd + 1; i < this._allTokens.length; i++) {
+            const token = this._allTokens[i];
+            if (token.channel === Token.HIDDEN_CHANNEL || token.type === Token.EOF)
+                continue;
+            const text = (_a = token.text) !== null && _a !== void 0 ? _a : '';
+            if (text === ';')
+                break;
+            if (text === '(') {
+                depth++;
+            }
+            else if (text === ')') {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+            end = token.tokenIndex;
+        }
+        return end;
+    }
+    finalizeCteDefinitions() {
+        this._cteDefinitions.forEach((cte) => {
+            if (cte.outward) {
+                cte.entity.relatedEntities = [cte.outward];
+                return;
+            }
+            const fromColumnList = cte.columnListCtx
+                ? this.createColumnListQueryResultFromTokens(cte.entity.belongStmt, this.columnTokens(cte.columnListCtx))
+                : cte.columnNameCtxs.length
+                    ? this.createColumnListQueryResult(cte.entity.belongStmt, cte.columnNameCtxs)
+                    : null;
+            const found = fromColumnList !== null && fromColumnList !== void 0 ? fromColumnList : this.findOutwardQueryResult(cte.body);
+            // Column-list results are already a dedicated object. A body query
+            // result is shared with the entity set, so dialects may copy it.
+            const outward = fromColumnList !== null && fromColumnList !== void 0 ? fromColumnList : (found ? this.adaptOutwardQueryResult(found) : null);
+            cte.outward = outward;
+            if (outward) {
+                cte.entity.relatedEntities = [outward];
+            }
+        });
+    }
+    /**
+     * CTE outward schema defaults to the body query result itself.
+     * Override when that result's text covers more than the select list.
+     */
+    adaptOutwardQueryResult(entity) {
+        return entity;
+    }
+    sourceSlice(startIndex, endIndex) {
+        return this._input.slice(startIndex, endIndex + 1);
+    }
+    findOutwardQueryResult(body) {
+        var _a, _b, _c, _d;
+        if (!(body === null || body === void 0 ? void 0 : body.start) || !body.stop)
+            return null;
+        const start = body.start.tokenIndex;
+        const stop = body.stop.tokenIndex;
+        let best = null;
+        for (const entity of this._entitiesSet) {
+            if (entity.entityContextType !== EntityContextType.QUERY_RESULT ||
+                !isCommonEntityContext(entity)) {
+                continue;
+            }
+            const tokenStart = entity.position.startTokenIndex;
+            const tokenStop = entity.position.endTokenIndex;
+            if (tokenStart < start || tokenStop > stop)
+                continue;
+            if (!best) {
+                best = entity;
+                continue;
+            }
+            const bestDepth = (_b = (_a = best.belongStmt) === null || _a === void 0 ? void 0 : _a.scopeDepth) !== null && _b !== void 0 ? _b : 0;
+            const depth = (_d = (_c = entity.belongStmt) === null || _c === void 0 ? void 0 : _c.scopeDepth) !== null && _d !== void 0 ? _d : 0;
+            if (depth < bestDepth ||
+                (depth === bestDepth && tokenStart < best.position.startTokenIndex)) {
+                best = entity;
+            }
+        }
+        return best;
+    }
+    columnTokens(listCtx) {
+        const tokens = [];
+        const skip = new Set(['(', ')', ',', '.', '[', ']']);
+        const visit = (ctx) => {
+            var _a;
+            for (let i = 0; i < ctx.getChildCount(); i++) {
+                const child = ctx.getChild(i);
+                if (child instanceof ParserRuleContext) {
+                    visit(child);
+                    continue;
+                }
+                if (child instanceof TerminalNode) {
+                    const text = (_a = child.symbol.text) !== null && _a !== void 0 ? _a : '';
+                    if (text && !skip.has(text))
+                        tokens.push(child.symbol);
+                }
+            }
+        };
+        visit(listCtx);
+        return tokens;
+    }
+    createColumnListQueryResultFromTokens(belongStmt, tokens) {
+        const columns = [];
+        tokens.forEach((token) => {
+            const word = tokenToWord(token, this._input);
+            if (!word.text.trim())
+                return;
+            columns.push({
+                entityContextType: EntityContextType.COLUMN,
+                text: word.text,
+                position: {
+                    startIndex: word.startIndex,
+                    endIndex: word.endIndex,
+                    line: word.line,
+                    startColumn: word.startColumn,
+                    endColumn: word.endColumn,
+                    startTokenIndex: token.tokenIndex,
+                    endTokenIndex: token.tokenIndex,
+                },
+                belongStmt,
+                declareType: ColumnDeclareType.LITERAL,
+                relatedEntities: null,
+                [AttrName.colType]: null,
+                [AttrName.comment]: null,
+                isAccessible: null,
+            });
+        });
+        return this.wrapOutwardColumns(belongStmt, columns);
+    }
+    createColumnListQueryResult(belongStmt, columnNameCtxs) {
+        const columns = [];
+        columnNameCtxs.forEach((nameCtx) => {
+            const column = toEntityContext(nameCtx, EntityContextType.COLUMN, this._input, belongStmt, undefined, { declareType: ColumnDeclareType.LITERAL });
+            if (column && isColumnEntityContext(column) && column.text.trim()) {
+                columns.push(column);
+            }
+        });
+        return this.wrapOutwardColumns(belongStmt, columns);
+    }
+    wrapOutwardColumns(belongStmt, columns) {
+        if (!columns.length)
+            return null;
+        const first = columns[0].position;
+        const last = columns[columns.length - 1].position;
+        return {
+            entityContextType: EntityContextType.QUERY_RESULT,
+            text: columns.map((column) => column.text).join(', '),
+            position: {
+                startIndex: first.startIndex,
+                endIndex: last.endIndex,
+                line: first.line,
+                startColumn: first.startColumn,
+                endColumn: last.endColumn,
+                startTokenIndex: first.startTokenIndex,
+                endTokenIndex: last.endTokenIndex,
+            },
+            belongStmt,
+            relatedEntities: null,
+            columns,
+            [AttrName.comment]: null,
+            isAccessible: null,
+        };
+    }
+    bindCteReferences() {
+        this._entitiesSet.forEach((entity) => {
+            if (entity.entityContextType !== EntityContextType.TABLE ||
+                !isCommonEntityContext(entity) ||
+                entity.declareType !== TableDeclareType.LITERAL) {
+                return;
+            }
+            const cte = this.resolveCte(entity.text, entity.position.startTokenIndex);
+            if (!cte)
+                return;
+            entity.declareType = TableDeclareType.EXPRESSION;
+            entity.relatedEntities = cte.outward ? [cte.outward] : null;
+        });
+    }
+    markCteAccessibility() {
+        const caretTokenIndex = this.getPrevNonHiddenTokenIndex(this._caretTokenIndex);
+        if (!Number.isFinite(caretTokenIndex)) {
+            this._cteDefinitions.forEach((cte) => {
+                cte.entity.isAccessible = false;
+            });
+            return;
+        }
+        this._cteDefinitions.forEach((cte) => {
+            cte.entity.isAccessible = this.resolveCte(cte.name, caretTokenIndex) === cte;
+        });
+    }
+    /** Nearest preceding CTE whose scope covers `tokenIndex`. */
+    resolveCte(name, tokenIndex) {
+        let winner = null;
+        this._cteDefinitions.forEach((cte) => {
+            if (!sameIdent(cte.name, name))
+                return;
+            if (tokenIndex <= cte.endTokenIndex)
+                return;
+            if (tokenIndex > cte.scopeEndTokenIndex)
+                return;
+            if (!winner || cte.endTokenIndex > winner.endTokenIndex)
+                winner = cte;
+        });
+        return winner;
+    }
 }

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

@@ -1,4 +1,4 @@
-import { AtomExpressionTableContext, AtomFunctionTableContext, CatalogPathContext, CatalogPathCreateContext, ColumnNameCreateContext, CreateCatalogContext, CreateDatabaseContext, CreateFunctionContext, CreateTableContext, CreateViewContext, DatabasePathContext, DatabasePathCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SelectWindowItemColumnNameContext, SqlStatementContext, TableAllColumnsContext, TablePathContext, TablePathCreateContext, ViewPathContext, ViewPathCreateContext } from '../../lib/flink/FlinkSqlParser';
+import { AtomExpressionTableContext, AtomFunctionTableContext, CatalogPathContext, CatalogPathCreateContext, ColumnNameCreateContext, CreateCatalogContext, CreateDatabaseContext, CreateFunctionContext, CreateTableContext, CreateViewContext, DatabasePathContext, DatabasePathCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SelectWindowItemColumnNameContext, SqlStatementContext, TableAllColumnsContext, TablePathContext, TablePathCreateContext, ViewPathContext, ViewPathCreateContext, WithItemContext } from '../../lib/flink/FlinkSqlParser';
 import { FlinkSqlParserListener } from '../../lib/flink/FlinkSqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class FlinkEntityCollector extends EntityCollector implements FlinkSqlParserListener {
@@ -11,6 +11,7 @@ export declare class FlinkEntityCollector extends EntityCollector implements Fli
     exitAtomFunctionTable(ctx: AtomFunctionTableContext): void;
     exitAtomExpressionTable(ctx: AtomExpressionTableContext): void;
     exitTablePathCreate(ctx: TablePathCreateContext): void;
+    exitWithItem(ctx: WithItemContext): void;
     exitViewPath(ctx: ViewPathContext): void;
     exitViewPathCreate(ctx: ViewPathCreateContext): void;
     exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;

package/dist/parser/flink/flinkEntityCollector.js

@@ -58,6 +58,10 @@ export class FlinkEntityCollector extends EntityCollector {
             },
         ]);
     }
+    exitWithItem(ctx) {
+        var _a, _b;
+        this.collectCte(ctx, ctx.withItemName(), ctx.queryStatement(), (_b = (_a = ctx.stop) === null || _a === void 0 ? void 0 : _a.tokenIndex) !== null && _b !== void 0 ? _b : -1, ctx.columnName());
+    }
     exitViewPath(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }

package/dist/parser/flink/index.js

@@ -67,7 +67,7 @@ export class FlinkSQL extends BasicSQL {
         const keywords = [];
         for (let candidate of candidates.rules) {
             const [ruleType, candidateRule] = candidate;
-            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            const tokenRanges = this.getCandidateTokenRanges(candidates, candidateRule.startTokenIndex, allTokens, caretTokenIndex);
             let syntaxContextType = void 0;
             switch (ruleType) {
                 case FlinkSqlParser.RULE_catalogPath: {

package/dist/parser/generic/genericEntityCollector.d.ts

@@ -1,13 +1,18 @@
 import type { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
-import { AlterTableContext, ColumnDefinitionContext, ColumnRefContext, CreateTableContext, DeleteContext, DropTableContext, InsertContext, QuerySpecificationContext, QueryStatementContext, SelectItemContext, SingleStatementContext, TableNameContext, TableNameCreateContext, UpdateContext } from '../../lib/generic/GenericSqlParser';
-import { EntityCollector } from '../common/entityCollector';
+import { AlterTableContext, ColumnDefinitionContext, ColumnRefContext, CreateTableContext, DeleteContext, DropTableContext, InsertContext, NamedQueryContext, QuerySpecificationContext, QueryStatementContext, SelectItemContext, SingleStatementContext, TableNameContext, TableNameCreateContext, UpdateContext } from '../../lib/generic/GenericSqlParser';
+import { CommonEntityContext, EntityCollector } from '../common/entityCollector';
 export declare class GenericEntityCollector extends EntityCollector implements GenericSqlListener {
+    /** Select-list source text for each query result. The result itself keeps the full statement. */
+    private readonly selectListText;
+    enterProgram(): void;
     /** ====== Entity Begin */
     exitTableName(ctx: TableNameContext): void;
+    exitNamedQuery(ctx: NamedQueryContext): void;
     exitTableNameCreate(ctx: TableNameCreateContext): void;
     exitColumnRef(ctx: ColumnRefContext): void;
     exitColumnDefinition(ctx: ColumnDefinitionContext): void;
     exitQuerySpecification(ctx: QuerySpecificationContext): void;
+    protected adaptOutwardQueryResult(entity: CommonEntityContext): CommonEntityContext;
     exitSelectItem(ctx: SelectItemContext): void;
     private isSimpleColumnReference;
     /** ===== Statement begin */