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

package/dist/lib/plsql/PlSqlParserVisitor.js

@@ -1,11 +0,0 @@
-// Generated from dt-sql-parser/src/grammar/plsql/PlSqlParser.g4 by ANTLR 4.13.1
-import { AbstractParseTreeVisitor } from "antlr4ng";
-/**
- * This interface defines a complete generic visitor for a parse tree produced
- * by `PlSqlParser`.
- *
- * @param <Result> The return type of the visit operation. Use `void` for
- * operations with no return type.
- */
-export class PlSqlParserVisitor extends AbstractParseTreeVisitor {
-}

package/dist/parser/common/basic-parser-types.js

@@ -1,34 +0,0 @@
-/**
- * Syntax context type at caret position
- */
-export var SyntaxContextType;
-(function (SyntaxContextType) {
-    /** catalog name */
-    SyntaxContextType["CATALOG"] = "catalog";
-    /** catalog name that will be created  */
-    SyntaxContextType["CATALOG_CREATE"] = "catalogCreate";
-    /** database name path, such as catalog.db */
-    SyntaxContextType["DATABASE"] = "database";
-    /** database name path that will be created  */
-    SyntaxContextType["DATABASE_CREATE"] = "databaseCreate";
-    /** table name path, such as catalog.db.tb */
-    SyntaxContextType["TABLE"] = "table";
-    /** table name path that will be created */
-    SyntaxContextType["TABLE_CREATE"] = "tableCreate";
-    /** view name path, such as db.tb.view */
-    SyntaxContextType["VIEW"] = "view";
-    /** view name path that will be created */
-    SyntaxContextType["VIEW_CREATE"] = "viewCreate";
-    /** function name */
-    SyntaxContextType["FUNCTION"] = "function";
-    /** function name that will be created */
-    SyntaxContextType["FUNCTION_CREATE"] = "functionCreate";
-    /** procedure name */
-    SyntaxContextType["PROCEDURE"] = "procedure";
-    /** procedure name that will be created */
-    SyntaxContextType["PROCEDURE_CREATE"] = "procedureCreate";
-    /** column name */
-    SyntaxContextType["COLUMN"] = "column";
-    /** column name that will be created */
-    SyntaxContextType["COLUMN_CREATE"] = "columnCreate";
-})(SyntaxContextType || (SyntaxContextType = {}));

package/dist/parser/flinksql.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { FlinkSqlLexer } from '../lib/flinksql/FlinkSqlLexer';
-import { FlinkSqlParser, ProgramContext, SingleStatementContext } from '../lib/flinksql/FlinkSqlParser';
-import { FlinkSqlParserListener } from '../lib/flinksql/FlinkSqlParserListener';
-import { Suggestions } from './common/basic-parser-types';
-import BasicParser from './common/basicParser';
-export default class FlinkSQL extends BasicParser<FlinkSqlLexer, ProgramContext, FlinkSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): FlinkSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): FlinkSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): FlinkSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class FlinkSqlSplitListener implements FlinkSqlParserListener {
-    private _statementsContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/parser/hive.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { HiveSqlLexer } from '../lib/hive/HiveSqlLexer';
-import { HiveSqlParser, ProgramContext, StatementContext } from '../lib/hive/HiveSqlParser';
-import BasicParser from './common/basicParser';
-import { HiveSqlParserListener } from '../lib/hive/HiveSqlParserListener';
-import { Suggestions } from './common/basic-parser-types';
-export default class HiveSQL extends BasicParser<HiveSqlLexer, ProgramContext, HiveSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): HiveSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): HiveSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): HiveSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class HiveSqlSplitListener implements HiveSqlParserListener {
-    private _statementContext;
-    exitStatement: (ctx: StatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): StatementContext[];
-}

package/dist/parser/impala.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { ImpalaSqlLexer } from '../lib/impala/ImpalaSqlLexer';
-import { ImpalaSqlParser, ProgramContext, SingleStatementContext } from '../lib/impala/ImpalaSqlParser';
-import BasicParser from './common/basicParser';
-import { ImpalaSqlParserListener } from '../lib/impala/ImpalaSqlParserListener';
-import { Suggestions } from './common/basic-parser-types';
-export default class ImpalaSQL extends BasicParser<ImpalaSqlLexer, ProgramContext, ImpalaSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): ImpalaSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): ImpalaSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): ImpalaSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class ImpalaSqlSplitListener implements ImpalaSqlParserListener {
-    private _statementContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/parser/mysql.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { MySqlLexer } from '../lib/mysql/MySqlLexer';
-import { MySqlParser, ProgramContext, SingleStatementContext } from '../lib/mysql/MySqlParser';
-import BasicParser from './common/basicParser';
-import { Suggestions } from './common/basic-parser-types';
-import { MySqlParserListener } from '../lib/mysql/MySqlParserListener';
-export default class MySQL extends BasicParser<MySqlLexer, ProgramContext, MySqlParser> {
-    protected createLexerFromCharStream(charStreams: any): MySqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): MySqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): MysqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class MysqlSplitListener implements MySqlParserListener {
-    private _statementsContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/parser/pgsql.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { PostgreSQLLexer } from '../lib/pgsql/PostgreSQLLexer';
-import { PostgreSQLParser, ProgramContext, SingleStmtContext } from '../lib/pgsql/PostgreSQLParser';
-import BasicParser from './common/basicParser';
-import { PostgreSQLParserListener } from '../lib/pgsql/PostgreSQLParserListener';
-import { Suggestions } from './common/basic-parser-types';
-export default class PostgresSQL extends BasicParser<PostgreSQLLexer, ProgramContext, PostgreSQLParser> {
-    protected createLexerFromCharStream(charStreams: any): PostgreSQLLexer;
-    protected createParserFromTokenStream(tokenStream: any): PostgreSQLParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): PgSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class PgSqlSplitListener implements PostgreSQLParserListener {
-    private _statementsContext;
-    exitSingleStmt: (ctx: SingleStmtContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStmtContext[];
-}

package/dist/parser/pgsql.js

@@ -1,140 +0,0 @@
-import { PostgreSQLLexer } from '../lib/pgsql/PostgreSQLLexer';
-import { PostgreSQLParser } from '../lib/pgsql/PostgreSQLParser';
-import BasicParser from './common/basicParser';
-import { SyntaxContextType } from './common/basic-parser-types';
-export default class PostgresSQL extends BasicParser {
-    constructor() {
-        super(...arguments);
-        this.preferredRules = new Set([
-            PostgreSQLParser.RULE_table_name_create,
-            PostgreSQLParser.RULE_table_name,
-            PostgreSQLParser.RULE_function_name,
-            PostgreSQLParser.RULE_function_name_create,
-            PostgreSQLParser.RULE_schema_name_create,
-            PostgreSQLParser.RULE_schema_name,
-            PostgreSQLParser.RULE_view_name_create,
-            PostgreSQLParser.RULE_view_name,
-            PostgreSQLParser.RULE_database_name_create,
-            PostgreSQLParser.RULE_database_name,
-            PostgreSQLParser.RULE_procedure_name_create,
-            PostgreSQLParser.RULE_procedure_name,
-            PostgreSQLParser.RULE_column_name_create,
-            PostgreSQLParser.RULE_column_name, // column name
-        ]);
-    }
-    createLexerFromCharStream(charStreams) {
-        const lexer = new PostgreSQLLexer(charStreams);
-        return lexer;
-    }
-    createParserFromTokenStream(tokenStream) {
-        return new PostgreSQLParser(tokenStream);
-    }
-    get splitListener() {
-        return new PgSqlSplitListener();
-    }
-    processCandidates(candidates, allTokens, caretTokenIndex, tokenIndexOffset) {
-        const originalSyntaxSuggestions = [];
-        const keywords = [];
-        for (let candidate of candidates.rules) {
-            const [ruleType, candidateRule] = candidate;
-            const startTokenIndex = candidateRule.startTokenIndex + tokenIndexOffset;
-            const tokenRanges = allTokens.slice(startTokenIndex, caretTokenIndex + tokenIndexOffset + 1);
-            let syntaxContextType;
-            switch (ruleType) {
-                case PostgreSQLParser.RULE_table_name_create: {
-                    syntaxContextType = SyntaxContextType.TABLE_CREATE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_table_name: {
-                    syntaxContextType = SyntaxContextType.TABLE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_function_name_create: {
-                    syntaxContextType = SyntaxContextType.FUNCTION_CREATE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_function_name: {
-                    syntaxContextType = SyntaxContextType.FUNCTION;
-                    break;
-                }
-                case PostgreSQLParser.RULE_schema_name_create: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_schema_name: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_view_name_create: {
-                    syntaxContextType = SyntaxContextType.VIEW_CREATE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_view_name: {
-                    syntaxContextType = SyntaxContextType.VIEW;
-                    break;
-                }
-                case PostgreSQLParser.RULE_database_name_create: {
-                    syntaxContextType = SyntaxContextType.DATABASE_CREATE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_database_name: {
-                    syntaxContextType = SyntaxContextType.DATABASE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_procedure_name_create: {
-                    syntaxContextType = SyntaxContextType.PROCEDURE_CREATE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_procedure_name: {
-                    syntaxContextType = SyntaxContextType.PROCEDURE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_column_name_create: {
-                    syntaxContextType = SyntaxContextType.COLUMN_CREATE;
-                    break;
-                }
-                case PostgreSQLParser.RULE_column_name: {
-                    syntaxContextType = SyntaxContextType.COLUMN;
-                    break;
-                }
-                default:
-                    break;
-            }
-            if (syntaxContextType) {
-                originalSyntaxSuggestions.push({
-                    syntaxContextType,
-                    wordRanges: tokenRanges,
-                });
-            }
-        }
-        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_')) {
-                const keyword = displayName.startsWith("'") && displayName.endsWith("'")
-                    ? displayName.slice(1, -1)
-                    : displayName;
-                keywords.push(keyword);
-            }
-        }
-        return {
-            syntax: originalSyntaxSuggestions,
-            keywords,
-        };
-    }
-}
-export class PgSqlSplitListener {
-    constructor() {
-        this._statementsContext = [];
-        this.exitSingleStmt = (ctx) => {
-            this._statementsContext.push(ctx);
-        };
-    }
-    visitTerminal() { }
-    visitErrorNode() { }
-    enterEveryRule() { }
-    exitEveryRule() { }
-    get statementsContext() {
-        return this._statementsContext;
-    }
-}

package/dist/parser/plsql.d.ts

@@ -1,13 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { PlSqlLexer } from '../lib/plsql/PlSqlLexer';
-import { PlSqlParser, ProgramContext } from '../lib/plsql/PlSqlParser';
-import BasicParser from './common/basicParser';
-import { Suggestions } from './common/basic-parser-types';
-export default class PLSQL extends BasicParser<PlSqlLexer, ProgramContext, PlSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): PlSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): PlSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): any;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number): Suggestions<Token>;
-}

package/dist/parser/plsql.js

@@ -1,25 +0,0 @@
-import { PlSqlLexer } from '../lib/plsql/PlSqlLexer';
-import { PlSqlParser } from '../lib/plsql/PlSqlParser';
-import BasicParser from './common/basicParser';
-export default class PLSQL extends BasicParser {
-    constructor() {
-        super(...arguments);
-        this.preferredRules = new Set();
-    }
-    createLexerFromCharStream(charStreams) {
-        const lexer = new PlSqlLexer(charStreams);
-        return lexer;
-    }
-    createParserFromTokenStream(tokenStream) {
-        return new PlSqlParser(tokenStream);
-    }
-    get splitListener() {
-        return null;
-    }
-    processCandidates(candidates, allTokens, caretTokenIndex) {
-        return {
-            syntax: [],
-            keywords: [],
-        };
-    }
-}

package/dist/parser/spark.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { SparkSqlLexer } from '../lib/spark/SparkSqlLexer';
-import { SparkSqlParser, ProgramContext, SingleStatementContext } from '../lib/spark/SparkSqlParser';
-import BasicParser from './common/basicParser';
-import { Suggestions } from './common/basic-parser-types';
-import { SparkSqlParserListener } from '../lib/spark/SparkSqlParserListener';
-export default class SparkSQL extends BasicParser<SparkSqlLexer, ProgramContext, SparkSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): SparkSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): SparkSqlParser;
-    protected preferredRules: Set<number>;
-    protected get splitListener(): SparkSqlSplitListener;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class SparkSqlSplitListener implements SparkSqlParserListener {
-    private _statementsContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/parser/trinosql.d.ts

@@ -1,23 +0,0 @@
-import { Token } from 'antlr4ng';
-import { CandidatesCollection } from 'antlr4-c3';
-import { TrinoSqlLexer } from '../lib/trinosql/TrinoSqlLexer';
-import { TrinoSqlParser, ProgramContext, SingleStatementContext } from '../lib/trinosql/TrinoSqlParser';
-import { TrinoSqlListener } from '../lib/trinosql/TrinoSqlListener';
-import BasicParser from './common/basicParser';
-import { Suggestions } from './common/basic-parser-types';
-export default class TrinoSQL extends BasicParser<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
-    protected createLexerFromCharStream(charStreams: any): TrinoSqlLexer;
-    protected createParserFromTokenStream(tokenStream: any): TrinoSqlParser;
-    protected get splitListener(): TrinoSqlSplitListener;
-    protected preferredRules: Set<number>;
-    protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;
-}
-export declare class TrinoSqlSplitListener implements TrinoSqlListener {
-    private _statementsContext;
-    exitSingleStatement: (ctx: SingleStatementContext) => void;
-    visitTerminal(): void;
-    visitErrorNode(): void;
-    enterEveryRule(): void;
-    exitEveryRule(): void;
-    get statementsContext(): SingleStatementContext[];
-}

package/dist/utils/index.d.ts

@@ -1,19 +0,0 @@
-import { Legacy_Token } from './token';
-/**
- * @param {String} sql
- * @deprecated use parser.createLexer() instead.
- */
-declare function legacy_lexer(input: string): Legacy_Token[];
-/**
- * split sql
- * @param {String} sql
- * @deprecated use parser.splitSQLByStatement() instead.
- */
-declare function legacy_splitSql(sql: string): any[];
-/**
- * clean comment
- * @param {String} sql
- * @deprecated will be removed in future.
- */
-declare function legacy_cleanSql(sql: string): string;
-export { legacy_cleanSql, legacy_splitSql, legacy_lexer };

package/dist/utils/index.js

@@ -1,170 +0,0 @@
-import { Legacy_TokenType, Legacy_TokenReg } from './token';
-/**
- * @param {String} sql
- * @deprecated use parser.createLexer() instead.
- */
-function legacy_lexer(input) {
-    let current = 0;
-    let line = 1;
-    const tokens = [];
-    const extract = (currentChar, validator, TokenType) => {
-        let value = '';
-        const start = current;
-        while (validator.test(currentChar)) {
-            value += currentChar;
-            currentChar = input[++current];
-        }
-        return {
-            type: TokenType,
-            start: start,
-            end: current,
-            lineNumber: line,
-            value: value,
-        };
-    };
-    const matchFunction = () => {
-        const bracketNum = [current];
-        for (let i = current + 1; i < input.length; i++) {
-            const currentChar = input[i];
-            if (currentChar === '\n') {
-                line++;
-            }
-            if (Legacy_TokenReg.LeftSmallBracket.test(currentChar)) {
-                bracketNum.push(i);
-            }
-            if (Legacy_TokenReg.RightSmallBracket.test(currentChar)) {
-                const start = bracketNum.pop();
-                const end = i + 1;
-                if (bracketNum.length === 0) {
-                    current = end;
-                    tokens.push({
-                        type: Legacy_TokenType.FunctionArguments,
-                        value: input.slice(start, end),
-                        start,
-                        lineNumber: line,
-                        end,
-                    });
-                    return;
-                }
-            }
-        }
-    };
-    const matchQuotation = (currentChar, validator, TokenType) => {
-        do {
-            if (currentChar === '\n') {
-                line++;
-            }
-            currentChar = input[++current];
-        } while (!validator.test(currentChar));
-        ++current;
-    };
-    while (current < input.length) {
-        let char = input[current];
-        if (char === '\n') {
-            line++;
-            current++;
-            continue;
-        }
-        if (Legacy_TokenReg.LeftSmallBracket.test(char)) {
-            matchFunction();
-            continue;
-        }
-        if (Legacy_TokenReg.BackQuotation.test(char)) {
-            matchQuotation(char, Legacy_TokenReg.BackQuotation, Legacy_TokenType.BackQuotation);
-            continue;
-        }
-        if (Legacy_TokenReg.SingleQuotation.test(char)) {
-            matchQuotation(char, Legacy_TokenReg.SingleQuotation, Legacy_TokenType.SingleQuotation);
-            continue;
-        }
-        if (Legacy_TokenReg.DoubleQuotation.test(char)) {
-            matchQuotation(char, Legacy_TokenReg.DoubleQuotation, Legacy_TokenType.DoubleQuotation);
-            continue;
-        }
-        if (char === '-' && input[current + 1] === '-') {
-            let value = '';
-            const start = current;
-            while (char !== '\n' && current < input.length) {
-                value += char;
-                char = input[++current];
-            }
-            tokens.push({
-                type: Legacy_TokenType.Comment,
-                value,
-                start: start,
-                lineNumber: line,
-                end: current,
-            });
-            continue;
-        }
-        if (char === '/' && input[current + 1] === '*') {
-            let value = '';
-            const start = current;
-            const startLine = line;
-            while (!(char === '/' && input[current - 1] === '*')) {
-                if (char === '\n') {
-                    line++;
-                }
-                value += char;
-                char = input[++current];
-            }
-            value += char;
-            ++current;
-            tokens.push({
-                type: Legacy_TokenType.Comment,
-                value,
-                start: start,
-                lineNumber: startLine,
-                end: current,
-            });
-            continue;
-        }
-        if (Legacy_TokenReg.StatementTerminator.test(char)) {
-            const newToken = extract(char, Legacy_TokenReg.StatementTerminator, Legacy_TokenType.StatementTerminator);
-            tokens.push(newToken);
-            continue;
-        }
-        current++;
-    }
-    return tokens;
-}
-/**
- * split sql
- * @param {String} sql
- * @deprecated use parser.splitSQLByStatement() instead.
- */
-function legacy_splitSql(sql) {
-    const tokens = legacy_lexer(sql);
-    const sqlArr = [];
-    let startIndex = 0;
-    tokens.forEach((ele) => {
-        if (ele.type === Legacy_TokenType.StatementTerminator) {
-            sqlArr.push(sql.slice(startIndex, ele.end));
-            startIndex = ele.end;
-        }
-    });
-    if (startIndex < sql.length) {
-        sqlArr.push(sql.slice(startIndex));
-    }
-    return sqlArr;
-}
-/**
- * clean comment
- * @param {String} sql
- * @deprecated will be removed in future.
- */
-function legacy_cleanSql(sql) {
-    sql = sql.trim();
-    const tokens = legacy_lexer(sql);
-    let resultSql = '';
-    let startIndex = 0;
-    tokens.forEach((ele) => {
-        if (ele.type === Legacy_TokenType.Comment) {
-            resultSql += sql.slice(startIndex, ele.start);
-            startIndex = ele.end + 1;
-        }
-    });
-    resultSql += sql.slice(startIndex);
-    return resultSql;
-}
-export { legacy_cleanSql, legacy_splitSql, legacy_lexer };

package/dist/utils/token.d.ts

@@ -1,59 +0,0 @@
-/**
- * @deprecated will be removed in future.
- */
-export declare enum Legacy_TokenType {
-    /**
-     * Enclosed in single/double/back quotation, `` Symbol
-     * 'abc', "abc", `abc`
-     */
-    SingleQuotation = "SingleQuotation",
-    DoubleQuotation = "DoubleQuotation",
-    BackQuotation = "BackQuotation",
-    /**
-     * Language element type
-     */
-    Comment = "Comment",
-    /**
-     * Statement
-     */
-    StatementTerminator = "StatementTerminator",
-    /**
-     * Others
-     */
-    Error = "Error",
-    /**
-     * Left small Bracket
-     */
-    LeftSmallBracket = "LeftSmallBracket",
-    /**
-     * Left small Bracket
-     */
-    RightSmallBracket = "RightSmallBracket",
-    Comma = "Comma",
-    FunctionArguments = "FunctionArguments"
-}
-/**
- * @deprecated will be removed in future.
- * Token object
- */
-export interface Legacy_Token {
-    type: Legacy_TokenType;
-    value: string;
-    start: number;
-    end: number;
-    lineNumber: number;
-    message?: string;
-}
-/**
- * @deprecated will be removed in future.
- * Token recognition rules
- */
-export declare const Legacy_TokenReg: {
-    StatementTerminator: RegExp;
-    SingleQuotation: RegExp;
-    DoubleQuotation: RegExp;
-    BackQuotation: RegExp;
-    LeftSmallBracket: RegExp;
-    RightSmallBracket: RegExp;
-    Comma: RegExp;
-};