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

package/README.md

@@ -225,7 +225,7 @@ console.log(sqlSlices)
     startLine: 1,
     endLine: 1,
     startColumn: 1,
-    endColumn: 12,
+    endColumn: 13,
     text: 'SHOW TABLES;'
   },
   {
@@ -234,7 +234,7 @@ console.log(sqlSlices)
     startLine: 2,
     endLine: 2,
     startColumn: 1,
-    endColumn: 17,
+    endColumn: 18,
     text: 'SELECT * FROM tb;'
   }
 ]
@@ -244,7 +244,7 @@ console.log(sqlSlices)
 ### Code Completion
 Obtaining code completion information at a specified position in SQL.
 
-Call the `getAllEntities` method on the SQL instance, pass the SQL content and the row and column numbers indicating the position where code completion is desired. The following are some additional explanations about [CaretPosition](#caretposition-of-code-completion).
+Call the `getSuggestionAtCaretPosition` method on the SQL instance, pass the SQL content and the row and column numbers indicating the position where code completion is desired. The following are some additional explanations about [CaretPosition](#caretposition-of-code-completion).
 + **keyword candidates list**
 
     ```javascript
@@ -252,7 +252,7 @@ Call the `getAllEntities` method on the SQL instance, pass the SQL content and t
   
     const flink = new FlinkSQL();
     const sql = 'CREATE ';
-    const pos = { lineNumber: 1, column: 16 }; // the end position
+    const pos = { lineNumber: 1, column: sql.length + 1 }; // the end position
     const keywords = flink.getSuggestionAtCaretPosition(sql, pos)?.keywords;
   
     console.log(keywords);
@@ -296,10 +296,10 @@ Call the `getAllEntities` method on the SQL instance, pass the SQL content and t
           {
             text: 'tb',
             startIndex: 14,
-            stopIndex: 15,
+            endIndex: 15,
             line: 1,
             startColumn: 15,
-            stopColumn: 16
+            endColumn: 17
           }
         ]
       },
@@ -309,10 +309,10 @@ Call the `getAllEntities` method on the SQL instance, pass the SQL content and t
           {
             text: 'tb',
             startIndex: 14,
-            stopIndex: 15,
+            endIndex: 15,
             line: 1,
             startColumn: 15,
-            stopColumn: 16
+            endColumn: 17
           }
         ]
       }

package/dist/lib/generic/GenericSqlListener.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 listener for a parse tree produced by
@@ -300,15 +307,53 @@ export declare class GenericSqlListener implements ParseTreeListener {
      */
     exitSetQuantifier?: (ctx: SetQuantifierContext) => void;
     /**
-     * Enter a parse tree produced by `GenericSqlParser.selectItem`.
+     * Enter a parse tree produced by the `selectExpressionElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
      * @param ctx the parse tree
      */
-    enterSelectItem?: (ctx: SelectItemContext) => void;
+    enterSelectExpressionElement?: (ctx: SelectExpressionElementContext) => void;
     /**
-     * Exit a parse tree produced by `GenericSqlParser.selectItem`.
+     * Exit a parse tree produced by the `selectExpressionElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
      * @param ctx the parse tree
      */
-    exitSelectItem?: (ctx: SelectItemContext) => void;
+    exitSelectExpressionElement?: (ctx: SelectExpressionElementContext) => void;
+    /**
+     * Enter a parse tree produced by the `selectStarElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     */
+    enterSelectStarElement?: (ctx: SelectStarElementContext) => void;
+    /**
+     * Exit a parse tree produced by the `selectStarElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     */
+    exitSelectStarElement?: (ctx: SelectStarElementContext) => void;
+    /**
+     * Enter a parse tree produced by the `selectAllElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     */
+    enterSelectAllElement?: (ctx: SelectAllElementContext) => void;
+    /**
+     * Exit a parse tree produced by the `selectAllElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     */
+    exitSelectAllElement?: (ctx: SelectAllElementContext) => void;
+    /**
+     * Enter a parse tree produced by the `selectEmptyElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     */
+    enterSelectEmptyElement?: (ctx: SelectEmptyElementContext) => void;
+    /**
+     * Exit a parse tree produced by the `selectEmptyElement`
+     * labeled alternative in `GenericSqlParser.selectItem`.
+     * @param ctx the parse tree
+     */
+    exitSelectEmptyElement?: (ctx: SelectEmptyElementContext) => void;
     /**
      * Enter a parse tree produced by `GenericSqlParser.fromClause`.
      * @param ctx the parse tree
@@ -527,6 +572,16 @@ export declare class GenericSqlListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitColumnDefinition?: (ctx: ColumnDefinitionContext) => void;
+    /**
+     * Enter a parse tree produced by `GenericSqlParser.columnRefCreate`.
+     * @param ctx the parse tree
+     */
+    enterColumnRefCreate?: (ctx: ColumnRefCreateContext) => void;
+    /**
+     * Exit a parse tree produced by `GenericSqlParser.columnRefCreate`.
+     * @param ctx the parse tree
+     */
+    exitColumnRefCreate?: (ctx: ColumnRefCreateContext) => void;
     /**
      * Enter a parse tree produced by `GenericSqlParser.tableConstraint`.
      * @param ctx the parse tree
@@ -1063,6 +1118,26 @@ export declare class GenericSqlListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitColumnRef?: (ctx: ColumnRefContext) => void;
+    /**
+     * Enter a parse tree produced by `GenericSqlParser.columnName`.
+     * @param ctx the parse tree
+     */
+    enterColumnName?: (ctx: ColumnNameContext) => void;
+    /**
+     * Exit a parse tree produced by `GenericSqlParser.columnName`.
+     * @param ctx the parse tree
+     */
+    exitColumnName?: (ctx: ColumnNameContext) => void;
+    /**
+     * Enter a parse tree produced by `GenericSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     */
+    enterEmptyColumn?: (ctx: EmptyColumnContext) => void;
+    /**
+     * Exit a parse tree produced by `GenericSqlParser.emptyColumn`.
+     * @param ctx the parse tree
+     */
+    exitEmptyColumn?: (ctx: EmptyColumnContext) => void;
     /**
      * Enter a parse tree produced by `GenericSqlParser.tableName`.
      * @param ctx the parse tree
@@ -1083,6 +1158,16 @@ export declare class GenericSqlListener implements ParseTreeListener {
      * @param ctx the parse tree
      */
     exitTableNameCreate?: (ctx: TableNameCreateContext) => void;
+    /**
+     * Enter a parse tree produced by `GenericSqlParser.functionName`.
+     * @param ctx the parse tree
+     */
+    enterFunctionName?: (ctx: FunctionNameContext) => void;
+    /**
+     * Exit a parse tree produced by `GenericSqlParser.functionName`.
+     * @param ctx the parse tree
+     */
+    exitFunctionName?: (ctx: FunctionNameContext) => void;
     /**
      * Enter a parse tree produced by `GenericSqlParser.nonReserved`.
      * @param ctx the parse tree

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

@@ -159,28 +159,32 @@ export declare class GenericSqlParser extends SQLParserBase {
     static readonly RULE_createTableStatement = 30;
     static readonly RULE_tableElement = 31;
     static readonly RULE_columnDefinition = 32;
-    static readonly RULE_tableConstraint = 33;
-    static readonly RULE_alterTableStatement = 34;
-    static readonly RULE_dropTableStatement = 35;
-    static readonly RULE_expression = 36;
-    static readonly RULE_booleanExpression = 37;
-    static readonly RULE_predicatedExpression = 38;
-    static readonly RULE_predicate = 39;
-    static readonly RULE_comparisonOperator = 40;
-    static readonly RULE_valueExpression = 41;
-    static readonly RULE_primaryExpression = 42;
-    static readonly RULE_whenClause = 43;
-    static readonly RULE_subqueryExpression = 44;
-    static readonly RULE_dataType = 45;
-    static readonly RULE_properties = 46;
-    static readonly RULE_property = 47;
-    static readonly RULE_literal = 48;
-    static readonly RULE_identifier = 49;
-    static readonly RULE_qualifiedName = 50;
-    static readonly RULE_columnRef = 51;
-    static readonly RULE_tableName = 52;
-    static readonly RULE_tableNameCreate = 53;
-    static readonly RULE_nonReserved = 54;
+    static readonly RULE_columnRefCreate = 33;
+    static readonly RULE_tableConstraint = 34;
+    static readonly RULE_alterTableStatement = 35;
+    static readonly RULE_dropTableStatement = 36;
+    static readonly RULE_expression = 37;
+    static readonly RULE_booleanExpression = 38;
+    static readonly RULE_predicatedExpression = 39;
+    static readonly RULE_predicate = 40;
+    static readonly RULE_comparisonOperator = 41;
+    static readonly RULE_valueExpression = 42;
+    static readonly RULE_primaryExpression = 43;
+    static readonly RULE_whenClause = 44;
+    static readonly RULE_subqueryExpression = 45;
+    static readonly RULE_dataType = 46;
+    static readonly RULE_properties = 47;
+    static readonly RULE_property = 48;
+    static readonly RULE_literal = 49;
+    static readonly RULE_identifier = 50;
+    static readonly RULE_qualifiedName = 51;
+    static readonly RULE_columnRef = 52;
+    static readonly RULE_columnName = 53;
+    static readonly RULE_emptyColumn = 54;
+    static readonly RULE_tableName = 55;
+    static readonly RULE_tableNameCreate = 56;
+    static readonly RULE_functionName = 57;
+    static readonly RULE_nonReserved = 58;
     static readonly literalNames: (string | null)[];
     static readonly symbolicNames: (string | null)[];
     static readonly ruleNames: string[];
@@ -225,6 +229,7 @@ export declare class GenericSqlParser extends SQLParserBase {
     createTableStatement(): CreateTableStatementContext;
     tableElement(): TableElementContext;
     columnDefinition(): ColumnDefinitionContext;
+    columnRefCreate(): ColumnRefCreateContext;
     tableConstraint(): TableConstraintContext;
     alterTableStatement(): AlterTableStatementContext;
     dropTableStatement(): DropTableStatementContext;
@@ -246,13 +251,18 @@ export declare class GenericSqlParser extends SQLParserBase {
     identifier(): IdentifierContext;
     qualifiedName(): QualifiedNameContext;
     columnRef(): ColumnRefContext;
+    columnName(): ColumnNameContext;
+    emptyColumn(): EmptyColumnContext;
     tableName(): TableNameContext;
     tableNameCreate(): TableNameCreateContext;
+    functionName(): FunctionNameContext;
     nonReserved(): NonReservedContext;
     sempred(localContext: antlr.RuleContext | null, ruleIndex: number, predIndex: number): boolean;
+    private selectItem_sempred;
     private relation_sempred;
     private booleanExpression_sempred;
     private valueExpression_sempred;
+    private columnRef_sempred;
     static readonly _serializedATN: number[];
     private static __ATN;
     static get _ATN(): antlr.ATN;
@@ -443,14 +453,38 @@ export declare class SetQuantifierContext extends antlr.ParserRuleContext {
     accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
 }
 export declare class SelectItemContext extends antlr.ParserRuleContext {
-    _alias?: IdentifierContext;
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    expression(): ExpressionContext | null;
+    get ruleIndex(): number;
+    copyFrom(ctx: SelectItemContext): void;
+}
+export declare class SelectExpressionElementContext extends SelectItemContext {
+    _alias?: IdentifierContext;
+    constructor(ctx: SelectItemContext);
+    expression(): ExpressionContext;
     identifier(): IdentifierContext | null;
     KW_AS(): antlr.TerminalNode | null;
-    qualifiedName(): QualifiedNameContext | null;
-    ASTERISK(): antlr.TerminalNode | null;
-    get ruleIndex(): number;
+    enterRule(listener: GenericSqlListener): void;
+    exitRule(listener: GenericSqlListener): void;
+    accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
+}
+export declare class SelectEmptyElementContext extends SelectItemContext {
+    constructor(ctx: SelectItemContext);
+    emptyColumn(): EmptyColumnContext;
+    enterRule(listener: GenericSqlListener): void;
+    exitRule(listener: GenericSqlListener): void;
+    accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
+}
+export declare class SelectStarElementContext extends SelectItemContext {
+    constructor(ctx: SelectItemContext);
+    qualifiedName(): QualifiedNameContext;
+    ASTERISK(): antlr.TerminalNode;
+    enterRule(listener: GenericSqlListener): void;
+    exitRule(listener: GenericSqlListener): void;
+    accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
+}
+export declare class SelectAllElementContext extends SelectItemContext {
+    constructor(ctx: SelectItemContext);
+    ASTERISK(): antlr.TerminalNode;
     enterRule(listener: GenericSqlListener): void;
     exitRule(listener: GenericSqlListener): void;
     accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
@@ -538,7 +572,8 @@ export declare class TableNameRelationContext extends RelationPrimaryContext {
 export declare class WhereClauseContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     KW_WHERE(): antlr.TerminalNode;
-    expression(): ExpressionContext;
+    expression(): ExpressionContext | null;
+    emptyColumn(): EmptyColumnContext | null;
     get ruleIndex(): number;
     enterRule(listener: GenericSqlListener): void;
     exitRule(listener: GenericSqlListener): void;
@@ -559,7 +594,8 @@ export declare class GroupByClauseContext extends antlr.ParserRuleContext {
 export declare class HavingClauseContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     KW_HAVING(): antlr.TerminalNode;
-    expression(): ExpressionContext;
+    expression(): ExpressionContext | null;
+    emptyColumn(): EmptyColumnContext | null;
     get ruleIndex(): number;
     enterRule(listener: GenericSqlListener): void;
     exitRule(listener: GenericSqlListener): void;
@@ -686,8 +722,9 @@ export declare class TableElementContext extends antlr.ParserRuleContext {
     accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
 }
 export declare class ColumnDefinitionContext extends antlr.ParserRuleContext {
+    _colType?: DataTypeContext;
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    columnRef(): ColumnRefContext;
+    columnRefCreate(): ColumnRefCreateContext;
     dataType(): DataTypeContext;
     KW_NOT(): antlr.TerminalNode | null;
     KW_NULL(): antlr.TerminalNode | null;
@@ -700,6 +737,14 @@ export declare class ColumnDefinitionContext extends antlr.ParserRuleContext {
     exitRule(listener: GenericSqlListener): void;
     accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
 }
+export declare class ColumnRefCreateContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    identifier(): IdentifierContext;
+    get ruleIndex(): number;
+    enterRule(listener: GenericSqlListener): void;
+    exitRule(listener: GenericSqlListener): void;
+    accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
+}
 export declare class TableConstraintContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     KW_PRIMARY(): antlr.TerminalNode | null;
@@ -992,7 +1037,7 @@ export declare class CoalesceExpressionContext extends PrimaryExpressionContext
 }
 export declare class ColumnReferenceContext extends PrimaryExpressionContext {
     constructor(ctx: PrimaryExpressionContext);
-    qualifiedName(): QualifiedNameContext;
+    columnName(): ColumnNameContext;
     enterRule(listener: GenericSqlListener): void;
     exitRule(listener: GenericSqlListener): void;
     accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
@@ -1014,7 +1059,7 @@ export declare class ExistsExpressionContext extends PrimaryExpressionContext {
 }
 export declare class FunctionCallContext extends PrimaryExpressionContext {
     constructor(ctx: PrimaryExpressionContext);
-    qualifiedName(): QualifiedNameContext;
+    functionName(): FunctionNameContext;
     expression(): ExpressionContext[];
     expression(i: number): ExpressionContext | null;
     setQuantifier(): SetQuantifierContext | null;
@@ -1212,7 +1257,23 @@ export declare class QualifiedNameContext extends antlr.ParserRuleContext {
 }
 export declare class ColumnRefContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
-    identifier(): IdentifierContext;
+    identifier(): IdentifierContext | null;
+    emptyColumn(): EmptyColumnContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: GenericSqlListener): void;
+    exitRule(listener: GenericSqlListener): void;
+    accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
+}
+export declare class ColumnNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    qualifiedName(): QualifiedNameContext;
+    get ruleIndex(): number;
+    enterRule(listener: GenericSqlListener): void;
+    exitRule(listener: GenericSqlListener): void;
+    accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
+}
+export declare class EmptyColumnContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     get ruleIndex(): number;
     enterRule(listener: GenericSqlListener): void;
     exitRule(listener: GenericSqlListener): void;
@@ -1234,6 +1295,14 @@ export declare class TableNameCreateContext extends antlr.ParserRuleContext {
     exitRule(listener: GenericSqlListener): void;
     accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
 }
+export declare class FunctionNameContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    qualifiedName(): QualifiedNameContext;
+    get ruleIndex(): number;
+    enterRule(listener: GenericSqlListener): void;
+    exitRule(listener: GenericSqlListener): void;
+    accept<Result>(visitor: GenericSqlVisitor<Result>): Result | null;
+}
 export declare class NonReservedContext extends antlr.ParserRuleContext {
     constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
     KW_ADD(): antlr.TerminalNode | null;