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

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

@@ -138,6 +138,8 @@ import { RelationDefaultContext } from "./TrinoSqlParser.js";
 import { JoinRelationContext } from "./TrinoSqlParser.js";
 import { JoinTypeContext } from "./TrinoSqlParser.js";
 import { JoinCriteriaContext } from "./TrinoSqlParser.js";
+import { JoinColumnEqualityContext } from "./TrinoSqlParser.js";
+import { JoinColumnReferenceContext } from "./TrinoSqlParser.js";
 import { SampledRelationContext } from "./TrinoSqlParser.js";
 import { SampleTypeContext } from "./TrinoSqlParser.js";
 import { TrimsSpecificationContext } from "./TrinoSqlParser.js";
@@ -223,6 +225,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";
@@ -355,6 +358,7 @@ import { CatalogNameCreateContext } from "./TrinoSqlParser.js";
 import { FunctionNameContext } from "./TrinoSqlParser.js";
 import { FunctionNameCreateContext } from "./TrinoSqlParser.js";
 import { ColumnRefContext } from "./TrinoSqlParser.js";
+import { EmptyColumnContext } from "./TrinoSqlParser.js";
 import { ColumnNameContext } from "./TrinoSqlParser.js";
 import { ColumnNameCreateContext } from "./TrinoSqlParser.js";
 import { QualifiedNameContext } from "./TrinoSqlParser.js";
@@ -1319,6 +1323,18 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitJoinCriteria?: (ctx: JoinCriteriaContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.joinColumnEquality`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitJoinColumnEquality?: (ctx: JoinColumnEqualityContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.joinColumnReference`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitJoinColumnReference?: (ctx: JoinColumnReferenceContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.sampledRelation`.
      * @param ctx the parse tree
@@ -1888,6 +1904,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`.
@@ -2761,6 +2784,12 @@ export declare class TrinoSqlVisitor<Result> extends AbstractParseTreeVisitor<Re
      * @return the visitor result
      */
     visitColumnRef?: (ctx: ColumnRefContext) => Result;
+    /**
+     * Visit a parse tree produced by `TrinoSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitEmptyColumn?: (ctx: EmptyColumnContext) => Result;
     /**
      * Visit a parse tree produced by `TrinoSqlParser.columnName`.
      * @param ctx the parse tree

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

@@ -95,10 +95,22 @@ export declare abstract class BasicSQL<L extends Lexer = Lexer, PRC extends Pars
     private parseWithCache;
     /**
      * Validate input string and return syntax errors if exists.
+     * When input contains multiple statements separated by semicolons
+     * and the initial parse doesn't capture all errors, each statement
+     * is validated independently to collect all errors.
      * @param input source string
      * @returns syntax errors
      */
     validate(input: string): ParseError[];
+    /**
+     * Validate each statement fragment independently and collect all errors.
+     */
+    private validateStatements;
+    /**
+     * Split input into individual statement strings by semicolons.
+     * Handles semicolons inside quoted strings correctly.
+     */
+    private splitStatements;
     /**
      * Get the input string that has been parsed.
      */

package/dist/parser/common/basicSQL.js

@@ -104,13 +104,84 @@ export class BasicSQL {
     }
     /**
      * Validate input string and return syntax errors if exists.
+     * When input contains multiple statements separated by semicolons
+     * and the initial parse doesn't capture all errors, each statement
+     * is validated independently to collect all errors.
      * @param input source string
      * @returns syntax errors
      */
     validate(input) {
         this.parseWithCache(input);
+        if (this._parseErrors.length > 0) {
+            const statements = this.splitStatements(input);
+            if (statements.length > 1) {
+                const splitErrors = this.validateStatements(statements);
+                if (splitErrors.length > this._parseErrors.length) {
+                    this._parseErrors = splitErrors;
+                }
+            }
+        }
         return this._parseErrors;
     }
+    /**
+     * Validate each statement fragment independently and collect all errors.
+     */
+    validateStatements(statements) {
+        const allErrors = [];
+        let lineOffset = 0;
+        for (const statement of statements) {
+            if (!statement.text.trim()) {
+                const newlines = (statement.text.match(/\n/g) || []).length;
+                lineOffset += newlines;
+                continue;
+            }
+            const parser = this.createParser(statement.text);
+            const errors = [];
+            parser.removeErrorListeners();
+            parser.addErrorListener(this.createErrorListener((error) => {
+                errors.push({
+                    startLine: error.startLine + lineOffset,
+                    endLine: error.endLine + lineOffset,
+                    startColumn: error.startColumn,
+                    endColumn: error.endColumn,
+                    message: error.message,
+                });
+            }));
+            parser.errorHandler = new ErrorStrategy();
+            parser.program();
+            allErrors.push(...errors);
+            const newlines = (statement.text.match(/\n/g) || []).length;
+            lineOffset += newlines;
+        }
+        return allErrors;
+    }
+    /**
+     * Split input into individual statement strings by semicolons.
+     * Handles semicolons inside quoted strings correctly.
+     */
+    splitStatements(input) {
+        const statements = [];
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let lastSplit = 0;
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            if (ch === "'" && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+            }
+            else if (ch === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+            }
+            else if (ch === ';' && !inSingleQuote && !inDoubleQuote) {
+                statements.push({ text: input.slice(lastSplit, i + 1), start: lastSplit });
+                lastSplit = i + 1;
+            }
+        }
+        if (lastSplit < input.length) {
+            statements.push({ text: input.slice(lastSplit), start: lastSplit });
+        }
+        return statements;
+    }
     /**
      * Get the input string that has been parsed.
      */

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

@@ -1,17 +1,14 @@
 import type { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
-import { AlterTableContext, ColumnRefContext, ColumnRefCreateContext, CreateTableContext, DeleteContext, DropTableContext, InsertContext, QuerySpecificationContext, QueryStatementContext, SelectAllElementContext, SelectEmptyElementContext, SelectExpressionElementContext, SelectStarElementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, UpdateContext } from '../../lib/generic/GenericSqlParser';
+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;
-    exitColumnRefCreate(ctx: ColumnRefCreateContext): void;
+    exitColumnDefinition(ctx: ColumnDefinitionContext): void;
     exitQuerySpecification(ctx: QuerySpecificationContext): void;
-    exitSelectExpressionElement(ctx: SelectExpressionElementContext): void;
-    exitSelectStarElement(ctx: SelectStarElementContext): void;
-    exitSelectAllElement(ctx: SelectAllElementContext): void;
-    exitSelectEmptyElement(ctx: SelectEmptyElementContext): void;
+    exitSelectItem(ctx: SelectItemContext): void;
     private isSimpleColumnReference;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStatementContext): void;

package/dist/parser/generic/genericEntityCollector.js

@@ -1,4 +1,4 @@
-import { ColumnDefinitionContext, CreateTableStatementContext, SelectExpressionElementContext, } from '../../lib/generic/GenericSqlParser';
+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 {
@@ -19,7 +19,7 @@ export class GenericEntityCollector extends EntityCollector {
     exitColumnRef(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN);
     }
-    exitColumnRefCreate(ctx) {
+    exitColumnDefinition(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
             {
                 attrName: AttrName.colType,
@@ -34,33 +34,25 @@ export class GenericEntityCollector extends EntityCollector {
     exitQuerySpecification(ctx) {
         this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
     }
-    exitSelectExpressionElement(ctx) {
-        const isSimpleColumn = this.isSimpleColumnReference(ctx);
-        this.pushEntity(ctx, EntityContextType.COLUMN, [
-            {
-                attrName: AttrName.alias,
-                endContextList: [SelectExpressionElementContext.name],
-            },
-        ], {
-            declareType: isSimpleColumn
-                ? ColumnDeclareType.LITERAL
-                : ColumnDeclareType.EXPRESSION,
-        });
-    }
-    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,
-        });
+    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();

package/dist/parser/generic/index.js

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

package/dist/parser/mysql/index.js

@@ -26,6 +26,7 @@ export class MySQL extends BasicSQL {
             MySqlParser.RULE_functionNameCreate,
             MySqlParser.RULE_columnName,
             MySqlParser.RULE_columnNamePath,
+            MySqlParser.RULE_columnNamePathAllowEmpty,
             MySqlParser.RULE_columnNameCreate,
             ...this.excludeKeywordRules,
         ]);
@@ -94,6 +95,16 @@ export class MySQL extends BasicSQL {
                     syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
+                case MySqlParser.RULE_columnNamePathAllowEmpty: {
+                    if (candidateRule.ruleList.includes(MySqlParser.RULE_joinSpec) ||
+                        candidateRule.ruleList.includes(MySqlParser.RULE_fromClause) ||
+                        candidateRule.ruleList.includes(MySqlParser.RULE_orderByExpression) ||
+                        candidateRule.ruleList.includes(MySqlParser.RULE_groupByItem) ||
+                        candidateRule.ruleList.includes(MySqlParser.RULE_havingClause)) {
+                        syntaxContextType = EntityContextType.COLUMN;
+                    }
+                    break;
+                }
                 case MySqlParser.RULE_columnNameCreate: {
                     syntaxContextType = EntityContextType.COLUMN_CREATE;
                     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, SelectElementsContext, SelectExpressionElementContext, SelectLiteralColumnNameContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, TableAllColumnsContext, AtomSubQueryTableSourceContext, PureAllColumnsContext, SelectElement_dot_emptyContext } from '../../lib/mysql/MySqlParser';
+import { ColumnCreateTableContext, ColumnNameCreateContext, CopyCreateTableContext, CreateDatabaseContext, CreateFunctionContext, CreateFunctionLoadableContext, CreateViewContext, DatabaseNameContext, DatabaseNameCreateContext, FunctionNameCreateContext, InsertStatementContext, QueryCreateTableContext, SelectElementsContext, SelectExpressionElementContext, SelectLiteralColumnNameContext, SelectStatementContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext, TableAllColumnsContext, AtomSubQueryTableSourceContext, PureAllColumnsContext, SelectElement_dot_emptyContext, ColumnNamePath_dot_emptyContext } from '../../lib/mysql/MySqlParser';
 import type { MySqlParserListener } from '../../lib/mysql/MySqlParserListener';
 import { EntityCollector } from '../common/entityCollector';
 export declare class MySqlEntityCollector extends EntityCollector implements MySqlParserListener {
@@ -19,6 +19,7 @@ export declare class MySqlEntityCollector extends EntityCollector implements MyS
     exitPureAllColumns(ctx: PureAllColumnsContext): void;
     exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
     exitSelectElement_dot_empty(ctx: SelectElement_dot_emptyContext): void;
+    exitColumnNamePath_dot_empty(ctx: ColumnNamePath_dot_emptyContext): void;
     exitSelectExpressionElement(ctx: SelectExpressionElementContext): void;
     /** ===== Statement begin */
     enterSingleStatement(ctx: SingleStatementContext): void;

package/dist/parser/mysql/mysqlEntityCollector.js

@@ -98,6 +98,11 @@ export class MySqlEntityCollector extends EntityCollector {
             declareType: ColumnDeclareType.LITERAL,
         });
     }
+    exitColumnNamePath_dot_empty(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
     exitSelectExpressionElement(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN, [
             {

package/dist/parser/postgresql/index.js

@@ -130,7 +130,8 @@ export class PostgreSQL extends BasicSQL {
                         candidateRule.ruleList.includes(PostgreSqlParser.RULE_whereClause) ||
                         candidateRule.ruleList.includes(PostgreSqlParser.RULE_havingClause) ||
                         candidateRule.ruleList.includes(PostgreSqlParser.RULE_windowClause) ||
-                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_triggerWhen)) {
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_triggerWhen) ||
+                        candidateRule.ruleList.includes(PostgreSqlParser.RULE_joinQual)) {
                         syntaxContextType = EntityContextType.COLUMN;
                     }
                     break;

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, 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 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, ColumnNamePath_dot_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 {
@@ -18,6 +18,7 @@ export declare class PostgreSqlEntityCollector extends EntityCollector implement
     exitTableAllColumns(ctx: TableAllColumnsContext): void;
     exitTarget_empty(ctx: Target_emptyContext): void;
     exitTarget_dot_empty(ctx: Target_dot_emptyContext): void;
+    exitColumnNamePath_dot_empty(ctx: ColumnNamePath_dot_emptyContext): void;
     exitSelectExpressionColumnName(ctx: SelectExpressionColumnNameContext): void;
     exitSelectLiteralColumnName(ctx: SelectLiteralColumnNameContext): void;
     exitProcedureName(ctx: ProcedureNameContext): void;

package/dist/parser/postgresql/postgreEntityCollector.js

@@ -105,6 +105,11 @@ export class PostgreSqlEntityCollector extends EntityCollector {
             declareType: ColumnDeclareType.LITERAL,
         });
     }
+    exitColumnNamePath_dot_empty(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+            declareType: ColumnDeclareType.LITERAL,
+        });
+    }
     exitSelectExpressionColumnName(ctx) {
         this.pushEntity(ctx, EntityContextType.COLUMN, [
             {

package/dist/parser/trino/index.js

@@ -115,9 +115,11 @@ export class TrinoSQL extends BasicSQL {
                         candidateRule.ruleList.includes(TrinoSqlParser.RULE_havingClause) ||
                         candidateRule.ruleList.includes(TrinoSqlParser.RULE_partitionBy) ||
                         candidateRule.ruleList.includes(TrinoSqlParser.RULE_whenClause) ||
-                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_relation)) {
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_relation) ||
+                        candidateRule.ruleList.includes(TrinoSqlParser.RULE_joinCriteria)) {
                         syntaxContextType = EntityContextType.COLUMN;
                     }
+                    break;
                 }
                 default:
                     break;

package/package.json

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