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

package/dist/lib/generic/GenericSqlVisitor.d.ts

@@ -18,7 +18,10 @@ import { QueryTermContext } from "./GenericSqlParser.js";
 import { QueryPrimaryContext } from "./GenericSqlParser.js";
 import { QuerySpecificationContext } from "./GenericSqlParser.js";
 import { SetQuantifierContext } from "./GenericSqlParser.js";
-import { SelectItemContext } from "./GenericSqlParser.js";
+import { SelectExpressionElementContext } from "./GenericSqlParser.js";
+import { SelectStarElementContext } from "./GenericSqlParser.js";
+import { SelectAllElementContext } from "./GenericSqlParser.js";
+import { SelectEmptyElementContext } from "./GenericSqlParser.js";
 import { FromClauseContext } from "./GenericSqlParser.js";
 import { SimpleRelationContext } from "./GenericSqlParser.js";
 import { JoinRelationContext } from "./GenericSqlParser.js";
@@ -40,6 +43,7 @@ import { DeleteStatementContext } from "./GenericSqlParser.js";
 import { CreateTableStatementContext } from "./GenericSqlParser.js";
 import { TableElementContext } from "./GenericSqlParser.js";
 import { ColumnDefinitionContext } from "./GenericSqlParser.js";
+import { ColumnRefCreateContext } from "./GenericSqlParser.js";
 import { TableConstraintContext } from "./GenericSqlParser.js";
 import { AlterTableStatementContext } from "./GenericSqlParser.js";
 import { DropTableStatementContext } from "./GenericSqlParser.js";
@@ -87,8 +91,11 @@ import { BinaryLiteralContext } from "./GenericSqlParser.js";
 import { IdentifierContext } from "./GenericSqlParser.js";
 import { QualifiedNameContext } from "./GenericSqlParser.js";
 import { ColumnRefContext } from "./GenericSqlParser.js";
+import { ColumnNameContext } from "./GenericSqlParser.js";
+import { EmptyColumnContext } from "./GenericSqlParser.js";
 import { TableNameContext } from "./GenericSqlParser.js";
 import { TableNameCreateContext } from "./GenericSqlParser.js";
+import { FunctionNameContext } from "./GenericSqlParser.js";
 import { NonReservedContext } from "./GenericSqlParser.js";
 /**
  * This interface defines a complete generic visitor for a parse tree produced
@@ -220,11 +227,33 @@ export declare class GenericSqlVisitor<Result> extends AbstractParseTreeVisitor<
      */
     visitSetQuantifier?: (ctx: SetQuantifierContext) => Result;
     /**
-     * Visit a parse tree produced by `GenericSqlParser.selectItem`.
+     * Visit a parse tree produced by the `selectExpressionElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitSelectItem?: (ctx: SelectItemContext) => Result;
+    visitSelectExpressionElement?: (ctx: SelectExpressionElementContext) => Result;
+    /**
+     * Visit a parse tree produced by the `selectStarElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectStarElement?: (ctx: SelectStarElementContext) => Result;
+    /**
+     * Visit a parse tree produced by the `selectAllElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectAllElement?: (ctx: SelectAllElementContext) => Result;
+    /**
+     * Visit a parse tree produced by the `selectEmptyElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectEmptyElement?: (ctx: SelectEmptyElementContext) => Result;
     /**
      * Visit a parse tree produced by `GenericSqlParser.fromClause`.
      * @param ctx the parse tree
@@ -355,6 +384,12 @@ export declare class GenericSqlVisitor<Result> extends AbstractParseTreeVisitor<
      * @return the visitor result
      */
     visitColumnDefinition?: (ctx: ColumnDefinitionContext) => Result;
+    /**
+     * Visit a parse tree produced by `GenericSqlParser.columnRefCreate`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitColumnRefCreate?: (ctx: ColumnRefCreateContext) => Result;
     /**
      * Visit a parse tree produced by `GenericSqlParser.tableConstraint`.
      * @param ctx the parse tree
@@ -670,6 +705,18 @@ export declare class GenericSqlVisitor<Result> extends AbstractParseTreeVisitor<
      * @return the visitor result
      */
     visitColumnRef?: (ctx: ColumnRefContext) => Result;
+    /**
+     * Visit a parse tree produced by `GenericSqlParser.columnName`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitColumnName?: (ctx: ColumnNameContext) => Result;
+    /**
+     * Visit a parse tree produced by `GenericSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitEmptyColumn?: (ctx: EmptyColumnContext) => Result;
     /**
      * Visit a parse tree produced by `GenericSqlParser.tableName`.
      * @param ctx the parse tree
@@ -682,6 +729,12 @@ export declare class GenericSqlVisitor<Result> extends AbstractParseTreeVisitor<
      * @return the visitor result
      */
     visitTableNameCreate?: (ctx: TableNameCreateContext) => Result;
+    /**
+     * Visit a parse tree produced by `GenericSqlParser.functionName`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitFunctionName?: (ctx: FunctionNameContext) => Result;
     /**
      * Visit a parse tree produced by `GenericSqlParser.nonReserved`.
      * @param ctx the parse tree

package/dist/parser/common/entityCollector.js

@@ -233,6 +233,11 @@ const CTE_CLAUSE_CONTEXT_NAMES = new Set([
     'CtesContext',
     'WithContext',
 ]);
+/**
+ * Strip outer quotes/brackets and lowercase for CTE name matching.
+ * Quoted forms are lowercased too on purpose — loose match for completion UX
+ * across dialects, not dialect-accurate case folding (e.g. PostgreSQL quoted ids).
+ */
 function normalizeIdent(text) {
     let value = text.trim();
     if ((value.startsWith('`') && value.endsWith('`') && value.length >= 2) ||

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

@@ -1,5 +1,5 @@
 import type { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
-import { AlterTableContext, ColumnDefinitionContext, ColumnRefContext, CreateTableContext, DeleteContext, DropTableContext, InsertContext, NamedQueryContext, QuerySpecificationContext, QueryStatementContext, SelectItemContext, SingleStatementContext, TableNameContext, TableNameCreateContext, UpdateContext } from '../../lib/generic/GenericSqlParser';
+import { AlterTableContext, ColumnRefContext, ColumnRefCreateContext, CreateTableContext, DeleteContext, DropTableContext, InsertContext, NamedQueryContext, QuerySpecificationContext, QueryStatementContext, SelectAllElementContext, SelectEmptyElementContext, SelectExpressionElementContext, SelectStarElementContext, 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. */
@@ -10,10 +10,13 @@ export declare class GenericEntityCollector extends EntityCollector implements G
     exitNamedQuery(ctx: NamedQueryContext): void;
     exitTableNameCreate(ctx: TableNameCreateContext): void;
     exitColumnRef(ctx: ColumnRefContext): void;
-    exitColumnDefinition(ctx: ColumnDefinitionContext): void;
+    exitColumnRefCreate(ctx: ColumnRefCreateContext): void;
     exitQuerySpecification(ctx: QuerySpecificationContext): void;
     protected adaptOutwardQueryResult(entity: CommonEntityContext): CommonEntityContext;
-    exitSelectItem(ctx: SelectItemContext): void;
+    exitSelectExpressionElement(ctx: SelectExpressionElementContext): void;
+    exitSelectStarElement(ctx: SelectStarElementContext): void;
+    exitSelectAllElement(ctx: SelectAllElementContext): void;
+    exitSelectEmptyElement(ctx: SelectEmptyElementContext): void;
     private isSimpleColumnReference;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStatementContext): void;

package/dist/parser/generic/genericEntityCollector.js

@@ -1,5 +1,5 @@
 import { ColumnDefinitionContext, AliasedRelationContext, CreateTableStatementContext, } from '../../lib/generic/GenericSqlParser';
-import { AttrName, ColumnDeclareType, EntityCollector, isColumnEntityContext, isCommonEntityContext, StmtContextType, TableDeclareType, } from '../common/entityCollector';
+import { AttrName, ColumnDeclareType, EntityCollector, isCommonEntityContext, StmtContextType, TableDeclareType, } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
 import { tokenToWord } from '../common/textAndWord';
 export class GenericEntityCollector extends EntityCollector {
@@ -38,33 +38,17 @@ export class GenericEntityCollector extends EntityCollector {
     exitColumnRef(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN);
     }
-    exitColumnDefinition(ctx) {
-        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, [
+    exitColumnRefCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.colType,
+                endContextList: [ColumnDefinitionContext.name],
+            },
             {
                 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) {
         var _a, _b;
@@ -82,28 +66,32 @@ export class GenericEntityCollector extends EntityCollector {
             return entity;
         return Object.assign(Object.assign({}, entity), { text });
     }
-    exitSelectItem(ctx) {
+    exitSelectExpressionElement(ctx) {
         var _a;
-        if (ctx.ASTERISK()) {
-            this.pushEntity(ctx, EntityContextType.COLUMN, [], {
-                declareType: ColumnDeclareType.ALL,
-            });
-        }
-        else {
-            const isSimpleColumn = this.isSimpleColumnReference(ctx);
-            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, '');
-            }
+        const isSimpleColumn = this.isSimpleColumnReference(ctx);
+        const entity = this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: isSimpleColumn ? ColumnDeclareType.LITERAL : ColumnDeclareType.EXPRESSION,
+        });
+        const aliasToken = (_a = ctx._alias) === null || _a === void 0 ? void 0 : _a.start;
+        if (entity && aliasToken) {
+            entity[AttrName.alias] = tokenToWord(aliasToken, '');
         }
     }
+    exitSelectStarElement(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
+    exitSelectAllElement(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.ALL,
+        });
+    }
+    exitSelectEmptyElement(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
     isSimpleColumnReference(ctx) {
         const text = ctx.getText();
         // Simple column reference: no parentheses, no operators, no spaces

package/dist/parser/generic/index.js

@@ -19,7 +19,9 @@ export class GenericSQL extends BasicSQL {
             GenericSqlParser.RULE_tableName,
             GenericSqlParser.RULE_tableNameCreate,
             GenericSqlParser.RULE_columnRef,
-            GenericSqlParser.RULE_qualifiedName,
+            GenericSqlParser.RULE_columnRefCreate,
+            GenericSqlParser.RULE_columnName,
+            GenericSqlParser.RULE_functionName,
             ...this.excludeKeywordRules,
         ]);
         this._diagnostics = (options === null || options === void 0 ? void 0 : options.diagnostics) !== false;
@@ -69,15 +71,16 @@ 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;
-                    }
+                case GenericSqlParser.RULE_columnRefCreate: {
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
+                    break;
+                }
+                case GenericSqlParser.RULE_columnName: {
+                    syntaxContextType = EntityContextType.COLUMN;
+                    break;
+                }
+                case GenericSqlParser.RULE_functionName: {
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-sql-parser",
-  "version": "4.5.2-beta.1",
+  "version": "4.5.2-beta.2",
   "authors": "DTStack Corporation",
   "description": "SQL Parsers for BigData, built with antlr4",
   "keywords": [