dt-sql-parser 4.5.0-beta.3 → 4.5.0

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

@@ -223,6 +223,7 @@ import { NullLiteralContext } from "./TrinoSqlParser.js";
 import { RowConstructorContext } from "./TrinoSqlParser.js";
 import { SubscriptContext } from "./TrinoSqlParser.js";
 import { JsonExistsContext } from "./TrinoSqlParser.js";
+import { CoalesceContext } from "./TrinoSqlParser.js";
 import { CurrentPathContext } from "./TrinoSqlParser.js";
 import { SubqueryExpressionContext } from "./TrinoSqlParser.js";
 import { BinaryLiteralContext } from "./TrinoSqlParser.js";
@@ -1888,6 +1889,13 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitJsonExists?: (ctx: JsonExistsContext) => Result;
+    /**
+     * Visit a parse tree produced by the `coalesce`
+     * labeled alternative in `TrinoSqlParser.primaryExpression`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitCoalesce?: (ctx: CoalesceContext) => Result;
     /**
      * Visit a parse tree produced by the `currentPath`
      * labeled alternative in `TrinoSqlParser.primaryExpression`.

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

@@ -1,13 +1,13 @@
-import { Lexer, Token, CommonTokenStream, CharStream, ParserRuleContext, ParseTreeListener, ANTLRErrorListener, Parser } from 'antlr4ng';
 import { CandidatesCollection } from 'antlr4-c3';
+import { ANTLRErrorListener, CharStream, CommonTokenStream, Lexer, Parser, ParserRuleContext, ParseTreeListener, Token } from 'antlr4ng';
 import { SQLParserBase } from '../../lib/SQLParserBase';
-import { TextSlice } from './textAndWord';
-import { CaretPosition, LOCALE_TYPE, SemanticCollectOptions, Suggestions } from './types';
-import { ParseError, ErrorListener } from './parseErrorListener';
-import type { SplitListener } from './splitListener';
 import type { EntityCollector } from './entityCollector';
 import { EntityContext } from './entityCollector';
+import { ErrorListener, ParseError } from './parseErrorListener';
 import SemanticContextCollector from './semanticContextCollector';
+import type { SplitListener } from './splitListener';
+import { TextSlice } from './textAndWord';
+import { CaretPosition, LOCALE_TYPE, SemanticCollectOptions, Suggestions } from './types';
 export declare const SQL_SPLIT_SYMBOL_TEXT = ";";
 /**
  * Basic SQL class, every sql needs extends it.

package/dist/parser/common/basicSQL.js

@@ -1,8 +1,8 @@
-import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
 import { CodeCompletionCore } from 'antlr4-c3';
+import { CharStreams, CommonTokenStream, ParseTreeWalker, PredictionMode, } from 'antlr4ng';
+import { ErrorStrategy } from './errorStrategy';
 import { findCaretTokenIndex } from './findCaretTokenIndex';
 import { ctxToText, tokenToWord } from './textAndWord';
-import { ErrorStrategy } from './errorStrategy';
 export const SQL_SPLIT_SYMBOL_TEXT = ';';
 /**
  * Basic SQL class, every sql needs extends it.
@@ -431,7 +431,7 @@ export class BasicSQL {
         const core = new CodeCompletionCore(sqlParserIns);
         core.preferredRules = this.preferredRules;
         // core.showRuleStack = true;
-        //  core.showResult = true;
+        // core.showResult = true;
         const candidates = core.collectCandidates(caretTokenIndex, parseTree);
         const originalSuggestions = this.processCandidates(candidates, allTokens, caretTokenIndex);
         const syntaxSuggestions = originalSuggestions.syntax.map((syntaxCtx) => {

package/dist/parser/common/entityCollector.js

@@ -436,8 +436,20 @@ export class EntityCollector {
         }
         else {
             // Do not collect column and queryResult entities if they are not inside a select statement
-            return entitiesInsideStmt.filter((entity) => entity.entityContextType !== EntityContextType.COLUMN &&
-                entity.entityContextType !== EntityContextType.QUERY_RESULT);
+            // Exception: empty column entities (text === '') should be kept
+            return entitiesInsideStmt.filter((entity) => {
+                // Keep non-COLUMN and non-QUERY_RESULT entities
+                if (entity.entityContextType !== EntityContextType.COLUMN &&
+                    entity.entityContextType !== EntityContextType.QUERY_RESULT) {
+                    return true;
+                }
+                // Also keep empty QUERY_RESULT entities (text === '')
+                if (entity.entityContextType === EntityContextType.QUERY_RESULT &&
+                    entity.text === '') {
+                    return true;
+                }
+                return false;
+            });
         }
     }
     combineQueryResultStmtEntities(stmtContext, entitiesInsideStmt) {

package/dist/parser/flink/index.js

@@ -36,6 +36,7 @@ export class FlinkSQL extends BasicSQL {
             FlinkSqlParser.RULE_functionNameCreate, // functionName that will be created
             FlinkSqlParser.RULE_columnName,
             FlinkSqlParser.RULE_columnNamePath,
+            FlinkSqlParser.RULE_columnNamePathAllowEmpty,
             FlinkSqlParser.RULE_columnNameCreate,
             FlinkSqlParser.RULE_tablePropertyKey,
             FlinkSqlParser.RULE_tablePropertyValue,
@@ -116,13 +117,15 @@ export class FlinkSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case FlinkSqlParser.RULE_columnNamePath: {
+                case FlinkSqlParser.RULE_columnNamePath:
+                case FlinkSqlParser.RULE_columnNamePathAllowEmpty: {
                     if (candidateRule.ruleList.includes(FlinkSqlParser.RULE_selectClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_whereClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_groupByClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_limitClause) ||
                         candidateRule.ruleList.includes(FlinkSqlParser.RULE_whenClause) ||
-                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause)) {
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_havingClause) ||
+                        candidateRule.ruleList.includes(FlinkSqlParser.RULE_joinCondition)) {
                         syntaxContextType = EntityContextType.COLUMN;
                     }
                     break;

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

@@ -0,0 +1,30 @@
+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';
+export declare class GenericEntityCollector extends EntityCollector implements GenericSqlListener {
+    /** ====== Entity Begin */
+    exitTableName(ctx: TableNameContext): void;
+    exitTableNameCreate(ctx: TableNameCreateContext): void;
+    exitColumnRef(ctx: ColumnRefContext): void;
+    exitColumnDefinition(ctx: ColumnDefinitionContext): void;
+    exitQuerySpecification(ctx: QuerySpecificationContext): void;
+    exitSelectItem(ctx: SelectItemContext): void;
+    private isSimpleColumnReference;
+    /** ===== Statement begin */
+    enterSingleStatement(ctx: SingleStatementContext): void;
+    exitSingleStatement(ctx: SingleStatementContext): void;
+    enterCreateTable(ctx: CreateTableContext): void;
+    exitCreateTable(ctx: CreateTableContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterInsert(ctx: InsertContext): void;
+    exitInsert(ctx: InsertContext): void;
+    enterUpdate(ctx: UpdateContext): void;
+    exitUpdate(ctx: UpdateContext): void;
+    enterDelete(ctx: DeleteContext): void;
+    exitDelete(ctx: DeleteContext): void;
+    enterAlterTable(ctx: AlterTableContext): void;
+    exitAlterTable(ctx: AlterTableContext): void;
+    enterDropTable(ctx: DropTableContext): void;
+    exitDropTable(ctx: DropTableContext): void;
+}

package/dist/parser/generic/genericEntityCollector.js

@@ -0,0 +1,116 @@
+import { ColumnDefinitionContext, CreateTableStatementContext, SelectItemContext, } from '../../lib/generic/GenericSqlParser';
+import { AttrName, ColumnDeclareType, EntityCollector, StmtContextType, TableDeclareType, } from '../common/entityCollector';
+import { EntityContextType } from '../common/types';
+export class GenericEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableStatementContext.name],
+            },
+        ]);
+    }
+    exitColumnRef(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN);
+    }
+    exitColumnDefinition(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.colType,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+            {
+                attrName: AttrName.comment,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+        ]);
+    }
+    exitQuerySpecification(ctx) {
+        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+    }
+    exitSelectItem(ctx) {
+        if (ctx.ASTERISK()) {
+            this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+                declareType: ColumnDeclareType.ALL,
+            });
+        }
+        else {
+            const isSimpleColumn = this.isSimpleColumnReference(ctx);
+            this.pushEntity(ctx, EntityContextType.COLUMN, [
+                {
+                    attrName: AttrName.alias,
+                    endContextList: [SelectItemContext.name],
+                },
+            ], {
+                declareType: isSimpleColumn
+                    ? ColumnDeclareType.LITERAL
+                    : ColumnDeclareType.EXPRESSION,
+            });
+        }
+    }
+    isSimpleColumnReference(ctx) {
+        const text = ctx.getText();
+        // Simple column reference: no parentheses, no operators, no spaces
+        return (!text.includes('(') &&
+            !text.includes(' ') &&
+            !text.includes('+') &&
+            !text.includes('-') &&
+            !text.includes('*') &&
+            !text.includes('/'));
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsert(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsert(ctx) {
+        this.popStmt();
+    }
+    enterUpdate(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitUpdate(ctx) {
+        this.popStmt();
+    }
+    enterDelete(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitDelete(ctx) {
+        this.popStmt();
+    }
+    enterAlterTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.ALTER_TABLE_STMT);
+    }
+    exitAlterTable(ctx) {
+        this.popStmt();
+    }
+    enterDropTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitDropTable(ctx) {
+        this.popStmt();
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Parser, Token } from 'antlr4ng';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export declare class GenericErrorListener extends ParseErrorListener {
+    private objectNames;
+    getExpectedText(parser: Parser, token: Token): string;
+}

package/dist/parser/generic/genericErrorListener.js

@@ -0,0 +1,56 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export class GenericErrorListener extends ParseErrorListener {
+    constructor() {
+        super(...arguments);
+        this.objectNames = new Map([
+            [GenericSqlParser.RULE_tableName, 'table'],
+            [GenericSqlParser.RULE_tableNameCreate, 'table'],
+            [GenericSqlParser.RULE_columnRef, 'column'],
+        ]);
+    }
+    getExpectedText(parser, token) {
+        var _a;
+        let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
+        while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
+            currentContext = currentContext.parent;
+        }
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
+        if (candidates.rules.size) {
+            const result = [];
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case GenericSqlParser.RULE_tableName:
+                    case GenericSqlParser.RULE_columnRef: {
+                        if (name && !result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
+                        break;
+                    }
+                    case GenericSqlParser.RULE_tableNameCreate: {
+                        if (name && !result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
+import { StatementsContext } from '../../lib/generic/GenericSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class GenericSemanticContextCollector extends SemanticContextCollector implements GenericSqlListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterStatements(ctx: StatementsContext): void;
+}
+export { GenericSemanticContextCollector };

package/dist/parser/generic/genericSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class GenericSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return GenericSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return GenericSqlParser.RULE_statements;
+    }
+    enterStatements(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { GenericSemanticContextCollector };

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

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

package/dist/parser/generic/genericSplitListener.js

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

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

@@ -0,0 +1,33 @@
+import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { GenericSqlLexer } from '../../lib/generic/GenericSqlLexer';
+import { GenericSqlParser, ProgramContext } from '../../lib/generic/GenericSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
+import { ErrorListener, ParseError } from '../common/parseErrorListener';
+import { GenericEntityCollector } from './genericEntityCollector';
+import { GenericErrorListener } from './genericErrorListener';
+import { GenericSplitListener } from './genericSplitListener';
+import { GenericSemanticContextCollector } from './genericSemanticContextCollector';
+export { GenericEntityCollector, GenericSplitListener };
+export interface GenericSQLOptions {
+    /** Enable or disable diagnostics (parse error collection). Defaults to true. */
+    diagnostics?: boolean;
+}
+export declare class GenericSQL extends BasicSQL<GenericSqlLexer, ProgramContext, GenericSqlParser> {
+    private _diagnostics;
+    constructor(options?: GenericSQLOptions);
+    protected createLexerFromCharStream(charStreams: CharStream): GenericSqlLexer;
+    validate(input: string): ParseError[];
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): GenericSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): GenericSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): GenericErrorListener;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): GenericEntityCollector;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): GenericSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
+}

package/dist/parser/generic/index.js

@@ -0,0 +1,94 @@
+import { processTokenCandidates } from '../common/tokenUtils';
+import { GenericSqlLexer } from '../../lib/generic/GenericSqlLexer';
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType, } from '../common/types';
+import { GenericEntityCollector } from './genericEntityCollector';
+import { GenericErrorListener } from './genericErrorListener';
+import { GenericSplitListener } from './genericSplitListener';
+import { GenericSemanticContextCollector } from './genericSemanticContextCollector';
+export { GenericEntityCollector, GenericSplitListener };
+export class GenericSQL extends BasicSQL {
+    constructor(options) {
+        super();
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([GenericSqlParser.RULE_nonReserved]);
+        this.preferredRules = new Set([
+            GenericSqlParser.RULE_tableName,
+            GenericSqlParser.RULE_tableNameCreate,
+            GenericSqlParser.RULE_columnRef,
+            ...this.excludeKeywordRules,
+        ]);
+        this._diagnostics = (options === null || options === void 0 ? void 0 : options.diagnostics) !== false;
+    }
+    createLexerFromCharStream(charStreams) {
+        return new GenericSqlLexer(charStreams);
+    }
+    validate(input) {
+        if (!this._diagnostics) {
+            return [];
+        }
+        return super.validate(input);
+    }
+    createParserFromTokenStream(tokenStream) {
+        return new GenericSqlParser(tokenStream);
+    }
+    get splitListener() {
+        return new GenericSplitListener();
+    }
+    createErrorListener(_errorListener) {
+        const parserContext = this;
+        return new GenericErrorListener(_errorListener, parserContext, this.preferredRules);
+    }
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new GenericEntityCollector(input, allTokens, caretTokenIndex);
+    }
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new GenericSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
+        const originalSyntaxSuggestions = [];
+        const keywords = [];
+        for (const candidate of candidates.rules) {
+            const [ruleType, candidateRule] = candidate;
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            let syntaxContextType = void 0;
+            switch (ruleType) {
+                case GenericSqlParser.RULE_tableName: {
+                    syntaxContextType = EntityContextType.TABLE;
+                    break;
+                }
+                case GenericSqlParser.RULE_tableNameCreate: {
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
+                    break;
+                }
+                case GenericSqlParser.RULE_columnRef: {
+                    syntaxContextType = EntityContextType.COLUMN;
+                    break;
+                }
+                default:
+                    break;
+            }
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
+                originalSyntaxSuggestions.push({
+                    syntaxContextType,
+                    wordRanges: tokenRanges,
+                });
+            }
+        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
+        return {
+            syntax: originalSyntaxSuggestions,
+            keywords,
+        };
+    }
+}

package/dist/parser/index.d.ts

@@ -5,3 +5,4 @@ export { SparkSQL } from './spark';
 export { PostgreSQL } from './postgresql';
 export { TrinoSQL } from './trino';
 export { ImpalaSQL } from './impala';
+export { GenericSQL } from './generic';

package/dist/parser/index.js

@@ -5,3 +5,4 @@ export { SparkSQL } from './spark';
 export { PostgreSQL } from './postgresql';
 export { TrinoSQL } from './trino';
 export { ImpalaSQL } from './impala';
+export { GenericSQL } from './generic';

package/dist/parser/mysql/index.js

@@ -25,6 +25,7 @@ export class MySQL extends BasicSQL {
             MySqlParser.RULE_functionName,
             MySqlParser.RULE_functionNameCreate,
             MySqlParser.RULE_columnName,
+            MySqlParser.RULE_columnNamePath,
             MySqlParser.RULE_columnNameCreate,
             ...this.excludeKeywordRules,
         ]);
@@ -88,7 +89,8 @@ export class MySQL extends BasicSQL {
                     syntaxContextType = EntityContextType.FUNCTION_CREATE;
                     break;
                 }
-                case MySqlParser.RULE_columnName: {
+                case MySqlParser.RULE_columnName:
+                case MySqlParser.RULE_columnNamePath: {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }

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

@@ -1,4 +1,4 @@
-import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectExpressionElementContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, TableAllColumnsContext, SelectLiteralColumnNameContext, AtomSubQueryTableSourceContext, SelectElementsContext, PureAllColumnsContext } 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, PureAllColumnsContext, SelectElement_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 {
@@ -18,6 +18,7 @@ export declare class MySqlEntityCollector extends EntityCollector implements MyS
     exitTableAllColumns(ctx: TableAllColumnsContext): void;
     exitPureAllColumns(ctx: PureAllColumnsContext): void;
     exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
+    exitSelectElement_dot_empty(ctx: SelectElement_dot_emptyContext): void;
     exitSelectExpressionElement(ctx: SelectExpressionElementContext): void;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStatementContext): void;

package/dist/parser/mysql/mysqlEntityCollector.js

@@ -1,4 +1,4 @@
-import { ColumnCreateTableContext, CreateDefinitionContext, CreateFunctionContext, SelectElementContext, TableSourceItemContext, AtomTableItemContext, SubqueryTableItemContext, } from '../../lib/mysql/MySqlParser';
+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';
 export class MySqlEntityCollector extends EntityCollector {
@@ -79,20 +79,30 @@ export class MySqlEntityCollector extends EntityCollector {
         });
     }
     exitSelectLiteralColumnName(ctx) {
+        // Handle empty column case (e.g., "select  from")
+        // When emptyColumn matches, the context has no actual tokens
+        if (!ctx.start || !ctx.stop || ctx.start.start > ctx.stop.stop) {
+            return;
+        }
         this.pushEntity(ctx, EntityContextType.COLUMN, [
             {
                 attrName: AttrName.alias,
-                endContextList: [SelectElementContext.name],
+                endContextList: [SelectElement_labelContext.name],
             },
         ], {
             declareType: ColumnDeclareType.LITERAL,
         });
     }
+    exitSelectElement_dot_empty(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
     exitSelectExpressionElement(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN, [
             {
                 attrName: AttrName.alias,
-                endContextList: [SelectElementContext.name],
+                endContextList: [SelectElement_exprContext.name],
             },
         ], {
             declareType: ColumnDeclareType.EXPRESSION,

package/dist/parser/mysql/mysqlErrorListener.js

@@ -14,6 +14,7 @@ export class MysqlErrorListener extends ParseErrorListener {
             [MySqlParser.RULE_functionName, 'function'],
             [MySqlParser.RULE_functionNameCreate, 'function'],
             [MySqlParser.RULE_columnName, 'column'],
+            [MySqlParser.RULE_columnNamePath, 'column'],
             [MySqlParser.RULE_columnNameCreate, 'column'],
         ]);
     }
@@ -48,6 +49,7 @@ export class MysqlErrorListener extends ParseErrorListener {
                     case MySqlParser.RULE_tableName:
                     case MySqlParser.RULE_functionName:
                     case MySqlParser.RULE_viewName:
+                    case MySqlParser.RULE_columnNamePath:
                     case MySqlParser.RULE_columnName: {
                         if (!result.includes(`{existing}${name}`)) {
                             result.push(`{existing}${name}`);

package/dist/parser/postgresql/postgreEntityCollector.d.ts

@@ -1,4 +1,4 @@
-import { type AlterTableStmtContext, type ColumnCreateTableContext, type ColumnNameCreateContext, type CreateDatabaseContext, type CreateForeignTableContext, type CreateFunctionStmtContext, type CreateMaterializedViewContext, type CreatePartitionForeignTableContext, type CreateViewContext, type DatabaseNameContext, type DatabaseNameCreateContext, type FunctionNameCreateContext, type InsertStatementContext, type ProcedureNameContext, type ProcedureNameCreateContext, type QueryCreateTableContext, SelectExpressionColumnNameContext, SelectLiteralColumnNameContext, type SelectStatementContext, type SingleStmtContext, TableAllColumnsContext, type TableNameContext, type TableNameCreateContext, type ViewNameContext, type ViewNameCreateContext, TargetListContext, SelectNoParensContext, XmlTableContext, FuncTableContext, SelectWithParensContext } from '../../lib/postgresql/PostgreSqlParser';
+import { type AlterTableStmtContext, type ColumnCreateTableContext, type ColumnNameCreateContext, type CreateDatabaseContext, type CreateForeignTableContext, type CreateFunctionStmtContext, type CreateMaterializedViewContext, type CreatePartitionForeignTableContext, type CreateViewContext, type DatabaseNameContext, type DatabaseNameCreateContext, FuncTableContext, type FunctionNameCreateContext, type InsertStatementContext, type ProcedureNameContext, type ProcedureNameCreateContext, type QueryCreateTableContext, SelectExpressionColumnNameContext, SelectLiteralColumnNameContext, SelectNoParensContext, type SelectStatementContext, SelectWithParensContext, type SingleStmtContext, TableAllColumnsContext, type TableNameContext, type TableNameCreateContext, Target_dot_emptyContext, Target_emptyContext, TargetListContext, type ViewNameContext, type ViewNameCreateContext, XmlTableContext } from '../../lib/postgresql/PostgreSqlParser';
 import type { PostgreSqlParserListener } from '../../lib/postgresql/PostgreSqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class PostgreSqlEntityCollector extends EntityCollector implements PostgreSqlParserListener {
@@ -16,6 +16,8 @@ export declare class PostgreSqlEntityCollector extends EntityCollector implement
     exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
     exitTargetList(ctx: TargetListContext): void;
     exitTableAllColumns(ctx: TableAllColumnsContext): void;
+    exitTarget_empty(ctx: Target_emptyContext): void;
+    exitTarget_dot_empty(ctx: Target_dot_emptyContext): void;
     exitSelectExpressionColumnName(ctx: SelectExpressionColumnNameContext): void;
     exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
     exitProcedureName(ctx: ProcedureNameContext): void;

package/dist/parser/postgresql/postgreEntityCollector.js

@@ -81,6 +81,7 @@ export class PostgreSqlEntityCollector extends EntityCollector {
         ]);
     }
     exitTargetList(ctx) {
+        // Only create QUERY_RESULT for targetList that is direct child of simpleSelect
         if (!isChildContextOf(ctx, PostgreSqlParser.RULE_simpleSelect))
             return;
         this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
@@ -92,6 +93,18 @@ export class PostgreSqlEntityCollector extends EntityCollector {
             declareType: ColumnDeclareType.ALL,
         });
     }
+    exitTarget_empty(ctx) {
+        // Don't create entity for empty column here
+        // The targetList will create QUERY_RESULT entity
+        // Empty targetEl means the QUERY_RESULT has no columns
+    }
+    exitTarget_dot_empty(ctx) {
+        // Create COLUMN entity for incomplete column reference (e.g., "tb.|")
+        // This allows completion to suggest columns from table "tb"
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
     exitSelectExpressionColumnName(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN, [
             {