dt-sql-parser 4.5.1 → 4.5.2-beta.1

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.identifier(), 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/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 */

package/dist/parser/generic/genericEntityCollector.js

@@ -1,13 +1,32 @@
-import { ColumnDefinitionContext, CreateTableStatementContext, SelectItemContext, } from '../../lib/generic/GenericSqlParser';
-import { AttrName, ColumnDeclareType, EntityCollector, StmtContextType, TableDeclareType, } from '../common/entityCollector';
+import { ColumnDefinitionContext, AliasedRelationContext, CreateTableStatementContext, } from '../../lib/generic/GenericSqlParser';
+import { AttrName, ColumnDeclareType, EntityCollector, isColumnEntityContext, isCommonEntityContext, StmtContextType, TableDeclareType, } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
+import { tokenToWord } from '../common/textAndWord';
 export class GenericEntityCollector extends EntityCollector {
+    constructor() {
+        super(...arguments);
+        /** Select-list source text for each query result. The result itself keeps the full statement. */
+        this.selectListText = new Map();
+    }
+    enterProgram() {
+        this.selectListText.clear();
+        super.enterProgram();
+    }
     /** ====== Entity Begin */
     exitTableName(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE, [], {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [AliasedRelationContext.name],
+            },
+        ], {
             declareType: TableDeclareType.LITERAL,
         });
     }
+    exitNamedQuery(ctx) {
+        var _a, _b;
+        this.collectCte(ctx, ctx.identifier(), ctx.queryStatement(), (_b = (_a = ctx.stop) === null || _a === void 0 ? void 0 : _a.tokenIndex) !== null && _b !== void 0 ? _b : -1, [], ctx.cteColumnList());
+    }
     exitTableNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
             {
@@ -20,21 +39,51 @@ export class GenericEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.COLUMN);
     }
     exitColumnDefinition(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
-            {
-                attrName: AttrName.colType,
-                endContextList: [ColumnDefinitionContext.name],
-            },
+        var _a, _b;
+        // The name is only `columnRef`. Pushing the whole definition made the
+        // completion label `age int` and inserted the type into the SQL.
+        const entity = this.pushEntity(ctx.columnRef(), EntityContextType.COLUMN_CREATE, [
             {
                 attrName: AttrName.comment,
                 endContextList: [ColumnDefinitionContext.name],
             },
         ]);
+        const dataType = ctx.dataType();
+        if (entity && isColumnEntityContext(entity) && (dataType === null || dataType === void 0 ? void 0 : dataType.start) && dataType.stop) {
+            const startIndex = dataType.start.start;
+            const endIndex = dataType.stop.stop;
+            const typeText = this.sourceSlice(startIndex, endIndex);
+            const startColumn = dataType.start.column + 1;
+            entity[AttrName.colType] = {
+                text: typeText,
+                line: dataType.start.line,
+                startIndex,
+                endIndex,
+                startColumn,
+                endColumn: dataType.stop.line === dataType.start.line
+                    ? startColumn + typeText.length
+                    : dataType.stop.column + 1 + ((_b = (_a = dataType.stop.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0),
+            };
+        }
     }
     exitQuerySpecification(ctx) {
-        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+        var _a, _b;
+        const entity = this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+        const items = ctx.selectItem();
+        const first = (_a = items[0]) === null || _a === void 0 ? void 0 : _a.start;
+        const last = (_b = items[items.length - 1]) === null || _b === void 0 ? void 0 : _b.stop;
+        if (entity && isCommonEntityContext(entity) && first && last) {
+            this.selectListText.set(entity, this.sourceSlice(first.start, last.stop));
+        }
+    }
+    adaptOutwardQueryResult(entity) {
+        const text = this.selectListText.get(entity);
+        if (text == null)
+            return entity;
+        return Object.assign(Object.assign({}, entity), { text });
     }
     exitSelectItem(ctx) {
+        var _a;
         if (ctx.ASTERISK()) {
             this.pushEntity(ctx, EntityContextType.COLUMN, [], {
                 declareType: ColumnDeclareType.ALL,
@@ -42,16 +91,17 @@ export class GenericEntityCollector extends EntityCollector {
         }
         else {
             const isSimpleColumn = this.isSimpleColumnReference(ctx);
-            this.pushEntity(ctx, EntityContextType.COLUMN, [
-                {
-                    attrName: AttrName.alias,
-                    endContextList: [SelectItemContext.name],
-                },
-            ], {
+            const entity = this.pushEntity(ctx, EntityContextType.COLUMN, [], {
                 declareType: isSimpleColumn
                     ? ColumnDeclareType.LITERAL
                     : ColumnDeclareType.EXPRESSION,
             });
+            // The alias sits on this select item. Searching parents would pick a
+            // later item's alias and label every column with that name.
+            const aliasToken = (_a = ctx._alias) === null || _a === void 0 ? void 0 : _a.start;
+            if (entity && aliasToken) {
+                entity[AttrName.alias] = tokenToWord(aliasToken, '');
+            }
         }
     }
     isSimpleColumnReference(ctx) {

package/dist/parser/generic/index.js

@@ -19,6 +19,7 @@ export class GenericSQL extends BasicSQL {
             GenericSqlParser.RULE_tableName,
             GenericSqlParser.RULE_tableNameCreate,
             GenericSqlParser.RULE_columnRef,
+            GenericSqlParser.RULE_qualifiedName,
             ...this.excludeKeywordRules,
         ]);
         this._diagnostics = (options === null || options === void 0 ? void 0 : options.diagnostics) !== false;
@@ -68,6 +69,17 @@ export class GenericSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
+                case GenericSqlParser.RULE_qualifiedName: {
+                    // Expressions use qualifiedName for columns. Table names use the same
+                    // rule through tableName, and those stay TABLE suggestions.
+                    const rules = candidateRule.ruleList;
+                    if (!rules.includes(GenericSqlParser.RULE_tableName) &&
+                        !rules.includes(GenericSqlParser.RULE_tableNameCreate) &&
+                        rules.includes(GenericSqlParser.RULE_expression)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                    break;
+                }
                 default:
                     break;
             }

package/dist/parser/hive/hiveEntityCollector.d.ts

@@ -1,5 +1,5 @@
 import { HiveSqlParserListener } from '../../lib';
-import { AtomPartitionedTableFunctionContext, AtomValuesClauseContext, ColumnNameCreateContext, CreateDatabaseStatementContext, CreateFunctionStatementContext, CreateMaterializedViewStatementContext, CreateTableStatementContext, CreateViewStatementContext, DbSchemaNameContext, DbSchemaNameCreateContext, FromInsertStmtContext, FromSelectStmtContext, FunctionNameCreateContext, InsertStmtContext, QueryStatementExpressionContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SelectStatementContext, StatementContext, TableAllColumnsContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/hive/HiveSqlParser';
+import { AtomPartitionedTableFunctionContext, AtomValuesClauseContext, ColumnNameCreateContext, CreateDatabaseStatementContext, CreateFunctionStatementContext, CreateMaterializedViewStatementContext, CreateTableStatementContext, CreateViewStatementContext, CteStatementContext, DbSchemaNameContext, DbSchemaNameCreateContext, FromInsertStmtContext, FromSelectStmtContext, FunctionNameCreateContext, InsertStmtContext, QueryStatementExpressionContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SelectStatementContext, StatementContext, TableAllColumnsContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/hive/HiveSqlParser';
 import { EntityCollector } from '../common/entityCollector';
 export declare class HiveEntityCollector extends EntityCollector implements HiveSqlParserListener {
     /** ====== Entity Begin */
@@ -19,6 +19,7 @@ export declare class HiveEntityCollector extends EntityCollector implements Hive
     exitTableAllColumns(ctx: TableAllColumnsContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
     exitSelectList(ctx: SelectListContext): void;
+    exitCteStatement(ctx: CteStatementContext): void;
     exitViewName(ctx: ViewNameContext): void;
     exitDbSchemaNameCreate(ctx: DbSchemaNameCreateContext): void;
     exitDbSchemaName(ctx: DbSchemaNameContext): void;

package/dist/parser/hive/hiveEntityCollector.js

@@ -116,6 +116,11 @@ export class HiveEntityCollector extends EntityCollector {
     exitSelectList(ctx) {
         this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
     }
+    exitCteStatement(ctx) {
+        var _a, _b, _c, _d;
+        const columns = (_b = (_a = ctx.columnNameList()) === null || _a === void 0 ? void 0 : _a.columnName()) !== null && _b !== void 0 ? _b : [];
+        this.collectCte(ctx, ctx.id_(), ctx.queryStatementExpression(), (_d = (_c = ctx.stop) === null || _c === void 0 ? void 0 : _c.tokenIndex) !== null && _d !== void 0 ? _d : -1, columns);
+    }
     exitViewName(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }

package/dist/parser/impala/impalaEntityCollector.d.ts

@@ -1,5 +1,5 @@
 import { ImpalaSqlParserListener } from '../../lib';
-import { AtomSubQueryTableSourceContext, ColumnNamePathCreateContext, CreateAggregateFunctionContext, CreateFunctionContext, CreateKuduTableAsSelectContext, CreateSchemaContext, CreateTableLikeContext, CreateTableSelectContext, CreateViewContext, DatabaseNameCreateContext, DatabaseNamePathContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SingleStatementContext, TableAllColumnsContext, TableNameCreateContext, TableNamePathContext, UnnestContext, ViewNameCreateContext, ViewNamePathContext } from '../../lib/impala/ImpalaSqlParser';
+import { AtomSubQueryTableSourceContext, ColumnNamePathCreateContext, CreateAggregateFunctionContext, CreateFunctionContext, CreateKuduTableAsSelectContext, CreateSchemaContext, CreateTableLikeContext, CreateTableSelectContext, CreateViewContext, DatabaseNameCreateContext, DatabaseNamePathContext, FunctionNameCreateContext, InsertStatementContext, NamedQueryContext, QueryStatementContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SingleStatementContext, TableAllColumnsContext, TableNameCreateContext, TableNamePathContext, UnnestContext, ViewNameCreateContext, ViewNamePathContext } from '../../lib/impala/ImpalaSqlParser';
 import { EntityCollector } from '../common/entityCollector';
 export declare class ImpalaEntityCollector extends EntityCollector implements ImpalaSqlParserListener {
     /** ===== Entity begin */
@@ -9,6 +9,7 @@ export declare class ImpalaEntityCollector extends EntityCollector implements Im
     exitUnnest(ctx: UnnestContext): void;
     exitColumnNamePathCreate(ctx: ColumnNamePathCreateContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
+    exitNamedQuery(ctx: NamedQueryContext): void;
     exitViewNamePath(ctx: ViewNamePathContext): void;
     exitDatabaseNamePath(ctx: DatabaseNamePathContext): void;
     exitDatabaseNameCreate(ctx: DatabaseNameCreateContext): void;

package/dist/parser/impala/impalaEntityCollector.js

@@ -72,6 +72,10 @@ export class ImpalaEntityCollector extends EntityCollector {
             },
         ]);
     }
+    exitNamedQuery(ctx) {
+        var _a, _b;
+        this.collectCte(ctx, ctx.identifier(), ctx.subQueryRelation(), (_b = (_a = ctx.stop) === null || _a === void 0 ? void 0 : _a.tokenIndex) !== null && _b !== void 0 ? _b : -1, [], ctx.columnAliases());
+    }
     exitViewNamePath(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }

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

@@ -1,4 +1,4 @@
-import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectElementsContext, SelectExpressionElementContext, SelectLiteralColumnNameContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, TableAllColumnsContext, AtomSubQueryTableSourceContext, PureAllColumnsContext, SelectElement_dot_emptyContext, ColumnNamePath_dot_emptyContext } from '../../lib/mysql/MySqlParser';
+import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectElementsContext, SelectExpressionElementContext, SelectLiteralColumnNameContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, TableAllColumnsContext, AtomSubQueryTableSourceContext, CommonTableExpressionsContext, PureAllColumnsContext, SelectElement_dot_emptyContext, ColumnNamePath_dot_emptyContext } from '../../lib/mysql/MySqlParser';
 import type { MySqlParserListener } from '../../lib/mysql/MySqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class MySqlEntityCollector extends EntityCollector implements MySqlParserListener {
@@ -7,6 +7,7 @@ export declare class MySqlEntityCollector extends EntityCollector implements MyS
     exitDatabaseNameCreate(ctx: DatabaseNameCreateContext): void;
     /** Table Entity Rules */
     exitTableName(ctx: TableNameContext): void;
+    exitCommonTableExpressions(ctx: CommonTableExpressionsContext): void;
     /** SubQuery Table Entity Rules */
     exitAtomSubQueryTableSource(ctx: AtomSubQueryTableSourceContext): void;
     exitTableNameCreate(ctx: TableNameCreateContext): void;

package/dist/parser/mysql/mysqlEntityCollector.js

@@ -1,3 +1,4 @@
+import { TerminalNode } from 'antlr4ng';
 import { ColumnCreateTableContext, CreateDefinitionContext, CreateFunctionContext, TableSourceItemContext, AtomTableItemContext, SubqueryTableItemContext, SelectElement_labelContext, SelectElement_exprContext, } from '../../lib/mysql/MySqlParser';
 import { AttrName, ColumnDeclareType, EntityCollector, StmtContextType, TableDeclareType, } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
@@ -20,6 +21,24 @@ export class MySqlEntityCollector extends EntityCollector {
             declareType: TableDeclareType.LITERAL,
         });
     }
+    exitCommonTableExpressions(ctx) {
+        var _a, _b, _c;
+        const names = ctx.uid();
+        if (!(names === null || names === void 0 ? void 0 : names.length))
+            return;
+        const bodyEnd = (_c = (_b = (_a = ctx.dmlStatement()) === null || _a === void 0 ? void 0 : _a.stop) === null || _b === void 0 ? void 0 : _b.tokenIndex) !== null && _c !== void 0 ? _c : -1;
+        let endTokenIndex = bodyEnd;
+        for (let i = 0; i < ctx.getChildCount(); i++) {
+            const child = ctx.getChild(i);
+            if (!(child instanceof TerminalNode))
+                continue;
+            if (child.symbol.text === ')' && child.symbol.tokenIndex > bodyEnd) {
+                endTokenIndex = child.symbol.tokenIndex;
+                break;
+            }
+        }
+        this.collectCte(ctx, names[0], ctx.dmlStatement(), endTokenIndex, names.slice(1));
+    }
     /** SubQuery Table Entity Rules */
     exitAtomSubQueryTableSource(ctx) {
         this.pushEntity(ctx, EntityContextType.TABLE, [