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

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

@@ -116,6 +116,7 @@ import { SortItemContext } from "./TrinoSqlParser.js";
 import { QuerySpecificationContext } from "./TrinoSqlParser.js";
 import { WhereClauseContext } from "./TrinoSqlParser.js";
 import { HavingClauseContext } from "./TrinoSqlParser.js";
+import { SelectListContext } from "./TrinoSqlParser.js";
 import { GroupByContext } from "./TrinoSqlParser.js";
 import { PartitionByContext } from "./TrinoSqlParser.js";
 import { SingleGroupingSetContext } from "./TrinoSqlParser.js";
@@ -128,8 +129,11 @@ import { WindowDefinitionContext } from "./TrinoSqlParser.js";
 import { WindowSpecificationContext } from "./TrinoSqlParser.js";
 import { NamedQueryContext } from "./TrinoSqlParser.js";
 import { SetQuantifierContext } from "./TrinoSqlParser.js";
-import { SelectSingleContext } from "./TrinoSqlParser.js";
-import { SelectAllContext } from "./TrinoSqlParser.js";
+import { SelectItemContext } from "./TrinoSqlParser.js";
+import { SelectAllWithoutTableContext } from "./TrinoSqlParser.js";
+import { TableAllColumnsContext } from "./TrinoSqlParser.js";
+import { SelectLiteralColumnNameContext } from "./TrinoSqlParser.js";
+import { SelectExpressionColumnNameContext } from "./TrinoSqlParser.js";
 import { RelationDefaultContext } from "./TrinoSqlParser.js";
 import { JoinRelationContext } from "./TrinoSqlParser.js";
 import { JoinTypeContext } from "./TrinoSqlParser.js";
@@ -151,11 +155,12 @@ import { ColumnListCreateContext } from "./TrinoSqlParser.js";
 import { ColumnListContext } from "./TrinoSqlParser.js";
 import { ColumnAliasesContext } from "./TrinoSqlParser.js";
 import { TableNameContext } from "./TrinoSqlParser.js";
+import { ExpressionSourceTableContext } from "./TrinoSqlParser.js";
+import { ParenthesizedRelationContext } from "./TrinoSqlParser.js";
 import { SubqueryRelationContext } from "./TrinoSqlParser.js";
 import { UnnestContext } from "./TrinoSqlParser.js";
 import { LateralContext } from "./TrinoSqlParser.js";
 import { TableFunctionInvocationContext } from "./TrinoSqlParser.js";
-import { ParenthesizedRelationContext } from "./TrinoSqlParser.js";
 import { JsonTableContext } from "./TrinoSqlParser.js";
 import { OrdinalityColumnContext } from "./TrinoSqlParser.js";
 import { ValueColumnContext } from "./TrinoSqlParser.js";
@@ -1176,6 +1181,12 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitHavingClause?: (ctx: HavingClauseContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.selectList`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectList?: (ctx: SelectListContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.groupBy`.
      * @param ctx the parse tree
@@ -1253,19 +1264,35 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      */
     visitSetQuantifier?: (ctx: SetQuantifierContext) => Result;
     /**
-     * Visit a parse tree produced by the `selectSingle`
-     * labeled alternative in `TrinoSqlParser.selectItem`.
+     * Visit a parse tree produced by `TrinoSqlParser.selectItem`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitSelectSingle?: (ctx: SelectSingleContext) => Result;
+    visitSelectItem?: (ctx: SelectItemContext) => Result;
     /**
-     * Visit a parse tree produced by the `selectAll`
-     * labeled alternative in `TrinoSqlParser.selectItem`.
+     * Visit a parse tree produced by `TrinoSqlParser.selectAllWithoutTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitSelectAll?: (ctx: SelectAllContext) => Result;
+    visitSelectAllWithoutTable?: (ctx: SelectAllWithoutTableContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.tableAllColumns`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTableAllColumns?: (ctx: TableAllColumnsContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.selectLiteralColumnName`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectLiteralColumnName?: (ctx: SelectLiteralColumnNameContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.selectExpressionColumnName`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSelectExpressionColumnName?: (ctx: SelectExpressionColumnNameContext) => Result;
     /**
      * Visit a parse tree produced by the `relationDefault`
      * labeled alternative in `TrinoSqlParser.relation`.
@@ -1396,43 +1423,50 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      */
     visitTableName?: (ctx: TableNameContext) => Result;
     /**
-     * Visit a parse tree produced by the `subqueryRelation`
+     * Visit a parse tree produced by the `expressionSourceTable`
+     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExpressionSourceTable?: (ctx: ExpressionSourceTableContext) => Result;
+    /**
+     * Visit a parse tree produced by the `parenthesizedRelation`
      * labeled alternative in `TrinoSqlParser.relationPrimary`.
      * @param ctx the parse tree
      * @return the visitor result
      */
+    visitParenthesizedRelation?: (ctx: ParenthesizedRelationContext) => Result;
+    /**
+     * Visit a parse tree produced by the `subqueryRelation`
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
     visitSubqueryRelation?: (ctx: SubqueryRelationContext) => Result;
     /**
      * Visit a parse tree produced by the `unnest`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
     visitUnnest?: (ctx: UnnestContext) => Result;
     /**
      * Visit a parse tree produced by the `lateral`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
     visitLateral?: (ctx: LateralContext) => Result;
     /**
      * Visit a parse tree produced by the `tableFunctionInvocation`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */
     visitTableFunctionInvocation?: (ctx: TableFunctionInvocationContext) => Result;
-    /**
-     * Visit a parse tree produced by the `parenthesizedRelation`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
-     * @param ctx the parse tree
-     * @return the visitor result
-     */
-    visitParenthesizedRelation?: (ctx: ParenthesizedRelationContext) => Result;
     /**
      * Visit a parse tree produced by the `jsonTable`
-     * labeled alternative in `TrinoSqlParser.relationPrimary`.
+     * labeled alternative in `TrinoSqlParser.relationSourceTable`.
      * @param ctx the parse tree
      * @return the visitor result
      */

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.
@@ -359,6 +359,8 @@ export class BasicSQL {
         }
         const core = new CodeCompletionCore(sqlParserIns);
         core.preferredRules = this.preferredRules;
+        // core.showRuleStack = 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.d.ts

@@ -22,6 +22,8 @@ export interface StmtContext {
     readonly rootStmt: StmtContext | null;
     readonly parentStmt: StmtContext | null;
     readonly isContainCaret?: boolean;
+    readonly scopeDepth: number;
+    readonly text: string;
 }
 export declare function toStmtContext(ctx: ParserRuleContext, type: StmtContextType, input: string, rootStmt: StmtContext | null, parentStmt: StmtContext | null, isContainCaret?: boolean): StmtContext | null;
 /**
@@ -49,31 +51,77 @@ export interface Argument {
     argName?: WordRange;
     argType: WordRange;
 }
+/**
+ * Base interface for all entity contexts in SQL parsing
+ */
 export interface BaseEntityContext {
+    /** The type of entity context */
     readonly entityContextType: EntityContextType;
+    /** The text representation of this entity */
     readonly text: string;
+    /** The position information for this entity */
     readonly position: WordPosition;
+    /** The statement this entity belongs to */
     readonly belongStmt: StmtContext;
+    /** Reference to another entity or string */
     reference?: string | EntityContext;
+    /** Whether the entity is accessible from the caret position, **ONLY** applicable to table entity */
+    isAccessible: boolean | null;
+    /** Entities related to this entity */
+    relatedEntities: EntityContext[] | null;
+    /** Comment attribute for this entity */
     [AttrName.comment]: WordRange | null;
+    /** Alias attribute for this entity */
     [AttrName.alias]?: WordRange | null;
 }
+/**
+ * Types of column declarations
+ */
+export declare enum ColumnDeclareType {
+    /** Literal column name */
+    LITERAL = 0,
+    /** Using asterisk syntax (tableName.*) */
+    ALL = 1,
+    /** Complex expressions like subqueries, case statements, function calls */
+    EXPRESSION = 2
+}
+/**
+ * Types of table declarations
+ */
+export declare enum TableDeclareType {
+    /** Regular table reference */
+    LITERAL = 0,
+    /** Table defined by expression (e.g., subquery) */
+    EXPRESSION = 1
+}
 export interface CommonEntityContext extends BaseEntityContext {
-    relatedEntities: CommonEntityContext[] | null;
+    /** Columns associated with this entity */
     columns?: ColumnEntityContext[];
+    /** Type of table declaration */
+    declareType?: TableDeclareType;
 }
 export interface ColumnEntityContext extends BaseEntityContext {
+    /** Type of column declaration */
+    declareType?: ColumnDeclareType;
+    /** Column type information */
     [AttrName.colType]: WordRange | null;
+    /** Column alias */
+    [AttrName.alias]?: WordRange | null;
 }
 export interface FuncEntityContext extends BaseEntityContext {
-    relatedEntities: CommonEntityContext[] | null;
+    /** Function arguments */
     arguments: Argument[] | null;
+    /** Function return value */
     returns?: Argument;
 }
 export type EntityContext = CommonEntityContext | FuncEntityContext | ColumnEntityContext;
 export declare function isCommonEntityContext(entity: EntityContext): entity is CommonEntityContext;
 export declare function isFuncEntityContext(entity: EntityContext): entity is FuncEntityContext;
 export declare function isColumnEntityContext(entity: EntityContext): entity is ColumnEntityContext;
+/**
+ * Check if ctx is a child node of a specific rule type
+ */
+export declare function isChildContextOf(ctx: ParserRuleContext, parentRuleIndex: number): boolean;
 /**
  *  what we need when collect attribute information
  * */
@@ -81,7 +129,10 @@ interface AttrInfo {
     attrName: AttrName;
     endContextList: string[];
 }
-export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, attrInfo?: AttrInfo[]): EntityContext | null;
+interface MetaInfo {
+    declareType: TableDeclareType | ColumnDeclareType;
+}
+export declare function toEntityContext(ctx: ParserRuleContext, type: EntityContextType, input: string, belongStmt: StmtContext, attrInfo?: AttrInfo[], metaInfo?: MetaInfo): EntityContext | null;
 export declare function findAttribute(ctx: ParserRuleContextWithAttr | null, keyName: AttrName, endContextNameList: string[]): Token | null;
 /**
  * @todo: Handle alias, includes column alias, table alias, query as alias and so on.
@@ -97,6 +148,16 @@ export declare abstract class EntityCollector {
     private readonly _stmtStack;
     /** Staging entities inside a single statement or clause. */
     private readonly _entityStack;
+    /**
+     * The scope depth of the statement containing the caret.
+     * This is used to determine the accessibility of entities.
+     */
+    private _caretStmtScopeDepth;
+    /**
+     * The nearest statement containing the caret,
+     * Not used for now.
+     */
+    private _caretStmt;
     /**
      * Always point to the first non-commonStmt at the bottom of the _stmtStack,
      * unless there are only commonStmts in the _stmtStack.
@@ -109,6 +170,30 @@ export declare abstract class EntityCollector {
     getRootStmt(): StmtContext | null;
     getEntities(): EntityContext[];
     enterProgram(): void;
+    exitProgram(): void;
+    /**
+     * Adds accessibility markers to entities
+     * @param entities The list of entities to process
+     */
+    protected attachAccessibleToEntities(entities: EntityContext[]): void;
+    /**
+     * Attach query result to column if the column is derived from expression.
+     */
+    protected attachQueryResultToColumn(column: ColumnEntityContext, queryResults: CommonEntityContext[]): void;
+    /**
+     * Attach related columns to query result
+     */
+    protected attachColumnsToQueryResult(queryResult: CommonEntityContext, columns: ColumnEntityContext[]): void;
+    /**
+     * Attach query result to table if the table is derived from expression.
+     */
+    protected attachQueryResultToTable(table: CommonEntityContext, queryResults: CommonEntityContext[]): void;
+    /**
+     * Gets query result entities inside a statement
+     * @param stmt The statement to search within
+     * @returns Array of query result entity contexts
+     */
+    protected getQueryResultEntitiesInsideStmt(stmt: StmtContext): CommonEntityContext[];
     /**
      * The antlr4 will ignore hidden tokens, if we type whitespace at the end of a statement,
      * the whitespace token will not as stop token, so we consider the whitespace token as a part of the nonhidden token in front of it
@@ -116,7 +201,7 @@ export declare abstract class EntityCollector {
     protected getPrevNonHiddenTokenIndex(caretTokenIndex: number): number;
     protected pushStmt(ctx: ParserRuleContext, type: StmtContextType): StmtContext | null;
     protected popStmt(): StmtContext;
-    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[]): EntityContext | null;
+    protected pushEntity(ctx: ParserRuleContext, type: EntityContextType, attrInfo?: AttrInfo[], metaInfo?: MetaInfo): EntityContext | null;
     /**
      * Combine entities that inside a single statement.
      * e.g. combine tableName and column if they are inside a same createTableStatement.
@@ -127,6 +212,8 @@ export declare abstract class EntityCollector {
      * Combined all entities under a rootStmt.
      */
     protected combineRootStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
+    protected combineQueryResultStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
+    protected combineFromTableSource(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
     protected combineCreateTableOrViewStmtEntities(stmtContext: StmtContext, entitiesInsideStmt: EntityContext[]): EntityContext[];
 }
 export {};