dt-sql-parser 4.5.0-beta.0 → 4.5.0-beta.2

package/dist/lib/index.d.ts

@@ -12,3 +12,5 @@ export { TrinoSqlListener } from './trino/TrinoSqlListener';
 export { TrinoSqlVisitor } from './trino/TrinoSqlVisitor';
 export { ImpalaSqlParserListener } from './impala/ImpalaSqlParserListener';
 export { ImpalaSqlParserVisitor } from './impala/ImpalaSqlParserVisitor';
+export { GenericSqlListener } from './generic/GenericSqlListener';
+export { GenericSqlVisitor } from './generic/GenericSqlVisitor';

package/dist/lib/index.js

@@ -12,3 +12,5 @@ export { TrinoSqlListener } from './trino/TrinoSqlListener';
 export { TrinoSqlVisitor } from './trino/TrinoSqlVisitor';
 export { ImpalaSqlParserListener } from './impala/ImpalaSqlParserListener';
 export { ImpalaSqlParserVisitor } from './impala/ImpalaSqlParserVisitor';
+export { GenericSqlListener } from './generic/GenericSqlListener';
+export { GenericSqlVisitor } from './generic/GenericSqlVisitor';

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

@@ -0,0 +1,29 @@
+import type { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
+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;
+    exitColumnDefinition(ctx: ColumnDefinitionContext): void;
+    exitQuerySpecification(ctx: QuerySpecificationContext): void;
+    exitSelectItem(ctx: SelectItemContext): void;
+    /** ===== Statement begin */
+    enterSingleStatement(ctx: SingleStatementContext): void;
+    exitSingleStatement(ctx: SingleStatementContext): void;
+    enterCreateTable(ctx: CreateTableContext): void;
+    exitCreateTable(ctx: CreateTableContext): void;
+    enterQueryStatement(ctx: QueryStatementContext): void;
+    exitQueryStatement(ctx: QueryStatementContext): void;
+    enterInsert(ctx: InsertContext): void;
+    exitInsert(ctx: InsertContext): void;
+    enterUpdate(ctx: UpdateContext): void;
+    exitUpdate(ctx: UpdateContext): void;
+    enterDelete(ctx: DeleteContext): void;
+    exitDelete(ctx: DeleteContext): void;
+    enterAlterTable(ctx: AlterTableContext): void;
+    exitAlterTable(ctx: AlterTableContext): void;
+    enterDropTable(ctx: DropTableContext): void;
+    exitDropTable(ctx: DropTableContext): void;
+}

package/dist/parser/generic/genericEntityCollector.js

@@ -0,0 +1,103 @@
+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 {
+    /** ====== Entity Begin */
+    exitTableName(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE, [], {
+            declareType: TableDeclareType.LITERAL,
+        });
+    }
+    exitTableNameCreate(ctx) {
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableStatementContext.name],
+            },
+        ]);
+    }
+    exitColumnRef(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN);
+    }
+    exitColumnDefinition(ctx) {
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.colType,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+            {
+                attrName: AttrName.comment,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+        ]);
+    }
+    exitQuerySpecification(ctx) {
+        this.pushEntity(ctx, EntityContextType.QUERY_RESULT);
+    }
+    exitSelectItem(ctx) {
+        if (ctx.ASTERISK()) {
+            this.pushEntity(ctx, EntityContextType.COLUMN, [], {
+                declareType: ColumnDeclareType.ALL,
+            });
+        }
+        else {
+            this.pushEntity(ctx, EntityContextType.COLUMN, [
+                {
+                    attrName: AttrName.alias,
+                    endContextList: [SelectItemContext.name],
+                },
+            ], {
+                declareType: ColumnDeclareType.EXPRESSION,
+            });
+        }
+    }
+    /** ===== 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();
+    }
+    enterQueryStatement(ctx) {
+        this.pushStmt(ctx, StmtContextType.SELECT_STMT);
+    }
+    exitQueryStatement(ctx) {
+        this.popStmt();
+    }
+    enterInsert(ctx) {
+        this.pushStmt(ctx, StmtContextType.INSERT_STMT);
+    }
+    exitInsert(ctx) {
+        this.popStmt();
+    }
+    enterUpdate(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitUpdate(ctx) {
+        this.popStmt();
+    }
+    enterDelete(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitDelete(ctx) {
+        this.popStmt();
+    }
+    enterAlterTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.ALTER_TABLE_STMT);
+    }
+    exitAlterTable(ctx) {
+        this.popStmt();
+    }
+    enterDropTable(ctx) {
+        this.pushStmt(ctx, StmtContextType.COMMON_STMT);
+    }
+    exitDropTable(ctx) {
+        this.popStmt();
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Parser, Token } from 'antlr4ng';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export declare class GenericErrorListener extends ParseErrorListener {
+    private objectNames;
+    getExpectedText(parser: Parser, token: Token): string;
+}

package/dist/parser/generic/genericErrorListener.js

@@ -0,0 +1,56 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export class GenericErrorListener extends ParseErrorListener {
+    constructor() {
+        super(...arguments);
+        this.objectNames = new Map([
+            [GenericSqlParser.RULE_tableName, 'table'],
+            [GenericSqlParser.RULE_tableNameCreate, 'table'],
+            [GenericSqlParser.RULE_columnRef, 'column'],
+        ]);
+    }
+    getExpectedText(parser, token) {
+        var _a;
+        let expectedText = '';
+        const input = this.parserContext.getParsedInput();
+        let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
+        while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
+            currentContext = currentContext.parent;
+        }
+        const parserInfo = this.parserContext.getMinimumParserInfo(input, token.tokenIndex, currentContext);
+        if (!parserInfo)
+            return '';
+        const { parser: c3Parser, newTokenIndex, parseTree: c3Context } = parserInfo;
+        const core = new CodeCompletionCore(c3Parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(newTokenIndex, c3Context);
+        if (candidates.rules.size) {
+            const result = [];
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case GenericSqlParser.RULE_tableName:
+                    case GenericSqlParser.RULE_columnRef: {
+                        if (name && !result.includes(`{existing}${name}`)) {
+                            result.push(`{existing}${name}`);
+                        }
+                        break;
+                    }
+                    case GenericSqlParser.RULE_tableNameCreate: {
+                        if (name && !result.includes(`{new}${name}`)) {
+                            result.push(`{new}${name}`);
+                        }
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { GenericSqlListener } from '../../lib/generic/GenericSqlListener';
+import { StatementsContext } from '../../lib/generic/GenericSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+declare class GenericSemanticContextCollector extends SemanticContextCollector implements GenericSqlListener {
+    getWhiteSpaceRuleType(): number;
+    getStatementRuleType(): number;
+    enterStatements(ctx: StatementsContext): void;
+}
+export { GenericSemanticContextCollector };

package/dist/parser/generic/genericSemanticContextCollector.js

@@ -0,0 +1,14 @@
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import SemanticContextCollector from '../common/semanticContextCollector';
+class GenericSemanticContextCollector extends SemanticContextCollector {
+    getWhiteSpaceRuleType() {
+        return GenericSqlParser.WHITE_SPACE;
+    }
+    getStatementRuleType() {
+        return GenericSqlParser.RULE_statements;
+    }
+    enterStatements(ctx) {
+        this.visitStatement(ctx);
+    }
+}
+export { GenericSemanticContextCollector };

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

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

package/dist/parser/generic/genericSplitListener.js

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

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

@@ -0,0 +1,33 @@
+import { CandidatesCollection } from 'antlr4-c3';
+import { CharStream, CommonTokenStream, Token } from 'antlr4ng';
+import { GenericSqlLexer } from '../../lib/generic/GenericSqlLexer';
+import { GenericSqlParser, ProgramContext } from '../../lib/generic/GenericSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { Suggestions, CaretPosition, SemanticCollectOptions } from '../common/types';
+import { ErrorListener, ParseError } from '../common/parseErrorListener';
+import { GenericEntityCollector } from './genericEntityCollector';
+import { GenericErrorListener } from './genericErrorListener';
+import { GenericSplitListener } from './genericSplitListener';
+import { GenericSemanticContextCollector } from './genericSemanticContextCollector';
+export { GenericEntityCollector, GenericSplitListener };
+export interface GenericSQLOptions {
+    /** Enable or disable diagnostics (parse error collection). Defaults to true. */
+    diagnostics?: boolean;
+}
+export declare class GenericSQL extends BasicSQL<GenericSqlLexer, ProgramContext, GenericSqlParser> {
+    private _diagnostics;
+    constructor(options?: GenericSQLOptions);
+    protected createLexerFromCharStream(charStreams: CharStream): GenericSqlLexer;
+    validate(input: string): ParseError[];
+    protected createParserFromTokenStream(tokenStream: CommonTokenStream): GenericSqlParser;
+    /**
+     * The rules that keywords you don't want to be suggested.
+     */
+    protected excludeKeywordRules: Set<number>;
+    protected preferredRules: Set<number>;
+    protected get splitListener(): GenericSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): GenericErrorListener;
+    protected createEntityCollector(input: string, allTokens?: Token[], caretTokenIndex?: number): GenericEntityCollector;
+    protected createSemanticContextCollector(input: string, caretPosition: CaretPosition, allTokens: Token[], options?: SemanticCollectOptions): GenericSemanticContextCollector;
+    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
+}

package/dist/parser/generic/index.js

@@ -0,0 +1,94 @@
+import { processTokenCandidates } from '../common/tokenUtils';
+import { GenericSqlLexer } from '../../lib/generic/GenericSqlLexer';
+import { GenericSqlParser } from '../../lib/generic/GenericSqlParser';
+import { BasicSQL } from '../common/basicSQL';
+import { EntityContextType, } from '../common/types';
+import { GenericEntityCollector } from './genericEntityCollector';
+import { GenericErrorListener } from './genericErrorListener';
+import { GenericSplitListener } from './genericSplitListener';
+import { GenericSemanticContextCollector } from './genericSemanticContextCollector';
+export { GenericEntityCollector, GenericSplitListener };
+export class GenericSQL extends BasicSQL {
+    constructor(options) {
+        super();
+        /**
+         * The rules that keywords you don't want to be suggested.
+         */
+        this.excludeKeywordRules = new Set([GenericSqlParser.RULE_nonReserved]);
+        this.preferredRules = new Set([
+            GenericSqlParser.RULE_tableName,
+            GenericSqlParser.RULE_tableNameCreate,
+            GenericSqlParser.RULE_columnRef,
+            ...this.excludeKeywordRules,
+        ]);
+        this._diagnostics = (options === null || options === void 0 ? void 0 : options.diagnostics) !== false;
+    }
+    createLexerFromCharStream(charStreams) {
+        return new GenericSqlLexer(charStreams);
+    }
+    validate(input) {
+        if (!this._diagnostics) {
+            return [];
+        }
+        return super.validate(input);
+    }
+    createParserFromTokenStream(tokenStream) {
+        return new GenericSqlParser(tokenStream);
+    }
+    get splitListener() {
+        return new GenericSplitListener();
+    }
+    createErrorListener(_errorListener) {
+        const parserContext = this;
+        return new GenericErrorListener(_errorListener, parserContext, this.preferredRules);
+    }
+    createEntityCollector(input, allTokens, caretTokenIndex) {
+        return new GenericEntityCollector(input, allTokens, caretTokenIndex);
+    }
+    createSemanticContextCollector(input, caretPosition, allTokens, options) {
+        return new GenericSemanticContextCollector(input, caretPosition, allTokens, options);
+    }
+    processCandidates(candidates, allTokens, caretTokenIndex) {
+        const originalSyntaxSuggestions = [];
+        const keywords = [];
+        for (const candidate of candidates.rules) {
+            const [ruleType, candidateRule] = candidate;
+            const tokenRanges = allTokens.slice(candidateRule.startTokenIndex, caretTokenIndex + 1);
+            let syntaxContextType = void 0;
+            switch (ruleType) {
+                case GenericSqlParser.RULE_tableName: {
+                    syntaxContextType = EntityContextType.TABLE;
+                    break;
+                }
+                case GenericSqlParser.RULE_tableNameCreate: {
+                    syntaxContextType = EntityContextType.TABLE_CREATE;
+                    break;
+                }
+                case GenericSqlParser.RULE_columnRef: {
+                    syntaxContextType = EntityContextType.COLUMN;
+                    break;
+                }
+                default:
+                    break;
+            }
+            if (syntaxContextType &&
+                !originalSyntaxSuggestions.some((syn) => {
+                    var _a, _b;
+                    return syn.syntaxContextType === syntaxContextType &&
+                        ((_a = syn.wordRanges.map((wordRange) => wordRange.text)) === null || _a === void 0 ? void 0 : _a.join(',')) ===
+                            ((_b = tokenRanges.map((tokenRange) => tokenRange.text)) === null || _b === void 0 ? void 0 : _b.join(','));
+                })) {
+                originalSyntaxSuggestions.push({
+                    syntaxContextType,
+                    wordRanges: tokenRanges,
+                });
+            }
+        }
+        const processedKeywords = processTokenCandidates(this._parser, candidates.tokens);
+        keywords.push(...processedKeywords);
+        return {
+            syntax: originalSyntaxSuggestions,
+            keywords,
+        };
+    }
+}

package/dist/parser/index.d.ts

@@ -5,3 +5,4 @@ export { SparkSQL } from './spark';
 export { PostgreSQL } from './postgresql';
 export { TrinoSQL } from './trino';
 export { ImpalaSQL } from './impala';
+export { GenericSQL } from './generic';

package/dist/parser/index.js

@@ -5,3 +5,4 @@ export { SparkSQL } from './spark';
 export { PostgreSQL } from './postgresql';
 export { TrinoSQL } from './trino';
 export { ImpalaSQL } from './impala';
+export { GenericSQL } from './generic';

package/package.json

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