dt-sql-parser 4.4.2 → 4.5.0-beta.1

package/dist/parser/hive/hiveEntityCollector.js

@@ -1,5 +1,5 @@
-import { ColumnNameCommentContext, ColumnNameTypeConstraintContext, CreateDatabaseStatementContext, CreateTableStatementContext, CreateViewStatementContext, TableSourceContext, UniqueJoinSourceContext, } from '../../lib/hive/HiveSqlParser';
-import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
+import { ColumnNameCommentContext, ColumnNameTypeConstraintContext, CreateDatabaseStatementContext, CreateTableStatementContext, CreateViewStatementContext, HiveSqlParser, PartitionedTableFunctionContext, SelectItemContext, SubQuerySourceContext, TableSourceContext, UniqueJoinSourceContext, VirtualTableSourceContext, } from '../../lib/hive/HiveSqlParser';
+import { AttrName, ColumnDeclareType, EntityCollector, isChildContextOf, StmtContextType, TableDeclareType, } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
 export class HiveEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
@@ -11,18 +11,57 @@ export class HiveEntityCollector extends EntityCollector {
             },
         ]);
     }
+    /** Table Entity Rules */
     exitTableName(ctx) {
-        var _a;
-        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
-        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
-            ? [
-                {
-                    attrName: AttrName.alias,
-                    endContextList: [TableSourceContext.name, UniqueJoinSourceContext.name],
-                },
-            ]
-            : undefined);
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableSourceContext.name, UniqueJoinSourceContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    /** Virtual Table Entity Rules */
+    exitAtomValuesClause(ctx) {
+        if (!isChildContextOf(ctx, HiveSqlParser.RULE_fromClause))
+            return;
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [VirtualTableSourceContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
+    }
+    /** SubQuery Table Entity Rules */
+    exitQueryStatementExpression(ctx) {
+        if (!isChildContextOf(ctx, HiveSqlParser.RULE_fromClause))
+            return;
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [SubQuerySourceContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
+    }
+    /** Partitioned Table Entity Rules */
+    exitAtomPartitionedTableFunction(ctx) {
+        if (!isChildContextOf(ctx, HiveSqlParser.RULE_fromClause))
+            return;
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [PartitionedTableFunctionContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
     }
+    /** Column Entity Rules */
     exitColumnNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
             {
@@ -35,6 +74,37 @@ export class HiveEntityCollector extends EntityCollector {
             },
         ]);
     }
+    exitSelectLiteralColumnName(ctx) {
+        if (!isChildContextOf(ctx, HiveSqlParser.RULE_selectItem))
+            return;
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [SelectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
+    exitSelectExpressionColumnName(ctx) {
+        if (!isChildContextOf(ctx, HiveSqlParser.RULE_selectItem))
+            return;
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [SelectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.EXPRESSION,
+        });
+    }
+    exitTableAllColumns(ctx) {
+        if (!isChildContextOf(ctx, HiveSqlParser.RULE_selectItem))
+            return;
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
     exitViewNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [
             {
@@ -43,6 +113,9 @@ export class HiveEntityCollector extends EntityCollector {
             },
         ]);
     }
+    exitSelectList(ctx) {
+        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+    }
     exitViewName(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }

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

@@ -1,16 +1,22 @@
 import { ImpalaSqlParserListener } from '../../lib';
-import { ColumnNamePathCreateContext, CreateAggregateFunctionContext, CreateFunctionContext, CreateKuduTableAsSelectContext, CreateSchemaContext, CreateTableLikeContext, CreateTableSelectContext, CreateViewContext, DatabaseNameCreateContext, DatabaseNamePathContext, FunctionNameCreateContext, InsertStatementContext, QueryStatementContext, SingleStatementContext, TableNameCreateContext, TableNamePathContext, ViewNameCreateContext, ViewNamePathContext } from '../../lib/impala/ImpalaSqlParser';
+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 { EntityCollector } from '../common/entityCollector';
 export declare class ImpalaEntityCollector extends EntityCollector implements ImpalaSqlParserListener {
     /** ===== Entity begin */
     exitTableNameCreate(ctx: TableNameCreateContext): void;
     exitTableNamePath(ctx: TableNamePathContext): void;
+    exitAtomSubQueryTableSource(ctx: AtomSubQueryTableSourceContext): void;
+    exitUnnest(ctx: UnnestContext): void;
     exitColumnNamePathCreate(ctx: ColumnNamePathCreateContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
     exitViewNamePath(ctx: ViewNamePathContext): void;
     exitDatabaseNamePath(ctx: DatabaseNamePathContext): void;
     exitDatabaseNameCreate(ctx: DatabaseNameCreateContext): void;
     exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    exitSelectList(ctx: SelectListContext): void;
+    exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
+    exitSelectExpressionColumnName(ctx: SelectExpressionColumnNameContext): void;
+    exitTableAllColumns(ctx: TableAllColumnsContext): void;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStatementContext): void;
     exitSingleStatement(ctx: SingleStatementContext): void;

package/dist/parser/impala/impalaEntityCollector.js

@@ -1,5 +1,5 @@
-import { ColumnDefinitionContext, CreateKuduTableAsSelectContext, CreateSchemaContext, CreateTableSelectContext, CreateViewContext, KuduTableElementContext, SampledRelationContext, ViewColumnItemContext, } from '../../lib/impala/ImpalaSqlParser';
-import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
+import { AliasedRelationContext, ColumnDefinitionContext, CreateKuduTableAsSelectContext, CreateSchemaContext, CreateTableSelectContext, CreateViewContext, KuduTableElementContext, SelectItemContext, ViewColumnItemContext, } from '../../lib/impala/ImpalaSqlParser';
+import { AttrName, ColumnDeclareType, EntityCollector, StmtContextType, TableDeclareType, } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
 export class ImpalaEntityCollector extends EntityCollector {
     /** ===== Entity begin */
@@ -15,16 +15,34 @@ export class ImpalaEntityCollector extends EntityCollector {
         ]);
     }
     exitTableNamePath(ctx) {
-        var _a;
-        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
-        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
-            ? [
-                {
-                    attrName: AttrName.alias,
-                    endContextList: [SampledRelationContext.name],
-                },
-            ]
-            : undefined);
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [AliasedRelationContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    exitAtomSubQueryTableSource(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [AliasedRelationContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
+    }
+    exitUnnest(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [AliasedRelationContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
     }
     exitColumnNamePathCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
@@ -71,6 +89,39 @@ export class ImpalaEntityCollector extends EntityCollector {
     exitFunctionNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
     }
+    exitSelectList(ctx) {
+        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+    }
+    exitSelectLiteralColumnName(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [SelectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
+    exitSelectExpressionColumnName(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [SelectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.EXPRESSION,
+        });
+    }
+    exitTableAllColumns(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [SelectItemContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
     /** ===== Statement begin */
     enterSingleStatement(ctx) {
         this.pushStmt(ctx, StmtContextType.COMMON_STMT);

package/dist/parser/impala/index.js

@@ -102,7 +102,8 @@ export class ImpalaSQL extends BasicSQL {
                         candidateRule.ruleList.includes(ImpalaSqlParser.RULE_whereClause) ||
                         candidateRule.ruleList.includes(ImpalaSqlParser.RULE_whenClause) ||
                         candidateRule.ruleList.includes(ImpalaSqlParser.RULE_partitionByClause) ||
-                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_relation)) {
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_relation) ||
+                        candidateRule.ruleList.includes(ImpalaSqlParser.RULE_functionCallExpression)) {
                         syntaxContextType = EntityContextType.COLUMN;
                     }
                 }

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,16 +1,25 @@
-import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } 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 {
     /** ====== Entity Begin */
     exitDatabaseName(ctx: DatabaseNameContext): void;
     exitDatabaseNameCreate(ctx: DatabaseNameCreateContext): void;
+    /** Table Entity Rules */
     exitTableName(ctx: TableNameContext): void;
+    /** SubQuery Table Entity Rules */
+    exitAtomSubQueryTableSource(ctx: AtomSubQueryTableSourceContext): void;
     exitTableNameCreate(ctx: TableNameCreateContext): void;
     exitViewName(ctx: ViewNameContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
     exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    exitSelectElements(ctx: SelectElementsContext): void;
     exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    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;
     exitSingleStatement(ctx: SingleStatementContext): void;

package/dist/parser/mysql/mysqlEntityCollector.js

@@ -1,5 +1,5 @@
-import { ColumnCreateTableContext, CreateDefinitionContext, CreateFunctionContext, TableSourceContext, } from '../../lib/mysql/MySqlParser';
-import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
+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 {
     /** ====== Entity Begin */
@@ -9,17 +9,27 @@ export class MySqlEntityCollector extends EntityCollector {
     exitDatabaseNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
     }
+    /** Table Entity Rules */
     exitTableName(ctx) {
-        var _a;
-        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
-        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
-            ? [
-                {
-                    attrName: AttrName.alias,
-                    endContextList: [TableSourceContext.name],
-                },
-            ]
-            : undefined);
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableSourceItemContext.name, AtomTableItemContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    /** SubQuery Table Entity Rules */
+    exitAtomSubQueryTableSource(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableSourceItemContext.name, SubqueryTableItemContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
     }
     exitTableNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
@@ -43,6 +53,9 @@ export class MySqlEntityCollector extends EntityCollector {
             },
         ]);
     }
+    exitSelectElements(ctx) {
+        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+    }
     exitColumnNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
             {
@@ -55,6 +68,46 @@ export class MySqlEntityCollector extends EntityCollector {
             },
         ]);
     }
+    exitTableAllColumns(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
+    exitPureAllColumns(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
+    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: [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: [SelectElement_exprContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.EXPRESSION,
+        });
+    }
     /** ===== Statement begin */
     enterSingleStatement(ctx) {
         this.pushStmt(ctx, StmtContextType.COMMON_STMT);

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, type SelectStatementContext, type SingleStmtContext, type TableNameContext, type TableNameCreateContext, type ViewNameContext, type ViewNameCreateContext } 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 {
@@ -6,11 +6,20 @@ export declare class PostgreSqlEntityCollector extends EntityCollector implement
     exitDatabaseName(ctx: DatabaseNameContext): void;
     exitDatabaseNameCreate(ctx: DatabaseNameCreateContext): void;
     exitTableName(ctx: TableNameContext): void;
+    exitXmlTable(ctx: XmlTableContext): void;
+    exitFuncTable(ctx: FuncTableContext): void;
+    exitSelectWithParens(ctx: SelectWithParensContext): void;
     exitTableNameCreate(ctx: TableNameCreateContext): void;
     exitViewName(ctx: ViewNameContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
     exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
     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;
     exitProcedureNameCreate(ctx: ProcedureNameCreateContext): void;
     /** ===== Statement begin */
@@ -32,6 +41,8 @@ export declare class PostgreSqlEntityCollector extends EntityCollector implement
     exitCreateMaterializedView(ctx: CreateMaterializedViewContext): void;
     enterSelectStatement(ctx: SelectStatementContext): void;
     exitSelectStatement(ctx: SelectStatementContext): void;
+    enterSelectNoParens(ctx: SelectNoParensContext): void;
+    exitSelectNoParens(ctx: SelectNoParensContext): void;
     enterInsertStatement(ctx: InsertStatementContext): void;
     exitInsertStatement(ctx: InsertStatementContext): void;
     enterCreateFunctionStmt(ctx: CreateFunctionStmtContext): void;

package/dist/parser/postgresql/postgreEntityCollector.js

@@ -1,5 +1,5 @@
-import { Column_defContext, TableRefContext, } from '../../lib/postgresql/PostgreSqlParser';
-import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
+import { Column_defContext, ExpressionTableContext, PostgreSqlParser, TableRefContext, Target_labelContext, } from '../../lib/postgresql/PostgreSqlParser';
+import { AttrName, ColumnDeclareType, EntityCollector, isChildContextOf, StmtContextType, TableDeclareType, } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
 export class PostgreSqlEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
@@ -10,31 +10,57 @@ export class PostgreSqlEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
     }
     exitTableName(ctx) {
-        var _a;
-        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
-        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
-            ? [
-                {
-                    attrName: AttrName.alias,
-                    endContextList: [TableRefContext.name],
-                },
-            ]
-            : undefined);
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableRefContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    exitXmlTable(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [ExpressionTableContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
+    }
+    exitFuncTable(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [ExpressionTableContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
+    }
+    exitSelectWithParens(ctx) {
+        if (!isChildContextOf(ctx, PostgreSqlParser.RULE_expressionTable))
+            return;
+        this.pushEntity(ctx, EntityContextType.TABLE, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [ExpressionTableContext.name],
+            },
+        ], {
+            declareType: TableDeclareType.EXPRESSION,
+        });
     }
     exitTableNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
     }
     exitViewName(ctx) {
-        var _a;
-        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
-        this.pushEntity(ctx, EntityContextType.VIEW, needCollectAttr
-            ? [
-                {
-                    attrName: AttrName.alias,
-                    endContextList: [TableRefContext.name],
-                },
-            ]
-            : undefined);
+        this.pushEntity(ctx, EntityContextType.VIEW, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [TableRefContext.name],
+            },
+        ]);
     }
     exitViewNameCreate(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
@@ -54,6 +80,51 @@ 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);
+    }
+    exitTableAllColumns(ctx) {
+        if (!isChildContextOf(ctx, PostgreSqlParser.RULE_targetList))
+            return;
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            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, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [Target_labelContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.EXPRESSION,
+        });
+    }
+    exitSelectLiteralColumnName(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [
+            {
+                attrName: AttrName.alias,
+                endContextList: [Target_labelContext.name],
+            },
+        ], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
     exitProcedureName(ctx) {
         this.pushEntity(ctx, EntityContextType.PROCEDURE);
     }
@@ -115,6 +186,12 @@ export class PostgreSqlEntityCollector extends EntityCollector {
     exitSelectStatement(ctx) {
         this.popStmt();
     }
+    enterSelectNoParens(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitSelectNoParens(ctx) {
+        this.popStmt();
+    }
     enterInsertStatement(ctx) {
         this.pushStmt(ctx, StmtContextType.INSERT_STMT);
     }

package/dist/parser/spark/index.js

@@ -30,6 +30,7 @@ export class SparkSQL extends BasicSQL {
             SparkSqlParser.RULE_functionNameCreate,
             SparkSqlParser.RULE_columnName,
             SparkSqlParser.RULE_columnNamePath,
+            SparkSqlParser.RULE_columnNamePathAllowEmpty,
             SparkSqlParser.RULE_columnNameCreate,
             ...this.excludeKeywordRules,
         ]);
@@ -101,7 +102,8 @@ export class SparkSQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
-                case SparkSqlParser.RULE_columnNamePath: {
+                case SparkSqlParser.RULE_columnNamePath:
+                case SparkSqlParser.RULE_columnNamePathAllowEmpty: {
                     if (candidateRule.ruleList.includes(SparkSqlParser.RULE_whenClause) ||
                         candidateRule.ruleList.includes(SparkSqlParser.RULE_whereClause) ||
                         candidateRule.ruleList.includes(SparkSqlParser.RULE_joinRelation) ||

package/dist/parser/spark/sparkEntityCollector.d.ts

@@ -1,16 +1,28 @@
-import { ColumnNameCreateContext, CreateFunctionContext, CreateNamespaceContext, CreateTableContext, CreateTableLikeContext, CreateTempViewUsingContext, CreateViewContext, FunctionNameCreateContext, InsertFromQueryContext, MultipleInsertContext, NamespaceNameContext, NamespaceNameCreateContext, QueryStatementContext, ReplaceTableContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/spark/SparkSqlParser';
+import { AtomSubQueryTableSourceContext, ColumnNameCreateContext, CreateFunctionContext, CreateNamespaceContext, CreateTableContext, CreateTableLikeContext, CreateTempViewUsingContext, CreateViewContext, FunctionNameCreateContext, FunctionTableSourceContext, InlineTableSourceContext, InsertFromQueryContext, MultipleInsertContext, NamespaceNameContext, NamespaceNameCreateContext, QueryStatementContext, ReplaceTableContext, SelectExpressionColumnNameContext, SelectListContext, SelectLiteralColumnNameContext, SingleStatementContext, TableAllColumnsContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/spark/SparkSqlParser';
 import type { SparkSqlParserListener } from '../../lib/spark/SparkSqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class SparkEntityCollector extends EntityCollector implements SparkSqlParserListener {
     /** ====== Entity Begin */
     exitNamespaceName(ctx: NamespaceNameContext): void;
     exitNamespaceNameCreate(ctx: NamespaceNameCreateContext): void;
+    /** Table Entity Rules */
     exitTableName(ctx: TableNameContext): void;
+    /** Inline Table Entity Rules */
+    exitInlineTableSource(ctx: InlineTableSourceContext): void;
+    /** Function Table Entity Rules */
+    exitFunctionTableSource(ctx: FunctionTableSourceContext): void;
+    /** SubQuery Table Entity Rules */
+    exitAtomSubQueryTableSource(ctx: AtomSubQueryTableSourceContext): void;
     exitTableNameCreate(ctx: TableNameCreateContext): void;
     exitViewName(ctx: ViewNameContext): void;
+    exitSelectList(ctx: SelectListContext): void;
     exitViewNameCreate(ctx: ViewNameCreateContext): void;
     exitFunctionNameCreate(ctx: FunctionNameCreateContext): void;
+    /** Column Entity Rules */
     exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
+    exitSelectExpressionColumnName(ctx: SelectExpressionColumnNameContext): void;
+    exitTableAllColumns(ctx: TableAllColumnsContext): void;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStatementContext): void;
     exitSingleStatement(ctx: SingleStatementContext): void;