dt-sql-parser 4.0.0-ng.2 → 4.0.1

package/dist/parser/spark/sparkEntityCollector.js

@@ -0,0 +1,96 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class SparkEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitNamespaceName(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitNamespaceNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+    }
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE);
+    }
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+    }
+    exitViewName(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW);
+    }
+    exitViewNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+    }
+    exitFunctionNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.FUNCTION_CREATE);
+    }
+    exitColumnNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateTableLike(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTableLike(ctx) {
+        this.popStmt();
+    }
+    enterReplaceTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitReplaceTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateView(ctx) {
+        this.popStmt();
+    }
+    enterCreateTempViewUsing(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateTempViewUsing(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsertFromQuery(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertFromQuery(ctx) {
+        this.popStmt();
+    }
+    enterMultipleInsert(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitMultipleInsert(ctx) {
+        this.popStmt();
+    }
+    enterCreateNamespace(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateNamespace(ctx) {
+        this.popStmt();
+    }
+    enterCreateFunction(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_FUNCTION_STMT);
+    }
+    exitCreateFunction(ctx) {
+        this.popStmt();
+    }
+}

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

@@ -0,0 +1,6 @@
+import { SingleStatementContext } from '../../lib/spark/SparkSqlParser';
+import { SparkSqlParserListener } from '../../lib/spark/SparkSqlParserListener';
+import { SplitListener } from '../common/splitListener';
+export declare class SparkSqlSplitListener extends SplitListener<SingleStatementContext> implements SparkSqlParserListener {
+    exitSingleStatement(ctx: SingleStatementContext): void;
+}

package/dist/parser/spark/sparkSplitListener.js

@@ -0,0 +1,6 @@
+import { SplitListener } from '../common/splitListener';
+export class SparkSqlSplitListener extends SplitListener {
+    exitSingleStatement(ctx) {
+        this._statementsContext.push(ctx);
+    }
+}

package/dist/parser/trino/index.d.ts

@@ -0,0 +1,17 @@
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { CandidatesCollection } from 'antlr4-c3';
+import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
+import { TrinoSqlParser, ProgramContext } from '../../lib/trino/TrinoSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions } from '../common/types';
+import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { TrinoEntityCollector } from './trinoEntityCollector';
+export { TrinoSqlSplitListener, TrinoEntityCollector };
+export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
+    protected createLexerFromCharStream(charStreams: CharStream): TrinoSqlLexer;
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): TrinoSqlParser;
+    protected get splitListener(): TrinoSqlSplitListener;
+    protected createEntityCollector(input: string, caretTokenIndex?: number): TrinoEntityCollector;
+    protected preferredRules: Set<number>;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
+}

package/dist/parser/{trinosql.js → trino/index.js}

@@ -1,8 +1,11 @@
-import { TrinoSqlLexer } from '../lib/trinosql/TrinoSqlLexer';
-import { TrinoSqlParser, } from '../lib/trinosql/TrinoSqlParser';
-import BasicParser from './common/basicParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-export default class TrinoSQL extends BasicParser {
+import { TrinoSqlLexer } from '../../lib/trino/TrinoSqlLexer';
+import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType } from '../common/types';
+import { TrinoSqlSplitListener } from './trinoSplitListener';
+import { TrinoEntityCollector } from './trinoEntityCollector';
+export { TrinoSqlSplitListener, TrinoEntityCollector };
+export class TrinoSQL extends BasicSQL {
     constructor() {
         super(...arguments);
         this.preferredRules = new Set([
@@ -20,16 +23,17 @@ export default class TrinoSQL extends BasicParser {
         ]);
     }
     createLexerFromCharStream(charStreams) {
-        const lexer = new TrinoSqlLexer(charStreams);
-        return lexer;
+        return new TrinoSqlLexer(charStreams);
     }
     createParserFromTokenStream(tokenStream) {
-        const parser = new TrinoSqlParser(tokenStream);
-        return parser;
+        return new TrinoSqlParser(tokenStream);
     }
     get splitListener() {
         return new TrinoSqlSplitListener();
     }
+    createEntityCollector(input, caretTokenIndex) {
+        return new TrinoEntityCollector(input, caretTokenIndex);
+    }
     processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
         const originalSyntaxSuggestions = [];
         const keywords = [];
@@ -37,46 +41,46 @@ export default class TrinoSQL extends BasicParser {
             const [ruleType, candidateRule] = candidate;
             const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
             const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
-            let syntaxContextType;
+            let syntaxContextType = void 0;
             switch (ruleType) {
                 case TrinoSqlParser.RULE_catalogName: {
-                    syntaxContextType = SyntaxContextType.CATALOG;
+                    syntaxContextType = EntityContextType.CATALOG;
                     break;
                 }
                 case TrinoSqlParser.RULE_schemaName: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
+                    syntaxContextType = EntityContextType.DATABASE;
                     break;
                 }
                 case TrinoSqlParser.RULE_schemaNameCreate: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
+                    syntaxContextType = EntityContextType.DATABASE_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_tableName: {
-                    syntaxContextType = SyntaxContextType.TABLE;
+                    syntaxContextType = EntityContextType.TABLE;
                     break;
                 }
                 case TrinoSqlParser.RULE_tableNameCreate: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_viewName: {
-                    syntaxContextType = SyntaxContextType.VIEW;
+                    syntaxContextType = EntityContextType.VIEW;
                     break;
                 }
                 case TrinoSqlParser.RULE_viewNameCreate: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
+                    syntaxContextType = EntityContextType.VIEW_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_functionName: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
+                    syntaxContextType = EntityContextType.FUNCTION;
                     break;
                 }
                 case TrinoSqlParser.RULE_columnNameCreate: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
+                    syntaxContextType = EntityContextType.COLUMN_CREATE;
                     break;
                 }
                 case TrinoSqlParser.RULE_columnName: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
+                    syntaxContextType = EntityContextType.COLUMN;
                     break;
                 }
                 default:
@@ -92,7 +96,7 @@ export default class TrinoSQL extends BasicParser {
         for (let candidate of candidates.tokens) {
             const symbolicName = this._parser.vocabulary.getSymbolicName(candidate[0]);
             const displayName = this._parser.vocabulary.getDisplayName(candidate[0]);
-            if (symbolicName && symbolicName.startsWith('KW_')) {
+            if (displayName && symbolicName && symbolicName.startsWith('KW_')) {
                 const keyword = displayName.startsWith("'") && displayName.endsWith("'")
                     ? displayName.slice(1, -1)
                     : displayName;
@@ -105,18 +109,3 @@ export default class TrinoSQL extends BasicParser {
         };
     }
 }
-export class TrinoSqlSplitListener {
-    constructor() {
-        this._statementsContext = [];
-        this.exitSingleStatement = (ctx) => {
-            this._statementsContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementsContext;
-    }
-}

package/dist/parser/trino/trinoEntityCollector.d.ts

@@ -0,0 +1,30 @@
+import type { ColumnNameCreateContext, CreateMaterializedViewContext, CreateSchemaContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, InsertIntoContext, QueryStatementContext, SchemaNameContext, SchemaNameCreateContext, SingleStatementContext, TableNameContext, TableNameCreateContext, ViewNameContext, ViewNameCreateContext } from '../../lib/trino/TrinoSqlParser';
+import type { TrinoSqlListener } from '../../lib/trino/TrinoSqlListener';
+import { EntityCollector } from '../common/entityCollector';
+export declare class TrinoEntityCollector extends EntityCollector implements TrinoSqlListener {
+    /** ====== Entity Begin */
+    exitSchemaName(ctx: SchemaNameContext): void;
+    exitSchemaNameCreate(ctx: SchemaNameCreateContext): void;
+    exitTableName(ctx: TableNameContext): void;
+    exitTableNameCreate(ctx: TableNameCreateContext): void;
+    exitViewName(ctx: ViewNameContext): void;
+    exitViewNameCreate(ctx: ViewNameCreateContext): void;
+    exitColumnNameCreate(ctx: ColumnNameCreateContext): void;
+    /** ===== Statement begin */
+    enterSingleStatement(ctx: SingleStatementContext): void;
+    exitSingleStatement(ctx: SingleStatementContext): void;
+    enterCreateSchema(ctx: CreateSchemaContext): void;
+    exitCreateSchema(ctx: CreateSchemaContext): void;
+    enterCreateTableAsSelect(ctx: CreateTableAsSelectContext): void;
+    exitCreateTableAsSelect(ctx: CreateTableAsSelectContext): void;
+    enterCreateTable(ctx: CreateTableContext): void;
+    exitCreateTable(ctx: CreateTableContext): void;
+    enterCreateView(ctx: CreateViewContext): void;
+    exitCreateView(ctx: CreateViewContext): void;
+    enterCreateMaterializedView(ctx: CreateMaterializedViewContext): void;
+    exitCreateMaterializedView(ctx: CreateMaterializedViewContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterInsertInto(ctx: InsertIntoContext): void;
+    exitInsertInto(ctx: InsertIntoContext): void;
+}

package/dist/parser/trino/trinoEntityCollector.js

@@ -0,0 +1,75 @@
+import { EntityContextType } from '../common/types';
+import { StmtContextType, EntityCollector } from '../common/entityCollector';
+export class TrinoEntityCollector extends EntityCollector {
+    /** ====== Entity Begin */
+    exitSchemaName(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE);
+    }
+    exitSchemaNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
+    }
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE);
+    }
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+    }
+    exitViewName(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW);
+    }
+    exitViewNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+    }
+    exitColumnNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+    }
+    /** ===== Statement begin */
+    enterSingleStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitSingleStatement(ctx) {
+        this.popStmt();
+    }
+    enterCreateSchema(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_DATABASE_STMT);
+    }
+    exitCreateSchema(ctx) {
+        this.popStmt();
+    }
+    enterCreateTableAsSelect(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTableAsSelect(ctx) {
+        this.popStmt();
+    }
+    enterCreateTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_TABLE_STMT);
+    }
+    exitCreateTable(ctx) {
+        this.popStmt();
+    }
+    enterCreateView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateView(ctx) {
+        this.popStmt();
+    }
+    enterCreateMaterializedView(ctx) {
+        this.pushStmt(ctx, StmtContextType.CREATE_VIEW_STMT);
+    }
+    exitCreateMaterializedView(ctx) {
+        this.popStmt();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsertInto(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsertInto(ctx) {
+        this.popStmt();
+    }
+}

package/dist/parser/trino/trinoSplitListener.d.ts

@@ -0,0 +1,6 @@
+import { SingleStatementContext } from '../../lib/trino/TrinoSqlParser';
+import { TrinoSqlListener } from '../../lib/trino/TrinoSqlListener';
+import { SplitListener } from '../common/splitListener';
+export declare class TrinoSqlSplitListener extends SplitListener<SingleStatementContext> implements TrinoSqlListener {
+    exitSingleStatement(ctx: SingleStatementContext): void;
+}

package/dist/parser/trino/trinoSplitListener.js

@@ -0,0 +1,6 @@
+import { SplitListener } from '../common/splitListener';
+export class TrinoSqlSplitListener extends SplitListener {
+    exitSingleStatement(ctx) {
+        this._statementsContext.push(ctx);
+    }
+}

package/package.json

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

package/dist/lib/plsql/PlSqlBaseLexer.d.ts

@@ -1,5 +0,0 @@
-import { Lexer } from "antlr4ng";
-export default abstract class PlSqlBaseLexer extends Lexer {
-    _interp: any;
-    IsNewlineAtPos(pos: number): boolean;
-}

package/dist/lib/plsql/PlSqlBaseLexer.js

@@ -1,7 +0,0 @@
-import { Lexer } from "antlr4ng";
-export default class PlSqlBaseLexer extends Lexer {
-    IsNewlineAtPos(pos) {
-        const la = this._input.LA(pos);
-        return la == -1 || String.fromCharCode(la) == '\n';
-    }
-}

package/dist/lib/plsql/PlSqlBaseParser.d.ts

@@ -1,10 +0,0 @@
-import { Parser, TokenStream } from "antlr4ng";
-export default abstract class PlSqlBaseParser extends Parser {
-    private _isVersion10;
-    private _isVersion12;
-    constructor(input: TokenStream);
-    isVersion10(): boolean;
-    isVersion12(): boolean;
-    setVersion10(value: boolean): void;
-    setVersion12(value: boolean): void;
-}

package/dist/lib/plsql/PlSqlBaseParser.js

@@ -1,22 +0,0 @@
-import { Parser } from "antlr4ng";
-export default class PlSqlBaseParser extends Parser {
-    constructor(input) {
-        super(input);
-        this._isVersion10 = false;
-        this._isVersion12 = true;
-        this._isVersion10 = false;
-        this._isVersion12 = true;
-    }
-    isVersion10() {
-        return this._isVersion10;
-    }
-    isVersion12() {
-        return this._isVersion12;
-    }
-    setVersion10(value) {
-        this._isVersion10 = value;
-    }
-    setVersion12(value) {
-        this._isVersion12 = value;
-    }
-}