feat: add generic and plsql basic parser file

.gitignore

@@ -3,5 +3,5 @@ package-lock.json
 .DS_Store
 .vscode
 .history
-lib/
+dist/
 src/**/.antlr

.npmignore

@@ -8,3 +8,4 @@ package-lock.json
 site
 src/
 docs
+lib/grammar

CONTRIBUTING.md

@@ -0,0 +1,15 @@
+# dt-sql-parser
+
+summary
+
+## How to contribute
+
+## Prerequisites
+
+## Semantic Versioning
+
+## Branch Organization
+
+## Release Process
+
+## Source Code Organization

NeREADME.md

@@ -0,0 +1,33 @@
+# dt-sql-parser
+
+[![NPM version][npm-image]][npm-url]
+
+[npm-image]: https://img.shields.io/npm/v/dt-sql-parser.svg?style=flat-square
+[npm-url]: https://www.npmjs.com/package/dt-sql-parser
+
+## Installation
+
+## Usage
+
+### Basic
+
+### Syntax validation
+
+### Visitor
+
+### Listener
+
+## Example
+
+## Roadmap
+
+- Unify parser generate to Antlr4
+- Generic SQL
+- Flink SQL
+- Libra SQL
+- TiDB
+    MySQL Compatible Syntax
+
+## Contributing
+
+## License

build/antlr4.js

@@ -3,15 +3,14 @@ const exec = require('child_process').exec;
 
 const antlr4 = path.resolve(__dirname, 'antlr-4.8-complete.jar');
 const grammars = path.resolve(__dirname, '../src/grammar');
-const output = path.resolve(__dirname, '../src/parser');
+const output = path.resolve(__dirname, '../src/lib');
 
 const entry = [
     'generic',
-    'mysql',
     'hive',
     'plsql',
     'spark',
-    'tsql',
+    'impala',
 ];
 
 entry.forEach((language) => {

docs/Roadmap.md

@@ -17,6 +17,5 @@
 - Generic SQL
 - Flink SQL
 - Libra SQL
-- Oracle SQL
 - TiDB
     MySQL Compatible Syntax

docs/Tutorials.md

@@ -1,5 +1,13 @@
 # Tutorials
 
+## Antlr4 installation
+
+## How to extend new grammar
+
+## How to expose Javascript interface in this project
+
+## Integrate with Monaco Editor
+
 ## Reference
 
 - <https://tomassetti.me/writing-a-browser-based-editor-using-monaco-and-antlr/>

jest.config.js

@@ -27,7 +27,7 @@ module.exports = {
     // coverageDirectory: null,
 
     // An array of regexp pattern strings used to skip coverage collection
-    coveragePathIgnorePatterns: ["/node_modules/"],
+    coveragePathIgnorePatterns: ['/node_modules/'],
 
     // A list of reporter names that Jest uses when writing coverage reports
     // coverageReporters: [
@@ -129,7 +129,7 @@ module.exports = {
     // snapshotSerializers: [],
 
     // The test environment that will be used for testing
-    testEnvironment: "node",
+    testEnvironment: 'node',
 
     // Options that will be passed to the testEnvironment
     // testEnvironmentOptions: {},
@@ -144,7 +144,7 @@ module.exports = {
     // ],
 
     // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
-    testPathIgnorePatterns: ["/node_modules/"],
+    testPathIgnorePatterns: ['/node_modules/'],
 
     // The regexp pattern or array of patterns that Jest uses to detect test files
     // testRegex: [],
@@ -163,11 +163,11 @@ module.exports = {
 
     // A map from regular expressions to paths to transformers
     transform: {
-      "^.+\\.(t|j)sx?$": "ts-jest",
+        '^.+\\.(t|j)sx?$': 'ts-jest',
     },
 
     // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
-    transformIgnorePatterns: ["/node_modules/"],
+    transformIgnorePatterns: ['/node_modules/'],
 
     // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
     // unmockedModulePathPatterns: undefined,

lib/index.js

@@ -1,14 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./core"), exports);
-__exportStar(require("./utils"), exports);

lib/utils/index.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitSql = exports.replaceStrFormIndexArr = void 0;
-function replaceStrFormIndexArr(str, replaceStr, indexArr) {
-    let result = '';
-    let index = 0;
-    if (!indexArr || indexArr.length < 1) {
-        return str;
-    }
-    for (let i = 0; i < indexArr.length; i++) {
-        const indexItem = indexArr[i];
-        const begin = indexItem.begin;
-        result = result + str.substring(index, begin) + replaceStr;
-        index = indexItem.end + 1;
-        if (i == indexArr.length - 1) {
-            result = result + str.substring(index);
-        }
-    }
-    return result;
-}
-exports.replaceStrFormIndexArr = replaceStrFormIndexArr;
-function splitSql(sql) {
-    let haveEnd = true;
-    if (!sql.endsWith(';')) {
-        sql += ';';
-        haveEnd = false;
-    }
-    function pushSql(parser, sql) {
-        if (!haveEnd && parser.index == sql.length - 1) {
-            parser.sqls.push(parser.index - 1);
-            parser.queue = '';
-        }
-        else {
-            parser.sqls.push(parser.index);
-            parser.queue = '';
-        }
-    }
-    // 处理引号
-    function quoteToken(parser, sql) {
-        const queue = parser.queue;
-        const endsWith = queue[queue.length - 1];
-        if (endsWith == '\'' || endsWith == '"') {
-            const nextToken = sql.indexOf(endsWith, parser.index + 1);
-            if (nextToken != -1) {
-                parser.index = nextToken;
-                parser.queue = '';
-            }
-            else {
-                parser.index = sql.length - 1;
-            }
-        }
-        else {
-            return null;
-        }
-    }
-    // 处理单行注释
-    function singleLineCommentToken(parser, sql) {
-        let queue = parser.queue;
-        if (queue.endsWith('--')) {
-            const nextToken = sql.indexOf('\n', parser.index + 1);
-            if (nextToken != -1) {
-                parser.index = nextToken;
-                queue = '';
-            }
-            else {
-                parser.index = sql.length - 1;
-            }
-        }
-        else {
-            return null;
-        }
-    }
-    // 处理多行注释
-    function multipleLineCommentToken(parser, sql) {
-        const queue = parser.queue;
-        if (queue.endsWith('/*')) {
-            const nextToken = sql.indexOf('*/', parser.index + 1);
-            if (nextToken != -1) {
-                parser.index = nextToken + 1;
-                parser.queue = '';
-            }
-            else {
-                parser.index = sql.length - 1;
-                parser.queue = '';
-            }
-        }
-        else {
-            return null;
-        }
-    }
-    function splitToken(parser, sql) {
-        const queue = parser.queue;
-        if (queue.endsWith(';')) {
-            pushSql(parser, sql);
-        }
-        else {
-            return null;
-        }
-    }
-    const parser = {
-        index: 0,
-        queue: '',
-        sqls: [],
-    };
-    for (parser.index = 0; parser.index < sql.length; parser.index++) {
-        const char = sql[parser.index];
-        parser.queue += char;
-        const tokenFuncs = [
-            quoteToken,
-            singleLineCommentToken,
-            multipleLineCommentToken,
-            splitToken,
-        ];
-        for (let i = 0; i < tokenFuncs.length; i++) {
-            tokenFuncs[i](parser, sql);
-        }
-        if (parser.index == sql.length - 1 && parser.queue) {
-            pushSql(parser, sql);
-        }
-    }
-    return parser.sqls;
-}
-exports.splitSql = splitSql;

package.json

@@ -12,10 +12,10 @@
     "impala",
     "bigdata"
   ],
-  "main": "lib/index.js",
+  "main": "dist/index.js",
   "scripts": {
-    "antlr": "node build/antlr4.js",
+    "antlr4": "node build/antlr4.js",
-    "build": "npm test && rm -rf lib && tsc",
+    "build": "npm test && rm -rf dist && tsc",
     "eslint": "eslint ./src/**/*.ts",
     "check-types": "tsc --skipLibCheck",
     "test": "jest"

src/core/common/baseParser.ts

@@ -1,63 +0,0 @@
-import { Token, Lexer } from 'antlr4';
-
-import ParserErrorListener, { ParserError } from './parserErrorListener';
-
-/**
- * Custom Parser class, subclass needs extends it.
- */
-export default abstract class BaseParser {
-    /**
-     * Create antrl4 Lexer object
-     * @param input source string
-     */
-    public abstract createLexer(input: string): Lexer;
-
-    /**
-     * Create Parser by lexer
-     * @param lexer Lexer
-     */
-    public abstract createParserFromLexer(lexer: Lexer);
-
-    public getAllTokens(input: string): Token[] {
-        return this.createLexer(input).getAllTokens();
-    };
-
-    public createParser(input: string) {
-        const lexer = this.createLexer(input);
-        return this.createParserFromLexer(lexer);
-    }
-
-    public parserTree(input: string) {
-        const lexer = this.createLexer(input);
-        const parser: any = this.createParserFromLexer(lexer);
-        parser.buildParseTrees = true;
-        return parser;
-    }
-
-    /**
-     * It convert tree to string, it's convenient to use in unit test.
-     * @param string input
-     */
-    public parserTreeToString(input: string): string {
-        const parser = this.parserTree(input);
-        const tree = parser.statement();
-        return tree.toStringTree(parser.ruleNames);
-    }
-
-    public validate(input: string): ParserError[] {
-        const lexerError = []; const syntaxErrors = [];
-        const lexer = this.createLexer(input);
-        lexer.removeErrorListeners();
-        lexer.addErrorListener(new ParserErrorListener(lexerError));
-
-        const parser: any = this.createParserFromLexer(lexer);
-        parser.buildParseTrees = true;
-
-        parser.removeErrorListeners();
-        parser.addErrorListener(new ParserErrorListener(syntaxErrors));
-
-        parser.statement();
-
-        return lexerError.concat(syntaxErrors);
-    }
-}

src/core/common/parserErrorListener.ts

@@ -1,36 +0,0 @@
-import { Token, Recognizer } from 'antlr4';
-import { ErrorListener } from 'antlr4/error';
-
-export interface ParserError {
-    startLine: number;
-    endLine: number;
-    startCol: number;
-    endCol: number;
-    message: string;
-}
-
-export default class ParserErrorListener extends ErrorListener {
-    private _errors: ParserError[] = [];
-
-    constructor(errors: ParserError[]) {
-        super();
-        this._errors = errors;
-    }
-
-    syntaxError(
-        recognizer: Recognizer, offendingSymbol: Token, line: number,
-        charPositionInLine: number, msg: string, e: any,
-    ) {
-        let endCol = charPositionInLine + 1;
-        if (offendingSymbol.text !== null) {
-            endCol = charPositionInLine + offendingSymbol.text.length;
-        }
-        this._errors.push({
-            startLine: line,
-            endLine: line,
-            startCol: charPositionInLine,
-            endCol: endCol,
-            message: msg,
-        });
-    }
-}

src/core/index.ts

@@ -1,2 +0,0 @@
-export * as mySQLParser from './mysql';
-export * as tSQLParser from './tsql';

src/core/mysql.ts

@@ -1,17 +0,0 @@
-import { InputStream, CommonTokenStream, Lexer } from 'antlr4';
-import { MySQLLexer } from '../parser/MySQLLexer';
-import { MySQLParser } from '../parser/MySQLParser';
-
-import BaseParser from './common/baseParser';
-
-export default class MySQL extends BaseParser {
-    public createLexer(input: string): Lexer {
-        const chars = new InputStream(input.toUpperCase());
-        const lexer = <unknown> new MySQLLexer(chars) as Lexer;
-        return lexer;
-    }
-    public createParserFromLexer(lexer: Lexer) {
-        const tokenStream = new CommonTokenStream(lexer);
-        return new MySQLParser(tokenStream);
-    }
-}

src/core/tsql.ts

@@ -1,17 +0,0 @@
-import { InputStream, CommonTokenStream, Lexer } from 'antlr4';
-import { TSqlParser } from '../parser/TSqlParser';
-import { TSqlLexer } from '../parser/TSqlLexer';
-
-import BaseParser from './common/baseParser';
-
-export default class TSQLParser extends BaseParser {
-    public createLexer(input: string): Lexer {
-        const chars = new InputStream(input.toUpperCase());
-        const lexer = <unknown> new TSqlLexer(chars) as Lexer;
-        return lexer;
-    }
-    public createParserFromLexer(lexer: Lexer) {
-        const tokenStream = new CommonTokenStream(lexer);
-        return new TSqlParser(tokenStream);
-    }
-}

src/grammar/generic/SqlLexer.g4

@@ -23,7 +23,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
-lexer grammar MySQLLexer;
+lexer grammar SqlLexer;
 
 channels { MYSQLCOMMENT, ERRORCHANNEL }
 

src/grammar/generic/SqlParser.g4

@@ -23,13 +23,15 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
-parser grammar MySQLParser;
+parser grammar SqlParser;
 
-options { tokenVocab=MySQLLexer; }
+options { tokenVocab=SqlLexer; }
 
 
 // Top Level Description
 
+program: statement EOF;
+
 statement
     : sqlStatements? MINUSMINUS? EOF
     ;

src/grammar/hello/Hello.g4

@@ -1,4 +0,0 @@
-grammar helloSQL;
-r: 'hello' ID ;
-ID: [a-z]+ ;
-WS: [ \t\r\n]+ -> skip ;

src/grammar/hive/HiveSqlLexer.g4

@@ -0,0 +1,435 @@
+lexer grammar HiveSqlLexer;
+
+// Lexer rules
+T_ACTION          : A C T I O N ; 
+T_ADD2            : A D D ;
+T_ALL             : A L L ;
+T_ALLOCATE        : A L L O C A T E ;
+T_ALTER           : A L T E R ;
+T_AND             : A N D ;
+T_ANSI_NULLS      : A N S I '_' N U L L S ;
+T_ANSI_PADDING    : A N S I '_' P A D D I N G ;
+T_AS              : A S ;
+T_ASC             : A S C ;
+T_ASSOCIATE       : A S S O C I A T E ; 
+T_AT              : A T ;
+T_AUTO_INCREMENT  : A U T O '_' I N C R E M E N T ;
+T_AVG             : A V G ; 
+T_BATCHSIZE       : B A T C H S I Z E ;
+T_BEGIN           : B E G I N ;
+T_BETWEEN         : B E T W E E N ; 
+T_BIGINT          : B I G I N T ;
+T_BINARY_DOUBLE   : B I N A R Y '_' D O U B L E ;
+T_BINARY_FLOAT    : B I N A R Y '_' F L O A T ;
+T_BINARY_INTEGER  : B I N A R Y '_' I N T E G E R ;
+T_BIT             : B I T ;
+T_BODY            : B O D Y ; 
+T_BREAK           : B R E A K ;
+T_BY              : B Y ;
+T_BYTE            : B Y T E ; 
+T_CALL            : C A L L ;
+T_CALLER          : C A L L E R ;
+T_CASCADE         : C A S C A D E ; 
+T_CASE            : C A S E ;
+T_CASESPECIFIC    : C A S E S P E C I F I C ; 
+T_CAST            : C A S T ;
+T_CHAR            : C H A R ;
+T_CHARACTER       : C H A R A C T E R ;
+T_CHARSET         : C H A R S E T ;
+T_CLIENT          : C L I E N T ;
+T_CLOSE           : C L O S E ;
+T_CLUSTERED       : C L U S T E R E D;
+T_CMP             : C M P ; 
+T_COLLECT         : C O L L E C T ; 
+T_COLLECTION      : C O L L E C T I O N ; 
+T_COLUMN          : C O L U M N ;
+T_COMMENT         : C O M M E N T;
+T_CONSTANT        : C O N S T A N T ;
+T_COMMIT          : C O M M I T ; 
+T_COMPRESS        : C O M P R E S S ;
+T_CONCAT          : C O N C A T;
+T_CONDITION       : C O N D I T I O N ;
+T_CONSTRAINT      : C O N S T R A I N T ; 
+T_CONTINUE        : C O N T I N U E ;
+T_COPY            : C O P Y ;
+T_COUNT           : C O U N T ;
+T_COUNT_BIG       : C O U N T '_' B I G;
+T_CREATE          : C R E A T E ;
+T_CREATION        : C R E A T I O N ; 
+T_CREATOR         : C R E A T O R ;
+T_CS              : C S;
+T_CURRENT         : C U R R E N T ;
+T_CURRENT_SCHEMA  : C U R R E N T '_' S C H E M A ;
+T_CURSOR          : C U R S O R ;
+T_DATABASE        : D A T A B A S E ;
+T_DATA            : D A T A ;
+T_DATE            : D A T E ;
+T_DATETIME        : D A T E T I M E ; 
+T_DAY             : D A Y ;
+T_DAYS            : D A Y S ;
+T_DEC             : D E C ;
+T_DECIMAL         : D E C I M A L ;
+T_DECLARE         : D E C L A R E ;
+T_DEFAULT         : D E F A U L T ;
+T_DEFERRED        : D E F E R R E D ; 
+T_DEFINED         : D E F I N E D ; 
+T_DEFINER         : D E F I N E R ;
+T_DEFINITION      : D E F I N I T I O N ; 
+T_DELETE          : D E L E T E ;
+T_DELIMITED       : D E L I M I T E D ; 
+T_DELIMITER       : D E L I M I T E R ; 
+T_DESC            : D E S C ;
+T_DESCRIBE        : D E S C R I B E ; 
+T_DIAGNOSTICS     : D I A G N O S T I C S ;
+T_DIR             : D I R ;
+T_DIRECTORY       : D I R E C T O R Y ; 
+T_DISTINCT        : D I S T I N C T ;
+T_DISTRIBUTE      : D I S T R I B U T E ;
+T_DO              : D O ;
+T_DOUBLE          : D O U B L E ;
+T_DROP            : D R O P ;
+T_DYNAMIC         : D Y N A M I C ; 
+T_ELSE            : E L S E ;
+T_ELSEIF          : E L S E I F ;
+T_ELSIF           : E L S I F ;
+T_ENABLE          : E N A B L E ;
+T_END             : E N D ;
+T_ENGINE          : E N G I N E ;
+T_ESCAPED         : E S C A P E D ; 
+T_EXCEPT          : E X C E P T ;
+T_EXEC            : E X E C ;
+T_EXECUTE         : E X E C U T E ;
+T_EXCEPTION       : E X C E P T I O N ;
+T_EXCLUSIVE       : E X C L U S I V E ; 
+T_EXISTS          : E X I S T S ; 
+T_EXIT            : E X I T ;
+T_FALLBACK        : F A L L B A C K ;
+T_FALSE           : F A L S E ;
+T_FETCH           : F E T C H ;
+T_FIELDS          : F I E L D S ; 
+T_FILE            : F I L E ;
+T_FILES           : F I L E S ; 
+T_FLOAT           : F L O A T ;
+T_FOR             : F O R ;
+T_FOREIGN         : F O R E I G N ; 
+T_FORMAT          : F O R M A T ;
+T_FOUND           : F O U N D ;
+T_FROM            : F R O M ; 
+T_FULL            : F U L L ;
+T_FUNCTION        : F U N C T I O N ;
+T_GET             : G E T ;
+T_GLOBAL          : G L O B A L ; 
+T_GO              : G O ;
+T_GRANT           : G R A N T ; 
+T_GROUP           : G R O U P ;
+T_HANDLER         : H A N D L E R ;
+T_HASH            : H A S H ;
+T_HAVING          : H A V I N G ;
+T_HDFS            : H D F S ; 
+T_HIVE            : H I V E ;
+T_HOST            : H O S T ;
+T_IDENTITY        : I D E N T I T Y ; 
+T_IF              : I F ;
+T_IGNORE          : I G N O R E ; 
+T_IMMEDIATE       : I M M E D I A T E ;
+T_IN              : I N ;
+T_INCLUDE         : I N C L U D E ;
+T_INDEX           : I N D E X ;
+T_INITRANS        : I N I T R A N S ;
+T_INNER           : I N N E R ; 
+T_INOUT           : I N O U T;
+T_INSERT          : I N S E R T ;
+T_INT             : I N T ;
+T_INT2            : I N T '2';
+T_INT4            : I N T '4';
+T_INT8            : I N T '8';
+T_INTEGER         : I N T E G E R ;
+T_INTERSECT       : I N T E R S E C T ;
+T_INTERVAL        : I N T E R V A L ; 
+T_INTO            : I N T O ;
+T_INVOKER         : I N V O K E R ;
+T_IS              : I S ;
+T_ISOPEN          : I S O P E N ;
+T_ITEMS           : I T E M S ; 
+T_JOIN            : J O I N ;
+T_KEEP            : K E E P; 
+T_KEY             : K E Y ;
+T_KEYS            : K E Y S ;
+T_LANGUAGE        : L A N G U A G E ;
+T_LEAVE           : L E A V E ;
+T_LEFT            : L E F T ;
+T_LIKE            : L I K E ; 
+T_LIMIT           : L I M I T ;
+T_LINES           : L I N E S ; 
+T_LOCAL           : L O C A L ;
+T_LOCATION        : L O C A T I O N ;
+T_LOCATOR         : L O C A T O R ; 
+T_LOCATORS        : L O C A T O R S ; 
+T_LOCKS           : L O C K S ; 
+T_LOG             : L O G ; 
+T_LOGGED          : L O G G E D ; 
+T_LOGGING         : L O G G I N G ; 
+T_LOOP            : L O O P ;
+T_MAP             : M A P ; 
+T_MATCHED         : M A T C H E D ; 
+T_MAX             : M A X ;
+T_MAXTRANS        : M A X T R A N S ; 
+T_MERGE           : M E R G E ; 
+T_MESSAGE_TEXT    : M E S S A G E '_' T E X T ;
+T_MICROSECOND     : M I C R O S E C O N D ;
+T_MICROSECONDS    : M I C R O S E C O N D S;
+T_MIN             : M I N ;
+T_MULTISET        : M U L T I S E T ; 
+T_NCHAR           : N C H A R ; 
+T_NEW             : N E W ;
+T_NVARCHAR        : N V A R C H A R ; 
+T_NO              : N O ;
+T_NOCOUNT         : N O C O U N T ;
+T_NOCOMPRESS      : N O C O M P R E S S ; 
+T_NOLOGGING       : N O L O G G I N G ;
+T_NONE            : N O N E ;
+T_NOT             : N O T ;
+T_NOTFOUND        : N O T F O U N D ; 
+T_NULL            : N U L L ;
+T_NUMERIC         : N U M E R I C ; 
+T_NUMBER          : N U M B E R ;
+T_OBJECT          : O B J E C T ; 
+T_OFF             : O F F ;
+T_ON              : O N ;
+T_ONLY            : O N L Y ;
+T_OPEN            : O P E N ;
+T_OR              : O R ;
+T_ORDER           : O R D E R;
+T_OUT             : O U T ;
+T_OUTER           : O U T E R ;
+T_OVER            : O V E R ;
+T_OVERWRITE       : O V E R W R I T E ; 
+T_OWNER           : O W N E R ; 
+T_PACKAGE         : P A C K A G E ; 
+T_PARTITION       : P A R T I T I O N ; 
+T_PCTFREE         : P C T F R E E ; 
+T_PCTUSED         : P C T U S E D ;
+T_PLS_INTEGER     : P L S '_' I N T E G E R ;
+T_PRECISION       : P R E C I S I O N ; 
+T_PRESERVE        : P R E S E R V E ; 
+T_PRIMARY         : P R I M A R Y ;
+T_PRINT           : P R I N T ; 
+T_PROC            : P R O C ;
+T_PROCEDURE       : P R O C E D U R E ;
+T_QUALIFY         : Q U A L I F Y ;
+T_QUERY_BAND      : Q U E R Y '_' B A N D ; 
+T_QUIT            : Q U I T ; 
+T_QUOTED_IDENTIFIER : Q U O T E D '_' I D E N T I F I E R ;
+T_RAISE           : R A I S E ;
+T_REAL            : R E A L ; 
+T_REFERENCES      : R E F E R E N C E S ; 
+T_REGEXP          : R E G E X P ;
+T_REPLACE         : R E P L A C E ; 
+T_RESIGNAL        : R E S I G N A L ;
+T_RESTRICT        : R E S T R I C T ; 
+T_RESULT          : R E S U L T ; 
+T_RESULT_SET_LOCATOR : R E S U L T '_' S E T '_' L O C A T O R ;
+T_RETURN          : R E T U R N ;
+T_RETURNS         : R E T U R N S ;
+T_REVERSE         : R E V E R S E ;
+T_RIGHT           : R I G H T ;
+T_RLIKE           : R L I K E ;
+T_ROLE            : R O L E ;
+T_ROLLBACK        : R O L L B A C K ;
+T_ROW             : R O W ; 
+T_ROWS            : R O W S ; 
+T_ROWTYPE         : R O W T Y P E ; 
+T_ROW_COUNT       : R O W '_' C O U N T ;
+T_RR              : R R;
+T_RS              : R S ;
+T_PWD             : P W D ; 
+T_TRIM            : T R I M ;
+T_SCHEMA          : S C H E M A ;
+T_SECOND          : S E C O N D ;
+T_SECONDS         : S E C O N D S;
+T_SECURITY        : S E C U R I T Y ; 
+T_SEGMENT         : S E G M E N T ; 
+T_SEL             : S E L ;
+T_SELECT          : S E L E C T ; 
+T_SET             : S E T ;
+T_SESSION         : S E S S I O N ; 
+T_SESSIONS        : S E S S I O N S ;
+T_SETS            : S E T S;
+T_SHARE           : S H A R E ; 
+T_SIGNAL          : S I G N A L ;
+T_SIMPLE_DOUBLE   : S I M P L E '_' D O U B L E ;
+T_SIMPLE_FLOAT    : S I M P L E '_' F L O A T ;
+T_SIMPLE_INTEGER  : S I M P L E '_' I N T E G E R ;
+T_SMALLDATETIME   : S M A L L D A T E T I M E ;
+T_SMALLINT        : S M A L L I N T ;
+T_SQL             : S Q L ; 
+T_SQLEXCEPTION    : S Q L E X C E P T I O N ;
+T_SQLINSERT       : S Q L I N S E R T ;
+T_SQLSTATE        : S Q L S T A T E ;
+T_SQLWARNING      : S Q L W A R N I N G ;
+T_STATS           : S T A T S ; 
+T_STATISTICS      : S T A T I S T I C S ;
+T_STEP            : S T E P ; 
+T_STORAGE         : S T O R A G E ; 
+T_STORED          : S T O R E D ;
+T_STRING          : S T R I N G ;
+T_SUBDIR          : S U B D I R ; 
+T_SUBSTRING       : S U B S T R I N G ; 
+T_SUM             : S U M ;
+T_SUMMARY         : S U M M A R Y ;
+T_SYS_REFCURSOR   : S Y S '_' R E F C U R S O R ; 
+T_TABLE           : T A B L E ;
+T_TABLESPACE      : T A B L E S P A C E ; 
+T_TEMPORARY       : T E M P O R A R Y ;
+T_TERMINATED      : T E R M I N A T E D ; 
+T_TEXTIMAGE_ON    : T E X T I M A G E '_' O N ;
+T_THEN            : T H E N ;
+T_TIMESTAMP       : T I M E S T A M P ;
+T_TINYINT         : T I N Y I N T ;
+T_TITLE           : T I T L E ;
+T_TO              : T O ; 
+T_TOP             : T O P ;
+T_TRANSACTION     : T R A N S A C T I O N ;
+T_TRUE            : T R U E ;
+T_TRUNCATE        : T R U N C A T E;
+T_TYPE            : T Y P E ; 
+T_UNION           : U N I O N ;
+T_UNIQUE          : U N I Q U E ;
+T_UPDATE          : U P D A T E ; 
+T_UR              : U R ;
+T_USE             : U S E ;
+T_USING           : U S I N G ;
+T_VALUE           : V A L U E ;
+T_VALUES          : V A L U E S ;
+T_VAR             : V A R ;
+T_VARCHAR         : V A R C H A R ;
+T_VARCHAR2        : V A R C H A R '2' ;
+T_VARYING         : V A R Y I N G ;
+T_VOLATILE        : V O L A T I L E ;
+T_WHEN            : W H E N ;
+T_WHERE           : W H E R E ;
+T_WHILE           : W H I L E ;
+T_WITH            : W I T H ; 
+T_WITHOUT         : W I T H O U T ;
+T_WORK            : W O R K ;
+T_XACT_ABORT      : X A C T '_' A B O R T ;
+T_XML             : X M L ;
+T_YES             : Y E S ; 
+
+// Functions with specific syntax
+T_ACTIVITY_COUNT       : A C T I V I T Y '_' C O U N T ;
+T_CUME_DIST            : C U M E '_' D I S T ; 
+T_CURRENT_DATE         : C U R R E N T '_' D A T E ;
+T_CURRENT_TIMESTAMP    : C U R R E N T '_' T I M E S T A M P ;
+T_CURRENT_USER         : C U R R E N T '_' U S E R ;
+T_DENSE_RANK           : D E N S E '_' R A N K ;
+T_FIRST_VALUE          : F I R S T '_' V A L U E; 
+T_LAG                  : L A G ;
+T_LAST_VALUE           : L A S T '_' V A L U E; 
+T_LEAD                 : L E A D ; 
+T_MAX_PART_STRING      : M A X '_' P A R T '_' S T R I N G ;
+T_MIN_PART_STRING      : M I N '_' P A R T '_' S T R I N G ;
+T_MAX_PART_INT         : M A X '_' P A R T '_' I N T ;
+T_MIN_PART_INT         : M I N '_' P A R T '_' I N T ;
+T_MAX_PART_DATE        : M A X '_' P A R T '_' D A T E ;
+T_MIN_PART_DATE        : M I N '_' P A R T '_' D A T E ;
+T_PART_COUNT           : P A R T '_' C O U N T ; 
+T_PART_LOC             : P A R T '_' L O C ;
+T_RANK                 : R A N K ;
+T_ROW_NUMBER           : R O W '_' N U M B E R;
+T_STDEV                : S T D E V ;
+T_SYSDATE              : S Y S D A T E ;
+T_VARIANCE             : V A R I A N C E ; 
+T_USER                 : U S E R; 
+
+T_ADD          : '+' ;
+T_COLON        : ':' ;
+T_COMMA        : ',' ;
+T_PIPE         : '||' ;
+T_DIV          : '/' ;
+T_DOT2         : '..' ;
+T_EQUAL        : '=' ;
+T_EQUAL2       : '==' ;
+T_NOTEQUAL     : '<>' ;
+T_NOTEQUAL2    : '!=' ;
+T_GREATER      : '>' ;
+T_GREATEREQUAL : '>=' ;
+T_LESS         : '<' ;
+T_LESSEQUAL    : '<=' ;
+T_MUL          : '*' ;
+T_OPEN_B       : '{' ;
+T_OPEN_P       : '(' ;
+T_OPEN_SB      : '[' ;
+T_CLOSE_B      : '}' ; 
+T_CLOSE_P      : ')' ;
+T_CLOSE_SB     : ']' ;
+T_SEMICOLON    : ';' ;
+T_SUB          : '-' ;
+
+L_ID        : L_ID_PART                                                // Identifier
+            ;
+L_S_STRING  : '\'' (('\'' '\'') | ('\\' '\'') | ~('\''))* '\''         // Single quoted string literal
+            ;
+L_D_STRING  : '"' (L_STR_ESC_D | .)*? '"'                              // Double quoted string literal
+            ;
+L_INT       : L_DIGIT+ ;                                               // Integer
+L_DEC       : L_DIGIT+ '.' ~'.' L_DIGIT*                               // Decimal number
+            | '.' L_DIGIT+
+            ;
+L_WS        : L_BLANK+ -> skip ;                                       // Whitespace
+L_M_COMMENT : '/*' .*? '*/' -> channel(HIDDEN) ;                       // Multiline comment
+L_S_COMMENT : ('--' | '//')  .*? '\r'? '\n' -> channel(HIDDEN) ;       // Single line comment
+
+L_FILE      : ([a-zA-Z] ':' '\\'?)? L_ID ('\\' L_ID)*                  // File path (a/b/c Linux path causes conflicts with division operator and handled at parser level)
+            ; 
+
+L_LABEL     : ([a-zA-Z] | L_DIGIT | '_')* ':'            
+            ;
+            
+fragment
+L_ID_PART  :
+             [a-zA-Z] ([a-zA-Z] | L_DIGIT | '_')*                           // Identifier part
+            | '$' '{' .*? '}'
+            | ('_' | '@' | ':' | '#' | '$') ([a-zA-Z] | L_DIGIT | '_' | '@' | ':' | '#' | '$')+     // (at least one char must follow special char)
+            | '"' .*? '"'                                                   // Quoted identifiers
+            | '[' .*? ']'
+            | '`' .*? '`'
+            ;
+fragment
+L_STR_ESC_D :                                                          // Double quoted string escape sequence
+              '""' | '\\"' 
+            ;            
+fragment
+L_DIGIT     : [0-9]                                                    // Digit
+            ;
+fragment
+L_BLANK     : (' ' | '\t' | '\r' | '\n')
+            ;
+
+// Support case-insensitive keywords and allowing case-sensitive identifiers
+fragment A : ('a'|'A') ;
+fragment B : ('b'|'B') ;
+fragment C : ('c'|'C') ;
+fragment D : ('d'|'D') ;
+fragment E : ('e'|'E') ;
+fragment F : ('f'|'F') ;
+fragment G : ('g'|'G') ;
+fragment H : ('h'|'H') ;
+fragment I : ('i'|'I') ;
+fragment J : ('j'|'J') ;
+fragment K : ('k'|'K') ;
+fragment L : ('l'|'L') ;
+fragment M : ('m'|'M') ;
+fragment N : ('n'|'N') ;
+fragment O : ('o'|'O') ;
+fragment P : ('p'|'P') ;
+fragment Q : ('q'|'Q') ;
+fragment R : ('r'|'R') ;
+fragment S : ('s'|'S') ;
+fragment T : ('t'|'T') ;
+fragment U : ('u'|'U') ;
+fragment V : ('v'|'V') ;
+fragment W : ('w'|'W') ;
+fragment X : ('x'|'X') ;
+fragment Y : ('y'|'Y') ;
+fragment Z : ('z'|'Z') ;

src/grammar/spark/README.md

@@ -0,0 +1,3 @@
+# Spark SQL
+
+Grammar file from: <https://github.com/apache/spark/blob/master/sql/catalyst/src/main/antlr4/org/apache/spark/sql/catalyst/parser/SqlBase.g4>

src/grammar/tsql/TSqlLexer.g4

@@ -1,902 +0,0 @@
-/*
-T-SQL (Transact-SQL, MSSQL) grammar.
-The MIT License (MIT).
-Copyright (c) 2017, Mark Adams (madams51703@gmail.com)
-Copyright (c) 2015-2017, Ivan Kochurkin (kvanttt@gmail.com), Positive Technologies.
-Copyright (c) 2016, Scott Ure (scott@redstormsoftware.com).
-Copyright (c) 2016, Rui Zhang (ruizhang.ccs@gmail.com).
-Copyright (c) 2016, Marcus Henriksson (kuseman80@gmail.com).
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-*/
-
-lexer grammar TSqlLexer;
-
-// Basic keywords (from https://msdn.microsoft.com/en-us/library/ms189822.aspx)
-ABSENT:                                'ABSENT';
-ADD:                                   'ADD';
-AES:                                   'AES';
-ALL:                                   'ALL';
-ALLOW_CONNECTIONS:                     'ALLOW_CONNECTIONS';
-ALLOW_MULTIPLE_EVENT_LOSS:             'ALLOW_MULTIPLE_EVENT_LOSS';
-ALLOW_SINGLE_EVENT_LOSS:               'ALLOW_SINGLE_EVENT_LOSS';
-ALTER:                                 'ALTER';
-AND:                                   'AND';
-ANONYMOUS:                             'ANONYMOUS';
-ANY:                                   'ANY';
-APPEND:                                'APPEND';
-APPLICATION:                           'APPLICATION';
-AS:                                    'AS';
-ASC:                                   'ASC';
-ASYMMETRIC:                            'ASYMMETRIC';
-ASYNCHRONOUS_COMMIT:                   'ASYNCHRONOUS_COMMIT';
-AUTHORIZATION:                         'AUTHORIZATION';
-AUTHENTICATION:                        'AUTHENTICATION';
-AUTOMATED_BACKUP_PREFERENCE:           'AUTOMATED_BACKUP_PREFERENCE';
-AUTOMATIC:                             'AUTOMATIC';
-AVAILABILITY_MODE:                     'AVAILABILITY_MODE';
-BACKSLASH:                             '\\';
-BACKUP:                                'BACKUP';
-BEFORE:                                'BEFORE';
-BEGIN:                                 'BEGIN';
-BETWEEN:                               'BETWEEN';
-BLOCK:                                 'BLOCK';
-BLOCKSIZE:                             'BLOCKSIZE';
-BLOCKING_HIERARCHY:                    'BLOCKING_HIERARCHY';
-BREAK:                                 'BREAK';
-BROWSE:                                'BROWSE';
-BUFFER:                                'BUFFER';
-BUFFERCOUNT:                           'BUFFERCOUNT';
-BULK:                                  'BULK';
-BY:                                    'BY';
-CACHE:                                 'CACHE';
-CALLED:                                'CALLED';
-CASCADE:                               'CASCADE';
-CASE:                                  'CASE';
-CERTIFICATE:                           'CERTIFICATE';
-CHANGETABLE:                           'CHANGETABLE';
-CHANGES:                               'CHANGES';
-CHECK:                                 'CHECK';
-CHECKPOINT:                            'CHECKPOINT';
-CHECK_POLICY:                          'CHECK_POLICY';
-CHECK_EXPIRATION:                      'CHECK_EXPIRATION';
-CLASSIFIER_FUNCTION:                   'CLASSIFIER_FUNCTION';
-CLOSE:                                 'CLOSE';
-CLUSTER:                               'CLUSTER';
-CLUSTERED:                             'CLUSTERED';
-COALESCE:                              'COALESCE';
-COLLATE:                               'COLLATE';
-COLUMN:                                'COLUMN';
-COMPRESSION:                           'COMPRESSION';
-COMMIT:                                'COMMIT';
-COMPUTE:                               'COMPUTE';
-CONFIGURATION:                         'CONFIGURATION';
-CONSTRAINT:                            'CONSTRAINT';
-CONTAINMENT:                           'CONTAINMENT';
-CONTAINS:                              'CONTAINS';
-CONTAINSTABLE:                         'CONTAINSTABLE';
-CONTEXT:                               'CONTEXT';
-CONTINUE:                              'CONTINUE';
-CONTINUE_AFTER_ERROR:                  'CONTINUE_AFTER_ERROR';
-CONTRACT:                              'CONTRACT';
-CONTRACT_NAME:                         'CONTRACT_NAME';
-CONVERSATION:                          'CONVERSATION';
-CONVERT:                               'TRY_'? 'CONVERT';
-COPY_ONLY:                             'COPY_ONLY';
-CREATE:                                'CREATE';
-CROSS:                                 'CROSS';
-CURRENT:                               'CURRENT';
-CURRENT_DATE:                          'CURRENT_DATE';
-CURRENT_TIME:                          'CURRENT_TIME';
-CURRENT_TIMESTAMP:                     'CURRENT_TIMESTAMP';
-CURRENT_USER:                          'CURRENT_USER';
-CURSOR:                                'CURSOR';
-CYCLE:                                 'CYCLE';
-DATA_COMPRESSION:                      'DATA_COMPRESSION';
-DATA_SOURCE:                           'DATA_SOURCE';
-DATABASE:                              'DATABASE';
-DATABASE_MIRRORING:                    'DATABASE_MIRRORING';
-DBCC:                                  'DBCC';
-DEALLOCATE:                            'DEALLOCATE';
-DECLARE:                               'DECLARE';
-DEFAULT:                               'DEFAULT';
-DEFAULT_DATABASE:                      'DEFAULT_DATABASE';
-DEFAULT_SCHEMA:                        'DEFAULT_SCHEMA';
-DELETE:                                'DELETE';
-DENY:                                  'DENY';
-DESC:                                  'DESC';
-DIAGNOSTICS:                           'DIAGNOSTICS';
-DIFFERENTIAL:                          'DIFFERENTIAL';
-DISK:                                  'DISK';
-DISTINCT:                              'DISTINCT';
-DISTRIBUTED:                           'DISTRIBUTED';
-DOUBLE:                                'DOUBLE';
-DOUBLE_BACK_SLASH:                     '\\\\';
-DOUBLE_FORWARD_SLASH:                  '//';
-DROP:                                  'DROP';
-DTC_SUPPORT:                           'DTC_SUPPORT';
-DUMP:                                  'DUMP';
-ELSE:                                  'ELSE';
-ENABLED:                               'ENABLED';
-END:                                   'END';
-ENDPOINT:                              'ENDPOINT';
-ERRLVL:                                'ERRLVL';
-ESCAPE:                                'ESCAPE';
-ERROR:                                 'ERROR';
-EVENT:                                 'EVENT';
-EVENTDATA:                             'EVENTDATA' '(' ')';
-EVENT_RETENTION_MODE:                  'EVENT_RETENTION_MODE';
-EXCEPT:                                'EXCEPT';
-EXECUTABLE_FILE:                       'EXECUTABLE_FILE';
-EXECUTE:                               'EXEC' 'UTE'?;
-EXISTS:                                'EXISTS';
-EXPIREDATE:                            'EXPIREDATE';
-EXIT:                                  'EXIT';
-EXTENSION:                             'EXTENSION';
-EXTERNAL:                              'EXTERNAL';
-EXTERNAL_ACCESS:                       'EXTERNAL_ACCESS';
-FAILOVER:                              'FAILOVER';
-FAILURECONDITIONLEVEL:                 'FAILURECONDITIONLEVEL';
-FAN_IN:                                'FAN_IN';
-FETCH:                                 'FETCH';
-FILE:                                  'FILE';
-FILENAME:                              'FILENAME';
-FILLFACTOR:                            'FILLFACTOR';
-FILE_SNAPSHOT:                         'FILE_SNAPSHOT';
-FOR:                                   'FOR';
-FORCESEEK:                             'FORCESEEK';
-FORCE_SERVICE_ALLOW_DATA_LOSS:         'FORCE_SERVICE_ALLOW_DATA_LOSS';
-FOREIGN:                               'FOREIGN';
-FREETEXT:                              'FREETEXT';
-FREETEXTTABLE:                         'FREETEXTTABLE';
-FROM:                                  'FROM';
-FULL:                                  'FULL';
-FUNCTION:                              'FUNCTION';
-GET:                                   'GET';
-GOTO:                                  'GOTO';
-GOVERNOR:                              'GOVERNOR';
-GRANT:                                 'GRANT';
-GROUP:                                 'GROUP';
-HAVING:                                'HAVING';
-HASHED:                                'HASHED';
-HEALTHCHECKTIMEOUT:                    'HEALTHCHECKTIMEOUT';
-IDENTITY:                              'IDENTITY';
-IDENTITYCOL:                           'IDENTITYCOL';
-IDENTITY_INSERT:                       'IDENTITY_INSERT';
-IF:                                    'IF';
-IIF:                                   'IIF';
-IN:                                    'IN';
-INCLUDE:                               'INCLUDE';
-INCREMENT:                             'INCREMENT';
-INDEX:                                 'INDEX';
-INFINITE:                              'INFINITE';
-INIT:                                  'INIT';
-INNER:                                 'INNER';
-INSERT:                                'INSERT';
-INSTEAD:                               'INSTEAD';
-INTERSECT:                             'INTERSECT';
-INTO:                                  'INTO';
-IPV4_ADDR:                             [']? IPV4_OCTECT DOT IPV4_OCTECT DOT IPV4_OCTECT DOT IPV4_OCTECT [']?;
-IPV6_ADDR:                              [']?[0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[:][0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[:][0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[:][0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[:][0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[:][0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[:][0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[:][0-9A-F]?[0-9A-F]?[0-9A-F]?[0-9A-F]?[']?;
-IS:                                    'IS';
-ISNULL:                                'ISNULL';
-JOIN:                                  'JOIN';
-KERBEROS:                              'KERBEROS';
-KEY:                                   'KEY';
-KEY_PATH:                              'KEY_PATH';
-KEY_STORE_PROVIDER_NAME:               'KEY_STORE_PROVIDER_NAME';
-KILL:                                  'KILL';
-LANGUAGE:                              'LANGUAGE';
-LEFT:                                  'LEFT';
-LIBRARY:                               'LIBRARY';
-LIFETIME:                              'LIFETIME';
-LIKE:                                  'LIKE';
-LINENO:                                'LINENO';
-LINUX:                                 'LINUX';
-LISTENER_IP:                           'LISTENER_IP';
-LISTENER_PORT:                         'LISTENER_PORT';
-LOAD:                                  'LOAD';
-LOCAL_SERVICE_NAME:                    'LOCAL_SERVICE_NAME';
-LOG:                                   'LOG';
-MATCHED:                               'MATCHED';
-MASTER:                                'MASTER';
-MAX_MEMORY:                            'MAX_MEMORY';
-MAXTRANSFER:                           'MAXTRANSFER';
-MAXVALUE:                              'MAXVALUE';
-MAX_DISPATCH_LATENCY:                  'MAX_DISPATCH_LATENCY';
-MAX_EVENT_SIZE:                        'MAX_EVENT_SIZE';
-MAX_SIZE:                              'MAX_SIZE';
-MAX_OUTSTANDING_IO_PER_VOLUME:         'MAX_OUTSTANDING_IO_PER_VOLUME';
-MEDIADESCRIPTION:                      'MEDIADESCRIPTION';
-MEDIANAME:                             'MEDIANAME';
-MEMBER:                                'MEMBER';
-MEMORY_PARTITION_MODE:                 'MEMORY_PARTITION_MODE';
-MERGE:                                 'MERGE';
-MESSAGE_FORWARDING:                    'MESSAGE_FORWARDING';
-MESSAGE_FORWARD_SIZE:                  'MESSAGE_FORWARD_SIZE';
-MINVALUE:                              'MINVALUE';
-MIRROR:                                'MIRROR';
-MUST_CHANGE:                           'MUST_CHANGE';
-NATIONAL:                              'NATIONAL';
-NEGOTIATE:                             'NEGOTIATE';
-NOCHECK:                               'NOCHECK';
-NOFORMAT:                              'NOFORMAT';
-NOINIT:                                'NOINIT';
-NONCLUSTERED:                          'NONCLUSTERED';
-NONE:                                  'NONE';
-NOREWIND:                              'NOREWIND';
-NOSKIP:                                'NOSKIP';
-NOUNLOAD:                              'NOUNLOAD';
-NO_CHECKSUM:                           'NO_CHECKSUM';
-NO_COMPRESSION:                        'NO_COMPRESSION';
-NO_EVENT_LOSS:                         'NO_EVENT_LOSS';
-NOT:                                   'NOT';
-NOTIFICATION:                          'NOTIFICATION';
-NTLM:                                  'NTLM';
-NULL:                                  'NULL';
-NULLIF:                                'NULLIF';
-OF:                                    'OF';
-OFF:                                   'OFF';
-OFFSETS:                               'OFFSETS';
-OLD_PASSWORD:                          'OLD_PASSWORD';
-ON:                                    'ON';
-ON_FAILURE:                            'ON_FAILURE';
-OPEN:                                  'OPEN';
-OPENDATASOURCE:                        'OPENDATASOURCE';
-OPENQUERY:                             'OPENQUERY';
-OPENROWSET:                            'OPENROWSET';
-OPENXML:                               'OPENXML';
-OPTION:                                'OPTION';
-OR:                                    'OR';
-ORDER:                                 'ORDER';
-OUTER:                                 'OUTER';
-OVER:                                  'OVER';
-PAGE:                                  'PAGE';
-PARAM_NODE:                            'PARAM_NODE';
-PARTIAL:                               'PARTIAL';
-PASSWORD:                              'PASSWORD';
-PERCENT:                               'PERCENT';
-PERMISSION_SET:                        'PERMISSION_SET';
-PER_CPU:                               'PER_CPU';
-PER_DB:                                'PER_DB';
-PER_NODE:                              'PER_NODE';
-PIVOT:                                 'PIVOT';
-PLAN:                                  'PLAN';
-PLATFORM:                              'PLATFORM';
-POLICY:                                'POLICY';
-PRECISION:                             'PRECISION';
-PREDICATE:                             'PREDICATE';
-PRIMARY:                               'PRIMARY';
-PRINT:                                 'PRINT';
-PROC:                                  'PROC';
-PROCEDURE:                             'PROCEDURE';
-PROCESS:                               'PROCESS';
-PUBLIC:                                'PUBLIC';
-PYTHON:                                'PYTHON';
-R:                                     'R';
-RAISERROR:                             'RAISERROR';
-RAW:                                   'RAW';
-READ:                                  'READ';
-READTEXT:                              'READTEXT';
-READ_WRITE_FILEGROUPS:                 'READ_WRITE_FILEGROUPS';
-RECONFIGURE:                           'RECONFIGURE';
-REFERENCES:                            'REFERENCES';
-REGENERATE:                            'REGENERATE';
-RELATED_CONVERSATION:                  'RELATED_CONVERSATION';
-RELATED_CONVERSATION_GROUP:            'RELATED_CONVERSATION_GROUP';
-REPLICATION:                           'REPLICATION';
-REQUIRED:                              'REQUIRED';
-RESET:                                 'RESET';
-RESTART:                               'RESTART';
-RESTORE:                               'RESTORE';
-RESTRICT:                              'RESTRICT';
-RESUME:                                'RESUME';
-RETAINDAYS:                            'RETAINDAYS';
-RETURN:                                'RETURN';
-RETURNS:                               'RETURNS';
-REVERT:                                'REVERT';
-REVOKE:                                'REVOKE';
-REWIND:                                'REWIND';
-RIGHT:                                 'RIGHT';
-ROLLBACK:                              'ROLLBACK';
-ROLE:                                  'ROLE';
-ROWCOUNT:                              'ROWCOUNT';
-ROWGUIDCOL:                            'ROWGUIDCOL';
-RSA_512:                               'RSA_512';
-RSA_1024:                              'RSA_1024';
-RSA_2048:                              'RSA_2048';
-RSA_3072:                              'RSA_3072';
-RSA_4096:                              'RSA_4096';
-SAFETY:                                'SAFETY';
-RULE:                                  'RULE';
-SAFE:                                  'SAFE';
-SAVE:                                  'SAVE';
-SCHEDULER:                             'SCHEDULER';
-SCHEMA:                                'SCHEMA';
-SCHEME:                                'SCHEME';
-SECURITYAUDIT:                         'SECURITYAUDIT';
-SELECT:                                'SELECT';
-SEMANTICKEYPHRASETABLE:                'SEMANTICKEYPHRASETABLE';
-SEMANTICSIMILARITYDETAILSTABLE:        'SEMANTICSIMILARITYDETAILSTABLE';
-SEMANTICSIMILARITYTABLE:               'SEMANTICSIMILARITYTABLE';
-SERVER:                                'SERVER';
-SERVICE:                               'SERVICE';
-SERVICE_BROKER:                        'SERVICE_BROKER';
-SERVICE_NAME:                          'SERVICE_NAME';
-SESSION:                               'SESSION';
-SESSION_USER:                          'SESSION_USER';
-SET:                                   'SET';
-SETUSER:                               'SETUSER';
-SHUTDOWN:                              'SHUTDOWN';
-SID:                                   'SID';
-SKIP_KEYWORD:                          'SKIP';
-SOFTNUMA:                              'SOFTNUMA';
-SOME:                                  'SOME';
-SOURCE:                                'SOURCE';
-SPECIFICATION:                         'SPECIFICATION';
-SPLIT:                                 'SPLIT';
-SQLDUMPERFLAGS:                        'SQLDUMPERFLAGS';
-SQLDUMPERPATH:                         'SQLDUMPERPATH';
-SQLDUMPERTIMEOUT:                      'SQLDUMPERTIMEOUTS';
-STATISTICS:                            'STATISTICS';
-STATE:                                 'STATE';
-STATS:                                 'STATS';
-START:                                 'START';
-STARTED:                               'STARTED';
-STARTUP_STATE:                         'STARTUP_STATE';
-STOP:                                  'STOP';
-STOPPED:                               'STOPPED';
-STOP_ON_ERROR:                         'STOP_ON_ERROR';
-SUPPORTED:                             'SUPPORTED';
-SYSTEM_USER:                           'SYSTEM_USER';
-TABLE:                                 'TABLE';
-TABLESAMPLE:                           'TABLESAMPLE';
-TAPE:                                  'TAPE';
-TARGET:                                'TARGET';
-TCP:                                   'TCP';
-TEXTSIZE:                              'TEXTSIZE';
-THEN:                                  'THEN';
-TO:                                    'TO';
-TOP:                                   'TOP';
-TRACK_CAUSALITY:                       'TRACK_CAUSALITY';
-TRAN:                                  'TRAN';
-TRANSACTION:                           'TRANSACTION';
-TRANSFER:                              'TRANSFER';
-TRIGGER:                               'TRIGGER';
-TRUNCATE:                              'TRUNCATE';
-TSEQUAL:                               'TSEQUAL';
-UNCHECKED:                             'UNCHECKED';
-UNION:                                 'UNION';
-UNIQUE:                                'UNIQUE';
-UNLOCK:                                'UNLOCK';
-UNPIVOT:                               'UNPIVOT';
-UNSAFE:                                'UNSAFE';
-UPDATE:                                'UPDATE';
-UPDATETEXT:                            'UPDATETEXT';
-URL:                                   'URL';
-USE:                                   'USE';
-USED:                                  'USED';
-USER:                                  'USER';
-VALUES:                                'VALUES';
-VARYING:                               'VARYING';
-VERBOSELOGGING:                        'VERBOSELOGGING';
-VIEW:                                  'VIEW';
-VISIBILITY:                            'VISIBILITY';
-WAITFOR:                               'WAITFOR';
-WHEN:                                  'WHEN';
-WHERE:                                 'WHERE';
-WHILE:                                 'WHILE';
-WINDOWS:                               'WINDOWS';
-WITH:                                  'WITH';
-WITHIN:                                'WITHIN';
-WITHOUT:                               'WITHOUT';
-WITNESS:                               'WITNESS';
-WRITETEXT:                             'WRITETEXT';
-
-// Additional keywords. They can be id, please keep them in sync with the parser.
-ABSOLUTE:                              'ABSOLUTE';
-ACCENT_SENSITIVITY:                    'ACCENT_SENSITIVITY';
-ACTION:                                'ACTION';
-ACTIVATION:                            'ACTIVATION';
-ACTIVE:                                'ACTIVE';
-ADDRESS:                               'ADDRESS';
-AES_128:                               'AES_128';
-AES_192:                               'AES_192';
-AES_256:                               'AES_256';
-AFFINITY:                              'AFFINITY';
-AFTER:                                 'AFTER';
-AGGREGATE:                             'AGGREGATE';
-ALGORITHM:                             'ALGORITHM';
-ALLOW_ENCRYPTED_VALUE_MODIFICATIONS:   'ALLOW_ENCRYPTED_VALUE_MODIFICATIONS';
-ALLOW_SNAPSHOT_ISOLATION:              'ALLOW_SNAPSHOT_ISOLATION';
-ALLOWED:                               'ALLOWED';
-ANSI_NULL_DEFAULT:                     'ANSI_NULL_DEFAULT';
-ANSI_NULLS:                            'ANSI_NULLS';
-ANSI_PADDING:                          'ANSI_PADDING';
-ANSI_WARNINGS:                         'ANSI_WARNINGS';
-APPLICATION_LOG:                       'APPLICATION_LOG';
-APPLY:                                 'APPLY';
-ARITHABORT:                            'ARITHABORT';
-ASSEMBLY:                              'ASSEMBLY';
-AUDIT:                                 'AUDIT';
-AUDIT_GUID:                            'AUDIT_GUID';
-AUTO:                                  'AUTO';
-AUTO_CLEANUP:                          'AUTO_CLEANUP';
-AUTO_CLOSE:                            'AUTO_CLOSE';
-AUTO_CREATE_STATISTICS:                'AUTO_CREATE_STATISTICS';
-AUTO_SHRINK:                           'AUTO_SHRINK';
-AUTO_UPDATE_STATISTICS:                'AUTO_UPDATE_STATISTICS';
-AUTO_UPDATE_STATISTICS_ASYNC:          'AUTO_UPDATE_STATISTICS_ASYNC';
-AVAILABILITY:                          'AVAILABILITY';
-AVG:                                   'AVG';
-BACKUP_PRIORITY:                       'BACKUP_PRIORITY';
-BEGIN_DIALOG:                          'BEGIN_DIALOG';
-BIGINT:                                'BIGINT';
-BINARY_BASE64:                         'BINARY BASE64';
-BINARY_CHECKSUM:                       'BINARY_CHECKSUM';
-BINDING:                               'BINDING';
-BLOB_STORAGE:                          'BLOB_STORAGE';
-BROKER:                                'BROKER';
-BROKER_INSTANCE:                       'BROKER_INSTANCE';
-BULK_LOGGED:                           'BULK_LOGGED';
-CALLER:                                'CALLER';
-CAP_CPU_PERCENT:                       'CAP_CPU_PERCENT';
-CAST:                                  'TRY_'? 'CAST';
-CATALOG:                               'CATALOG';
-CATCH:                                 'CATCH';
-CHANGE_RETENTION:                      'CHANGE_RETENTION';
-CHANGE_TRACKING:                       'CHANGE_TRACKING';
-CHECKSUM:                              'CHECKSUM';
-CHECKSUM_AGG:                          'CHECKSUM_AGG';
-CLEANUP:                               'CLEANUP';
-COLLECTION:                            'COLLECTION';
-COLUMN_MASTER_KEY:                     'COLUMN_MASTER_KEY';
-COMMITTED:                             'COMMITTED';
-COMPATIBILITY_LEVEL:                   'COMPATIBILITY_LEVEL';
-CONCAT:                                'CONCAT';
-CONCAT_NULL_YIELDS_NULL:               'CONCAT_NULL_YIELDS_NULL';
-CONTENT:                               'CONTENT';
-CONTROL:                               'CONTROL';
-COOKIE:                                'COOKIE';
-COUNT:                                 'COUNT';
-COUNT_BIG:                             'COUNT_BIG';
-COUNTER:                               'COUNTER';
-CPU:                                   'CPU';
-CREATE_NEW:                            'CREATE_NEW';
-CREATION_DISPOSITION:                  'CREATION_DISPOSITION';
-CREDENTIAL:                            'CREDENTIAL';
-CRYPTOGRAPHIC:                         'CRYPTOGRAPHIC';
-CURSOR_CLOSE_ON_COMMIT:                'CURSOR_CLOSE_ON_COMMIT';
-CURSOR_DEFAULT:                        'CURSOR_DEFAULT';
-DATA:                                  'DATA';
-DATE_CORRELATION_OPTIMIZATION:         'DATE_CORRELATION_OPTIMIZATION';
-DATEADD:                               'DATEADD';
-DATEDIFF:                              'DATEDIFF';
-DATENAME:                              'DATENAME';
-DATEPART:                              'DATEPART';
-DAYS:                                  'DAYS';
-DB_CHAINING:                           'DB_CHAINING';
-DB_FAILOVER:                           'DB_FAILOVER';
-DECRYPTION:                            'DECRYPTION';
-DEFAULT_DOUBLE_QUOTE:                  ["]'DEFAULT'["];
-DEFAULT_FULLTEXT_LANGUAGE:             'DEFAULT_FULLTEXT_LANGUAGE';
-DEFAULT_LANGUAGE:                      'DEFAULT_LANGUAGE';
-DELAY:                                 'DELAY';
-DELAYED_DURABILITY:                    'DELAYED_DURABILITY';
-DELETED:                               'DELETED';
-DENSE_RANK:                            'DENSE_RANK';
-DEPENDENTS:                            'DEPENDENTS';
-DES:                                   'DES';
-DESCRIPTION:                           'DESCRIPTION';
-DESX:                                  'DESX';
-DHCP:                                  'DHCP';
-DIALOG:                                'DIALOG';
-DIRECTORY_NAME:                        'DIRECTORY_NAME';
-DISABLE:                               'DISABLE';
-DISABLE_BROKER:                        'DISABLE_BROKER';
-DISABLED:                              'DISABLED';
-DISK_DRIVE:                            [A-Z][:];
-DOCUMENT:                              'DOCUMENT';
-DYNAMIC:                               'DYNAMIC';
-ELEMENTS:                              'ELEMENTS';
-EMERGENCY:                             'EMERGENCY';
-EMPTY:                                 'EMPTY';
-ENABLE:                                'ENABLE';
-ENABLE_BROKER:                         'ENABLE_BROKER';
-ENCRYPTED_VALUE:                       'ENCRYPTED_VALUE';
-ENCRYPTION:                            'ENCRYPTION';
-ENDPOINT_URL:                          'ENDPOINT_URL';
-ERROR_BROKER_CONVERSATIONS:            'ERROR_BROKER_CONVERSATIONS';
-EXCLUSIVE:                             'EXCLUSIVE';
-EXECUTABLE:                            'EXECUTABLE';
-EXIST:                                 'EXIST';
-EXPAND:                                'EXPAND';
-EXPIRY_DATE:                           'EXPIRY_DATE';
-EXPLICIT:                              'EXPLICIT';
-FAIL_OPERATION:                        'FAIL_OPERATION';
-FAILOVER_MODE:                         'FAILOVER_MODE';
-FAILURE:                               'FAILURE';
-FAILURE_CONDITION_LEVEL:               'FAILURE_CONDITION_LEVEL';
-FAST:                                  'FAST';
-FAST_FORWARD:                          'FAST_FORWARD';
-FILEGROUP:                             'FILEGROUP';
-FILEGROWTH:                            'FILEGROWTH';
-FILEPATH:                              'FILEPATH';
-FILESTREAM:                            'FILESTREAM';
-FILTER:                                'FILTER';
-FIRST:                                 'FIRST';
-FIRST_VALUE:                           'FIRST_VALUE';
-FOLLOWING:                             'FOLLOWING';
-FORCE:                                 'FORCE';
-FORCE_FAILOVER_ALLOW_DATA_LOSS:        'FORCE_FAILOVER_ALLOW_DATA_LOSS';
-FORCED:                                'FORCED';
-FORMAT:                                'FORMAT';
-FORWARD_ONLY:                          'FORWARD_ONLY';
-FULLSCAN:                              'FULLSCAN';
-FULLTEXT:                              'FULLTEXT';
-GB:                                    'GB';
-GETDATE:                               'GETDATE';
-GETUTCDATE:                            'GETUTCDATE';
-GLOBAL:                                'GLOBAL';
-GO:                                    'GO';
-GROUP_MAX_REQUESTS:                    'GROUP_MAX_REQUESTS';
-GROUPING:                              'GROUPING';
-GROUPING_ID:                           'GROUPING_ID';
-HADR:                                  'HADR';
-HASH:                                  'HASH';
-HEALTH_CHECK_TIMEOUT:                  'HEALTH_CHECK_TIMEOUT';
-HIGH:                                  'HIGH';
-HONOR_BROKER_PRIORITY:                 'HONOR_BROKER_PRIORITY';
-HOURS:                                 'HOURS';
-IDENTITY_VALUE:                        'IDENTITY_VALUE';
-IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX: 'IGNORE_NONCLUSTERED_COLUMNSTORE_INDEX';
-IMMEDIATE:                             'IMMEDIATE';
-IMPERSONATE:                           'IMPERSONATE';
-IMPORTANCE:                            'IMPORTANCE';
-INCLUDE_NULL_VALUES:                   'INCLUDE_NULL_VALUES';
-INCREMENTAL:                           'INCREMENTAL';
-INITIATOR:                             'INITIATOR';
-INPUT:                                 'INPUT';
-INSENSITIVE:                           'INSENSITIVE';
-INSERTED:                              'INSERTED';
-INT:                                   'INT';
-IP:                                    'IP';
-ISOLATION:                             'ISOLATION';
-JOB:                                   'JOB';
-JSON:                                  'JSON';
-KB:                                    'KB';
-KEEP:                                  'KEEP';
-KEEPFIXED:                             'KEEPFIXED';
-KEY_SOURCE:                            'KEY_SOURCE';
-KEYS:                                  'KEYS';
-KEYSET:                                'KEYSET';
-LAG:                                   'LAG';
-LAST:                                  'LAST';
-LAST_VALUE:                            'LAST_VALUE';
-LEAD:                                  'LEAD';
-LEVEL:                                 'LEVEL';
-LIST:                                  'LIST';
-LISTENER:                              'LISTENER';
-LISTENER_URL:                          'LISTENER_URL';
-LOB_COMPACTION:                        'LOB_COMPACTION';
-LOCAL:                                 'LOCAL';
-LOCATION:                              'LOCATION';
-LOCK:                                  'LOCK';
-LOCK_ESCALATION:                       'LOCK_ESCALATION';
-LOGIN:                                 'LOGIN';
-LOOP:                                  'LOOP';
-LOW:                                   'LOW';
-MANUAL:                                'MANUAL';
-MARK:                                  'MARK';
-MATERIALIZED:                          'MATERIALIZED';
-MAX:                                   'MAX';
-MAX_CPU_PERCENT:                       'MAX_CPU_PERCENT';
-MAX_DOP:                               'MAX_DOP';
-MAX_FILES:                             'MAX_FILES';
-MAX_IOPS_PER_VOLUME:                   'MAX_IOPS_PER_VOLUME';
-MAX_MEMORY_PERCENT:                    'MAX_MEMORY_PERCENT';
-MAX_PROCESSES:                         'MAX_PROCESSES';
-MAX_QUEUE_READERS:                     'MAX_QUEUE_READERS';
-MAX_ROLLOVER_FILES:                    'MAX_ROLLOVER_FILES';
-MAXDOP:                                'MAXDOP';
-MAXRECURSION:                          'MAXRECURSION';
-MAXSIZE:                               'MAXSIZE';
-MB:                                    'MB';
-MEDIUM:                                'MEDIUM';
-MEMORY_OPTIMIZED_DATA:                 'MEMORY_OPTIMIZED_DATA';
-MESSAGE:                               'MESSAGE';
-MIN:                                   'MIN';
-MIN_ACTIVE_ROWVERSION:                 'MIN_ACTIVE_ROWVERSION';
-MIN_CPU_PERCENT:                       'MIN_CPU_PERCENT';
-MIN_IOPS_PER_VOLUME:                   'MIN_IOPS_PER_VOLUME';
-MIN_MEMORY_PERCENT:                    'MIN_MEMORY_PERCENT';
-MINUTES:                               'MINUTES';
-MIRROR_ADDRESS:                        'MIRROR_ADDRESS';
-MIXED_PAGE_ALLOCATION:                 'MIXED_PAGE_ALLOCATION';
-MODE:                                  'MODE';
-MODIFY:                                'MODIFY';
-MOVE:                                  'MOVE';
-MULTI_USER:                            'MULTI_USER';
-NAME:                                  'NAME';
-NESTED_TRIGGERS:                       'NESTED_TRIGGERS';
-NEW_ACCOUNT:                           'NEW_ACCOUNT';
-NEW_BROKER:                            'NEW_BROKER';
-NEW_PASSWORD:                          'NEW_PASSWORD';
-NEXT:                                  'NEXT';
-NO:                                    'NO';
-NO_TRUNCATE:                           'NO_TRUNCATE';
-NO_WAIT:                               'NO_WAIT';
-NOCOUNT:                               'NOCOUNT';
-NODES:                                 'NODES';
-NOEXPAND:                              'NOEXPAND';
-NON_TRANSACTED_ACCESS:                 'NON_TRANSACTED_ACCESS';
-NORECOMPUTE:                           'NORECOMPUTE';
-NORECOVERY:                            'NORECOVERY';
-NOWAIT:                                'NOWAIT';
-NTILE:                                 'NTILE';
-NUMANODE:                              'NUMANODE';
-NUMBER:                                'NUMBER';
-NUMERIC_ROUNDABORT:                    'NUMERIC_ROUNDABORT';
-OBJECT:                                'OBJECT';
-OFFLINE:                               'OFFLINE';
-OFFSET:                                'OFFSET';
-OLD_ACCOUNT:                           'OLD_ACCOUNT';
-ONLINE:                                'ONLINE';
-ONLY:                                  'ONLY';
-OPEN_EXISTING:                         'OPEN_EXISTING';
-OPTIMISTIC:                            'OPTIMISTIC';
-OPTIMIZE:                              'OPTIMIZE';
-OUT:                                   'OUT';
-OUTPUT:                                'OUTPUT';
-OVERRIDE:                              'OVERRIDE';
-OWNER:                                 'OWNER';
-PAGE_VERIFY:                           'PAGE_VERIFY';
-PARAMETERIZATION:                      'PARAMETERIZATION';
-PARTITION:                             'PARTITION';
-PARTITIONS:                            'PARTITIONS';
-PARTNER:                               'PARTNER';
-PATH:                                  'PATH';
-POISON_MESSAGE_HANDLING:               'POISON_MESSAGE_HANDLING';
-POOL:                                  'POOL';
-PORT:                                  'PORT';
-PRECEDING:                             'PRECEDING';
-PRIMARY_ROLE:                          'PRIMARY_ROLE';
-PRIOR:                                 'PRIOR';
-PRIORITY:                              'PRIORITY';
-PRIORITY_LEVEL:                        'PRIORITY_LEVEL';
-PRIVATE:                               'PRIVATE';
-PRIVATE_KEY:                           'PRIVATE_KEY';
-PRIVILEGES:                            'PRIVILEGES';
-PROCEDURE_NAME:                        'PROCEDURE_NAME';
-PROPERTY:                              'PROPERTY';
-PROVIDER:                              'PROVIDER';
-PROVIDER_KEY_NAME:                     'PROVIDER_KEY_NAME';
-QUERY:                                 'QUERY';
-QUEUE:                                 'QUEUE';
-QUEUE_DELAY:                           'QUEUE_DELAY';
-QUOTED_IDENTIFIER:                     'QUOTED_IDENTIFIER';
-RANGE:                                 'RANGE';
-RANK:                                  'RANK';
-RC2:                                   'RC2';
-RC4:                                   'RC4';
-RC4_128:                               'RC4_128';
-READ_COMMITTED_SNAPSHOT:               'READ_COMMITTED_SNAPSHOT';
-READ_ONLY:                             'READ_ONLY';
-READ_ONLY_ROUTING_LIST:                'READ_ONLY_ROUTING_LIST';
-READ_WRITE:                            'READ_WRITE';
-READONLY:                              'READONLY';
-REBUILD:                               'REBUILD';
-RECEIVE:                               'RECEIVE';
-RECOMPILE:                             'RECOMPILE';
-RECOVERY:                              'RECOVERY';
-RECURSIVE_TRIGGERS:                    'RECURSIVE_TRIGGERS';
-RELATIVE:                              'RELATIVE';
-REMOTE:                                'REMOTE';
-REMOTE_SERVICE_NAME:                   'REMOTE_SERVICE_NAME';
-REMOVE:                                'REMOVE';
-REORGANIZE:                            'REORGANIZE';
-REPEATABLE:                            'REPEATABLE';
-REPLICA:                               'REPLICA';
-REQUEST_MAX_CPU_TIME_SEC:              'REQUEST_MAX_CPU_TIME_SEC';
-REQUEST_MAX_MEMORY_GRANT_PERCENT:      'REQUEST_MAX_MEMORY_GRANT_PERCENT';
-REQUEST_MEMORY_GRANT_TIMEOUT_SEC:      'REQUEST_MEMORY_GRANT_TIMEOUT_SEC';
-REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT: 'REQUIRED_SYNCHRONIZED_SECONDARIES_TO_COMMIT';
-RESERVE_DISK_SPACE:                    'RESERVE_DISK_SPACE';
-RESOURCE:                              'RESOURCE';
-RESOURCE_MANAGER_LOCATION:             'RESOURCE_MANAGER_LOCATION';
-RESTRICTED_USER:                       'RESTRICTED_USER';
-RETENTION:                             'RETENTION';
-ROBUST:                                'ROBUST';
-ROOT:                                  'ROOT';
-ROUTE:                                 'ROUTE';
-ROW:                                   'ROW';
-ROW_NUMBER:                            'ROW_NUMBER';
-ROWGUID:                               'ROWGUID';
-ROWS:                                  'ROWS';
-SAMPLE:                                'SAMPLE';
-SCHEMABINDING:                         'SCHEMABINDING';
-SCOPED:                                'SCOPED';
-SCROLL:                                'SCROLL';
-SCROLL_LOCKS:                          'SCROLL_LOCKS';
-SEARCH:                                'SEARCH';
-SECONDARY:                             'SECONDARY';
-SECONDARY_ONLY:                        'SECONDARY_ONLY';
-SECONDARY_ROLE:                        'SECONDARY_ROLE';
-SECONDS:                               'SECONDS';
-SECRET:                                'SECRET';
-SECURITY:                              'SECURITY';
-SECURITY_LOG:                          'SECURITY_LOG';
-SEEDING_MODE:                          'SEEDING_MODE';
-SELF:                                  'SELF';
-SEMI_SENSITIVE:                        'SEMI_SENSITIVE';
-SEND:                                  'SEND';
-SENT:                                  'SENT';
-SEQUENCE:                              'SEQUENCE';
-SERIALIZABLE:                          'SERIALIZABLE';
-SESSION_TIMEOUT:                       'SESSION_TIMEOUT';
-SETERROR:                              'SETERROR';
-SHARE:                                 'SHARE';
-SHOWPLAN:                              'SHOWPLAN';
-SIGNATURE:                             'SIGNATURE';
-SIMPLE:                                'SIMPLE';
-SINGLE_USER:                           'SINGLE_USER';
-SIZE:                                  'SIZE';
-SMALLINT:                              'SMALLINT';
-SNAPSHOT:                              'SNAPSHOT';
-SPATIAL_WINDOW_MAX_CELLS:              'SPATIAL_WINDOW_MAX_CELLS';
-STANDBY:                               'STANDBY';
-START_DATE:                            'START_DATE';
-STATIC:                                'STATIC';
-STATS_STREAM:                          'STATS_STREAM';
-STATUS:                                'STATUS';
-STATUSONLY:                            'STATUSONLY';
-STDEV:                                 'STDEV';
-STDEVP:                                'STDEVP';
-STOPLIST:                              'STOPLIST';
-STRING_AGG:                            'STRING_AGG';
-STUFF:                                 'STUFF';
-SUBJECT:                               'SUBJECT';
-SUBSCRIPTION:                          'SUBSCRIPTION';
-SUM:                                   'SUM';
-SUSPEND:                               'SUSPEND';
-SYMMETRIC:                             'SYMMETRIC';
-SYNCHRONOUS_COMMIT:                    'SYNCHRONOUS_COMMIT';
-SYNONYM:                               'SYNONYM';
-SYSTEM:                                'SYSTEM';
-TAKE:                                  'TAKE';
-TARGET_RECOVERY_TIME:                  'TARGET_RECOVERY_TIME';
-TB:                                    'TB';
-TEXTIMAGE_ON:                          'TEXTIMAGE_ON';
-THROW:                                 'THROW';
-TIES:                                  'TIES';
-TIME:                                  'TIME';
-TIMEOUT:                               'TIMEOUT';
-TIMER:                                 'TIMER';
-TINYINT:                               'TINYINT';
-TORN_PAGE_DETECTION:                   'TORN_PAGE_DETECTION';
-TRANSFORM_NOISE_WORDS:                 'TRANSFORM_NOISE_WORDS';
-TRIPLE_DES:                            'TRIPLE_DES';
-TRIPLE_DES_3KEY:                       'TRIPLE_DES_3KEY';
-TRUSTWORTHY:                           'TRUSTWORTHY';
-TRY:                                   'TRY';
-TSQL:                                  'TSQL';
-TWO_DIGIT_YEAR_CUTOFF:                 'TWO_DIGIT_YEAR_CUTOFF';
-TYPE:                                  'TYPE';
-TYPE_WARNING:                          'TYPE_WARNING';
-UNBOUNDED:                             'UNBOUNDED';
-UNCOMMITTED:                           'UNCOMMITTED';
-UNKNOWN:                               'UNKNOWN';
-UNLIMITED:                             'UNLIMITED';
-UOW:                                   'UOW';
-USING:                                 'USING';
-VALID_XML:                             'VALID_XML';
-VALIDATION:                            'VALIDATION';
-VALUE:                                 'VALUE';
-VAR:                                   'VAR';
-VARP:                                  'VARP';
-VIEW_METADATA:                         'VIEW_METADATA';
-VIEWS:                                 'VIEWS';
-WAIT:                                  'WAIT';
-WELL_FORMED_XML:                       'WELL_FORMED_XML';
-WITHOUT_ARRAY_WRAPPER:                 'WITHOUT_ARRAY_WRAPPER';
-WORK:                                  'WORK';
-WORKLOAD:                              'WORKLOAD';
-XML:                                   'XML';
-XMLDATA:                               'XMLDATA';
-XMLNAMESPACES:                         'XMLNAMESPACES';
-XMLSCHEMA:                             'XMLSCHEMA';
-XSINIL:                                'XSINIL';
-
-DOLLAR_ACTION:                         '$ACTION';
-
-SPACE:              [ \t\r\n]+    -> skip;
-// https://docs.microsoft.com/en-us/sql/t-sql/language-elements/slash-star-comment-transact-sql
-COMMENT:            '/*' (COMMENT | .)*? '*/' -> channel(HIDDEN);
-LINE_COMMENT:       '--' ~[\r\n]* -> channel(HIDDEN);
-
-// TODO: ID can be not only Latin.
-DOUBLE_QUOTE_ID:    '"' ~'"'+ '"';
-SINGLE_QUOTE:       '\'';
-SQUARE_BRACKET_ID:  '[' ~']'+ ']';
-LOCAL_ID:           '@' ([A-Z_$@#0-9] | FullWidthLetter)+;
-DECIMAL:             DEC_DIGIT+;
-ID:                  ( [A-Z_#] | FullWidthLetter) ( [A-Z_#$@0-9] | FullWidthLetter )*;
-QUOTED_URL:          '\''([A-Z][A-Z]+[:]) '//'(([A-Z]+[.]|[A-Z]+)|IPV4_ADDR) [:] DECIMAL '\'';
-QUOTED_HOST_AND_PORT:'\''(([A-Z]+[.]|[A-Z]+)|IPV4_ADDR) ([:] DECIMAL) '\'';
-STRING:              'N'? '\'' (~'\'' | '\'\'')* '\'';
-BINARY:              '0' 'X' HEX_DIGIT*;
-FLOAT:               DEC_DOT_DEC;
-REAL:                (DECIMAL | DEC_DOT_DEC) ('E' [+-]? DEC_DIGIT+);
-
-EQUAL:               '=';
-
-GREATER:             '>';
-LESS:                '<';
-EXCLAMATION:         '!';
-
-PLUS_ASSIGN:         '+=';
-MINUS_ASSIGN:        '-=';
-MULT_ASSIGN:         '*=';
-DIV_ASSIGN:          '/=';
-MOD_ASSIGN:          '%=';
-AND_ASSIGN:          '&=';
-XOR_ASSIGN:          '^=';
-OR_ASSIGN:           '|=';
-
-DOUBLE_BAR:          '||';
-DOT:                 '.';
-UNDERLINE:           '_';
-AT:                  '@';
-SHARP:               '#';
-DOLLAR:              '$';
-LR_BRACKET:          '(';
-RR_BRACKET:          ')';
-COMMA:               ',';
-SEMI:                ';';
-COLON:               ':';
-STAR:                '*';
-DIVIDE:              '/';
-MODULE:              '%';
-PLUS:                '+';
-MINUS:               '-';
-BIT_NOT:             '~';
-BIT_OR:              '|';
-BIT_AND:             '&';
-BIT_XOR:             '^';
-
-fragment LETTER:       [A-Z_];
-fragment IPV6_OCTECT:  [0-9A-F][0-9A-F][0-9A-F][0-9A-F];
-IPV4_OCTECT:           [0-9]?[0-9]?[0-9];
-fragment DEC_DOT_DEC:  (DEC_DIGIT+ '.' DEC_DIGIT+ |  DEC_DIGIT+ '.' | '.' DEC_DIGIT+);
-fragment HEX_DIGIT:    [0-9A-F];
-fragment DEC_DIGIT:    [0-9];
-
-fragment FullWidthLetter
-    : '\u00c0'..'\u00d6'
-    | '\u00d8'..'\u00f6'
-    | '\u00f8'..'\u00ff'
-    | '\u0100'..'\u1fff'
-    | '\u2c00'..'\u2fff'
-    | '\u3040'..'\u318f'
-    | '\u3300'..'\u337f'
-    | '\u3400'..'\u3fff'
-    | '\u4e00'..'\u9fff'
-    | '\ua000'..'\ud7ff'
-    | '\uf900'..'\ufaff'
-    | '\uff00'..'\ufff0'
-    // | '\u10000'..'\u1F9FF'  //not support four bytes chars
-    // | '\u20000'..'\u2FA1F'
-    ;

src/index.ts

@@ -1,2 +1,2 @@
-export * from './core';
+export * from './parser';
 export * from './utils';

src/lib/hive/HiveSql.tokens

@@ -0,0 +1,384 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+T__5=6
+T__6=7
+T__7=8
+T__8=9
+T__9=10
+T_GO=11
+T_BEGIN=12
+T_SEMICOLON=13
+T_END=14
+T_EXCEPTION=15
+T_WHEN=16
+L_ID=17
+T_THEN=18
+T_NULL=19
+T_SET=20
+T_COMMA=21
+T_COLON=22
+T_EQUAL=23
+T_OPEN_P=24
+T_CLOSE_P=25
+T_ALLOCATE=26
+T_CURSOR=27
+T_FOR=28
+T_RESULT=29
+T_PROCEDURE=30
+T_ASSOCIATE=31
+T_LOCATOR=32
+T_LOCATORS=33
+T_WITH=34
+T_TRANSACTION=35
+T_BREAK=36
+T_CALL=37
+T_DECLARE=38
+T_AS=39
+T_CONSTANT=40
+T_CONDITION=41
+T_IS=42
+T_RETURN=43
+T_ONLY=44
+T_TO=45
+T_CALLER=46
+T_CLIENT=47
+T_WITHOUT=48
+T_CONTINUE=49
+T_EXIT=50
+T_HANDLER=51
+T_SQLEXCEPTION=52
+T_SQLWARNING=53
+T_NOT=54
+T_FOUND=55
+T_GLOBAL=56
+T_TEMPORARY=57
+T_TABLE=58
+T_CREATE=59
+T_IF=60
+T_EXISTS=61
+T_LOCAL=62
+T_MULTISET=63
+T_VOLATILE=64
+T_LIKE=65
+T_CONSTRAINT=66
+T_PRIMARY=67
+T_KEY=68
+T_UNIQUE=69
+T_REFERENCES=70
+T_IDENTITY=71
+L_INT=72
+T_AUTO_INCREMENT=73
+T_ENABLE=74
+T_CLUSTERED=75
+T_ASC=76
+T_DESC=77
+T_FOREIGN=78
+T_ON=79
+T_UPDATE=80
+T_DELETE=81
+T_NO=82
+T_ACTION=83
+T_RESTRICT=84
+T_DEFAULT=85
+T_CASCADE=86
+T_LOG=87
+T_FALLBACK=88
+T_COMMIT=89
+T_PRESERVE=90
+T_ROWS=91
+T_SEGMENT=92
+T_CREATION=93
+T_IMMEDIATE=94
+T_DEFERRED=95
+T_PCTFREE=96
+T_PCTUSED=97
+T_INITRANS=98
+T_MAXTRANS=99
+T_NOCOMPRESS=100
+T_LOGGING=101
+T_NOLOGGING=102
+T_STORAGE=103
+T_TABLESPACE=104
+T_INDEX=105
+T_IN=106
+T_REPLACE=107
+T_DISTRIBUTE=108
+T_BY=109
+T_HASH=110
+T_LOGGED=111
+T_COMPRESS=112
+T_YES=113
+T_DEFINITION=114
+T_DROP=115
+T_DATA=116
+T_STORED=117
+T_ROW=118
+T_FORMAT=119
+T_DELIMITED=120
+T_FIELDS=121
+T_TERMINATED=122
+T_ESCAPED=123
+T_COLLECTION=124
+T_ITEMS=125
+T_MAP=126
+T_KEYS=127
+T_LINES=128
+T_DEFINED=129
+T_TEXTIMAGE_ON=130
+T_COMMENT=131
+T_CHARACTER=132
+T_CHARSET=133
+T_ENGINE=134
+T_ALTER=135
+T_ADD2=136
+T_CHAR=137
+T_BIGINT=138
+T_BINARY_DOUBLE=139
+T_BINARY_FLOAT=140
+T_BINARY_INTEGER=141
+T_BIT=142
+T_DATE=143
+T_DATETIME=144
+T_DEC=145
+T_DECIMAL=146
+T_DOUBLE=147
+T_PRECISION=148
+T_FLOAT=149
+T_INT=150
+T_INT2=151
+T_INT4=152
+T_INT8=153
+T_INTEGER=154
+T_NCHAR=155
+T_NVARCHAR=156
+T_NUMBER=157
+T_NUMERIC=158
+T_PLS_INTEGER=159
+T_REAL=160
+T_RESULT_SET_LOCATOR=161
+T_VARYING=162
+T_SIMPLE_FLOAT=163
+T_SIMPLE_DOUBLE=164
+T_SIMPLE_INTEGER=165
+T_SMALLINT=166
+T_SMALLDATETIME=167
+T_STRING=168
+T_SYS_REFCURSOR=169
+T_TIMESTAMP=170
+T_TINYINT=171
+T_VARCHAR=172
+T_VARCHAR2=173
+T_XML=174
+T_TYPE=175
+T_ROWTYPE=176
+T_MAX=177
+T_BYTE=178
+T_CASESPECIFIC=179
+T_CS=180
+T_DATABASE=181
+T_SCHEMA=182
+T_LOCATION=183
+T_OR=184
+T_FUNCTION=185
+T_RETURNS=186
+T_PACKAGE=187
+T_PROC=188
+T_BODY=189
+T_OUT=190
+T_INOUT=191
+T_LANGUAGE=192
+T_SQL=193
+T_SECURITY=194
+T_CREATOR=195
+T_DEFINER=196
+T_INVOKER=197
+T_OWNER=198
+T_DYNAMIC=199
+T_SETS=200
+T_EXEC=201
+T_EXECUTE=202
+T_INTO=203
+T_ELSE=204
+T_ELSIF=205
+T_ELSEIF=206
+T_INCLUDE=207
+T_INSERT=208
+T_OVERWRITE=209
+T_VALUES=210
+T_DIRECTORY=211
+T_GET=212
+T_DIAGNOSTICS=213
+T_MESSAGE_TEXT=214
+T_ROW_COUNT=215
+T_GRANT=216
+T_ROLE=217
+T_LEAVE=218
+T_OBJECT=219
+T_AT=220
+T_OPEN=221
+T_FETCH=222
+T_FROM=223
+T_COLLECT=224
+T_STATISTICS=225
+T_STATS=226
+T_COLUMN=227
+T_CLOSE=228
+T_CMP=229
+T_SUM=230
+T_COPY=231
+T_HDFS=232
+T_BATCHSIZE=233
+T_DELIMITER=234
+T_SQLINSERT=235
+T_IGNORE=236
+T_WORK=237
+T_PRINT=238
+T_QUIT=239
+T_RAISE=240
+T_RESIGNAL=241
+T_SQLSTATE=242
+T_VALUE=243
+T_ROLLBACK=244
+T_CURRENT=245
+T_CURRENT_SCHEMA=246
+T_ANSI_NULLS=247
+T_ANSI_PADDING=248
+T_NOCOUNT=249
+T_QUOTED_IDENTIFIER=250
+T_XACT_ABORT=251
+T_OFF=252
+T_QUERY_BAND=253
+T_NONE=254
+T_SESSION=255
+T_SIGNAL=256
+T_SUMMARY=257
+T_TOP=258
+T_LIMIT=259
+T_TRUNCATE=260
+T_USE=261
+T_WHILE=262
+T_DO=263
+T_LOOP=264
+T_REVERSE=265
+T_DOT2=266
+T_STEP=267
+L_LABEL=268
+T_LESS=269
+T_GREATER=270
+T_USING=271
+T_UNION=272
+T_ALL=273
+T_EXCEPT=274
+T_INTERSECT=275
+T_SELECT=276
+T_SEL=277
+T_DISTINCT=278
+T_TITLE=279
+L_S_STRING=280
+T_INNER=281
+T_JOIN=282
+T_LEFT=283
+T_RIGHT=284
+T_FULL=285
+T_OUTER=286
+T_WHERE=287
+T_GROUP=288
+T_HAVING=289
+T_QUALIFY=290
+T_ORDER=291
+T_RR=292
+T_RS=293
+T_UR=294
+T_AND=295
+T_KEEP=296
+T_EXCLUSIVE=297
+T_SHARE=298
+T_LOCKS=299
+T_MERGE=300
+T_MATCHED=301
+T_DESCRIBE=302
+T_BETWEEN=303
+T_EQUAL2=304
+T_NOTEQUAL=305
+T_NOTEQUAL2=306
+T_LESSEQUAL=307
+T_GREATEREQUAL=308
+T_RLIKE=309
+T_REGEXP=310
+T_MUL=311
+T_DIV=312
+T_ADD=313
+T_SUB=314
+T_INTERVAL=315
+T_DAY=316
+T_DAYS=317
+T_MICROSECOND=318
+T_MICROSECONDS=319
+T_SECOND=320
+T_SECONDS=321
+T_PIPE=322
+T_CONCAT=323
+T_CASE=324
+T_ISOPEN=325
+T_NOTFOUND=326
+T_AVG=327
+T_COUNT=328
+T_COUNT_BIG=329
+T_CUME_DIST=330
+T_DENSE_RANK=331
+T_FIRST_VALUE=332
+T_LAG=333
+T_LAST_VALUE=334
+T_LEAD=335
+T_MIN=336
+T_RANK=337
+T_ROW_NUMBER=338
+T_STDEV=339
+T_VAR=340
+T_VARIANCE=341
+T_OVER=342
+T_PARTITION=343
+T_ACTIVITY_COUNT=344
+T_CAST=345
+T_CURRENT_DATE=346
+T_CURRENT_TIMESTAMP=347
+T_CURRENT_USER=348
+T_USER=349
+T_MAX_PART_STRING=350
+T_MIN_PART_STRING=351
+T_MAX_PART_INT=352
+T_MIN_PART_INT=353
+T_MAX_PART_DATE=354
+T_MIN_PART_DATE=355
+T_PART_COUNT=356
+T_PART_LOC=357
+T_TRIM=358
+T_SUBSTRING=359
+T_SYSDATE=360
+T_HIVE=361
+T_HOST=362
+L_FILE=363
+L_D_STRING=364
+L_DEC=365
+T_TRUE=366
+T_FALSE=367
+T_DIR=368
+T_FILE=369
+T_FILES=370
+T_NEW=371
+T_PWD=372
+T_SESSIONS=373
+T_SUBDIR=374
+'@'=1
+'#'=2
+'/'=3
+'%'=4
+'.'=5
+'*'=6
+'!'=7
+';'=8
+'-'=9
+'+'=10

src/lib/hive/HiveSqlLexer.interp

@@ -0,0 +1,47 @@
+token literal names:
+null
+'@'
+'#'
+'/'
+'%'
+'.'
+'*'
+'!'
+';'
+'-'
+'+'
+
+token symbolic names:
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+
+rule names:
+T__0
+T__1
+T__2
+T__3
+T__4
+T__5
+T__6
+T__7
+T__8
+T__9
+
+channel names:
+DEFAULT_TOKEN_CHANNEL
+HIDDEN
+
+mode names:
+DEFAULT_MODE
+
+atn:
+[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 12, 43, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3, 10, 3, 11, 3, 11, 2, 2, 12, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 3, 2, 2, 2, 42, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 3, 23, 3, 2, 2, 2, 5, 25, 3, 2, 2, 2, 7, 27, 3, 2, 2, 2, 9, 29, 3, 2, 2, 2, 11, 31, 3, 2, 2, 2, 13, 33, 3, 2, 2, 2, 15, 35, 3, 2, 2, 2, 17, 37, 3, 2, 2, 2, 19, 39, 3, 2, 2, 2, 21, 41, 3, 2, 2, 2, 23, 24, 7, 66, 2, 2, 24, 4, 3, 2, 2, 2, 25, 26, 7, 37, 2, 2, 26, 6, 3, 2, 2, 2, 27, 28, 7, 49, 2, 2, 28, 8, 3, 2, 2, 2, 29, 30, 7, 39, 2, 2, 30, 10, 3, 2, 2, 2, 31, 32, 7, 48, 2, 2, 32, 12, 3, 2, 2, 2, 33, 34, 7, 44, 2, 2, 34, 14, 3, 2, 2, 2, 35, 36, 7, 35, 2, 2, 36, 16, 3, 2, 2, 2, 37, 38, 7, 61, 2, 2, 38, 18, 3, 2, 2, 2, 39, 40, 7, 47, 2, 2, 40, 20, 3, 2, 2, 2, 41, 42, 7, 45, 2, 2, 42, 22, 3, 2, 2, 2, 3, 2, 2]

src/lib/hive/HiveSqlLexer.js

@@ -0,0 +1,85 @@
+// Generated from /Users/ziv/Workspace/dt-sql-parser/src/grammar/hive/HiveSql.g4 by ANTLR 4.8
+// jshint ignore: start
+var antlr4 = require('antlr4/index');
+
+
+
+var serializedATN = ["\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964",
+    "\u0002\f+\b\u0001\u0004\u0002\t\u0002\u0004\u0003\t\u0003\u0004\u0004",
+    "\t\u0004\u0004\u0005\t\u0005\u0004\u0006\t\u0006\u0004\u0007\t\u0007",
+    "\u0004\b\t\b\u0004\t\t\t\u0004\n\t\n\u0004\u000b\t\u000b\u0003\u0002",
+    "\u0003\u0002\u0003\u0003\u0003\u0003\u0003\u0004\u0003\u0004\u0003\u0005",
+    "\u0003\u0005\u0003\u0006\u0003\u0006\u0003\u0007\u0003\u0007\u0003\b",
+    "\u0003\b\u0003\t\u0003\t\u0003\n\u0003\n\u0003\u000b\u0003\u000b\u0002",
+    "\u0002\f\u0003\u0003\u0005\u0004\u0007\u0005\t\u0006\u000b\u0007\r\b",
+    "\u000f\t\u0011\n\u0013\u000b\u0015\f\u0003\u0002\u0002\u0002*\u0002",
+    "\u0003\u0003\u0002\u0002\u0002\u0002\u0005\u0003\u0002\u0002\u0002\u0002",
+    "\u0007\u0003\u0002\u0002\u0002\u0002\t\u0003\u0002\u0002\u0002\u0002",
+    "\u000b\u0003\u0002\u0002\u0002\u0002\r\u0003\u0002\u0002\u0002\u0002",
+    "\u000f\u0003\u0002\u0002\u0002\u0002\u0011\u0003\u0002\u0002\u0002\u0002",
+    "\u0013\u0003\u0002\u0002\u0002\u0002\u0015\u0003\u0002\u0002\u0002\u0003",
+    "\u0017\u0003\u0002\u0002\u0002\u0005\u0019\u0003\u0002\u0002\u0002\u0007",
+    "\u001b\u0003\u0002\u0002\u0002\t\u001d\u0003\u0002\u0002\u0002\u000b",
+    "\u001f\u0003\u0002\u0002\u0002\r!\u0003\u0002\u0002\u0002\u000f#\u0003",
+    "\u0002\u0002\u0002\u0011%\u0003\u0002\u0002\u0002\u0013\'\u0003\u0002",
+    "\u0002\u0002\u0015)\u0003\u0002\u0002\u0002\u0017\u0018\u0007B\u0002",
+    "\u0002\u0018\u0004\u0003\u0002\u0002\u0002\u0019\u001a\u0007%\u0002",
+    "\u0002\u001a\u0006\u0003\u0002\u0002\u0002\u001b\u001c\u00071\u0002",
+    "\u0002\u001c\b\u0003\u0002\u0002\u0002\u001d\u001e\u0007\'\u0002\u0002",
+    "\u001e\n\u0003\u0002\u0002\u0002\u001f \u00070\u0002\u0002 \f\u0003",
+    "\u0002\u0002\u0002!\"\u0007,\u0002\u0002\"\u000e\u0003\u0002\u0002\u0002",
+    "#$\u0007#\u0002\u0002$\u0010\u0003\u0002\u0002\u0002%&\u0007=\u0002",
+    "\u0002&\u0012\u0003\u0002\u0002\u0002\'(\u0007/\u0002\u0002(\u0014\u0003",
+    "\u0002\u0002\u0002)*\u0007-\u0002\u0002*\u0016\u0003\u0002\u0002\u0002",
+    "\u0003\u0002\u0002"].join("");
+
+
+var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); });
+
+function HiveSqlLexer(input) {
+	antlr4.Lexer.call(this, input);
+    this._interp = new antlr4.atn.LexerATNSimulator(this, atn, decisionsToDFA, new antlr4.PredictionContextCache());
+    return this;
+}
+
+HiveSqlLexer.prototype = Object.create(antlr4.Lexer.prototype);
+HiveSqlLexer.prototype.constructor = HiveSqlLexer;
+
+Object.defineProperty(HiveSqlLexer.prototype, "atn", {
+        get : function() {
+                return atn;
+        }
+});
+
+HiveSqlLexer.EOF = antlr4.Token.EOF;
+HiveSqlLexer.T__0 = 1;
+HiveSqlLexer.T__1 = 2;
+HiveSqlLexer.T__2 = 3;
+HiveSqlLexer.T__3 = 4;
+HiveSqlLexer.T__4 = 5;
+HiveSqlLexer.T__5 = 6;
+HiveSqlLexer.T__6 = 7;
+HiveSqlLexer.T__7 = 8;
+HiveSqlLexer.T__8 = 9;
+HiveSqlLexer.T__9 = 10;
+
+HiveSqlLexer.prototype.channelNames = [ "DEFAULT_TOKEN_CHANNEL", "HIDDEN" ];
+
+HiveSqlLexer.prototype.modeNames = [ "DEFAULT_MODE" ];
+
+HiveSqlLexer.prototype.literalNames = [ null, "'@'", "'#'", "'/'", "'%'", 
+                                        "'.'", "'*'", "'!'", "';'", "'-'", 
+                                        "'+'" ];
+
+HiveSqlLexer.prototype.symbolicNames = [  ];
+
+HiveSqlLexer.prototype.ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", 
+                                     "T__5", "T__6", "T__7", "T__8", "T__9" ];
+
+HiveSqlLexer.prototype.grammarFileName = "HiveSql.g4";
+
+
+exports.HiveSqlLexer = HiveSqlLexer;
+

src/lib/hive/HiveSqlLexer.tokens

@@ -0,0 +1,20 @@
+T__0=1
+T__1=2
+T__2=3
+T__3=4
+T__4=5
+T__5=6
+T__6=7
+T__7=8
+T__8=9
+T__9=10
+'@'=1
+'#'=2
+'/'=3
+'%'=4
+'.'=5
+'*'=6
+'!'=7
+';'=8
+'-'=9
+'+'=10

src/lib/plsql/PlSqlBaseLexer.js

@@ -0,0 +1,16 @@
+const Lexer = require('antlr4').Lexer;
+
+function PlSqlBaseLexer(...args) {
+    Lexer.call(this, ...args);
+    return this;
+}
+
+PlSqlBaseLexer.prototype = Object.create(Lexer.prototype);
+PlSqlBaseLexer.prototype.constructor = PlSqlBaseLexer;
+
+PlSqlBaseLexer.prototype.IsNewlineAtPos = function(pos) {
+    const la = this._input.LA(pos);
+    return la == -1 || la == '\n';
+};
+
+exports.PlSqlBaseLexer = PlSqlBaseLexer;

src/lib/plsql/PlSqlBaseParser.js

@@ -0,0 +1,27 @@
+
+const Parser = require('antlr4').Parser;
+
+function PlSqlBaseParser(...args) {
+    Parser.call(this, ...args);
+    this._isVersion10 = false;
+    this._isVersion12 = true;
+    return this;
+}
+
+PlSqlBaseParser.prototype = Object.create(Parser.prototype);
+PlSqlBaseParser.prototype.constructor = PlSqlBaseParser;
+
+PlSqlBaseParser.prototype.isVersion10 = function() {
+    return this._isVersion10;
+};
+PlSqlBaseParser.prototype.isVersion12 = function() {
+    return this._isVersion12;
+};
+PlSqlBaseParser.prototype.setVersion10 = function(value) {
+    this._isVersion10 = value;
+};
+PlSqlBaseParser.prototype.setVersion12 = function(value) {
+    this._isVersion12 = value;
+};
+
+exports.PlSqlBaseParser = PlSqlBaseParser;

src/parser/common/BasicParser.ts

@@ -0,0 +1,111 @@
+import { Token, Lexer } from 'antlr4';
+import { ParseTreeWalker } from 'antlr4/tree';
+
+import ParserErrorListener, {
+    ParserError,
+    ErrorHandler,
+    ParserErrorCollector,
+} from './parserErrorListener';
+
+/**
+ * Custom Parser class, subclass needs extends it.
+ */
+export default abstract class BasicParser<C = any> {
+    private _parser;
+
+    public parse(
+        input: string,
+        errorListener?: ErrorHandler,
+    ) {
+        const parser = this.createParser(input);
+        this._parser = parser;
+
+        parser.removeErrorListeners();
+        parser.addErrorListener(new ParserErrorListener(errorListener));
+
+        const parserTree = parser.program();
+
+        return parserTree;
+    }
+
+    public validate(input: string): ParserError[] {
+        const lexerError = []; const syntaxErrors = [];
+
+        const parser = this.createParser(input);
+        this._parser = parser;
+
+        parser.removeErrorListeners();
+        parser.addErrorListener(new ParserErrorCollector(syntaxErrors));
+
+        parser.program();
+
+        return lexerError.concat(syntaxErrors);
+    }
+
+    /**
+     * Create antrl4 Lexer object
+     * @param input source string
+     */
+    public abstract createLexer(input: string): Lexer;
+
+    /**
+     * Create Parser by lexer
+     * @param lexer Lexer
+     */
+    public abstract createParserFromLexer(lexer: Lexer);
+
+    /**
+     * Visit parser tree
+     * @param parserTree
+     */
+    // public abstract visit(visitor: any, parserTree: any);
+
+    /**
+     * The source string
+     * @param input string
+     */
+    public getAllTokens(input: string): Token[] {
+        return this.createLexer(input).getAllTokens();
+    };
+
+    /**
+     * Get Parser instance by input string
+     * @param input
+     */
+    public createParser(input: string) {
+        const lexer = this.createLexer(input);
+        const parser: any = this.createParserFromLexer(lexer);
+        parser.buildParseTrees = true;
+        this._parser = parser;
+
+        return parser;
+    }
+
+    /**
+     * It convert tree to string, it's convenient to use in unit test.
+     * @param string input
+     */
+    public parserTreeToString(input: string): string {
+        const parser = this.createParser(input);
+        this._parser = parser;
+
+        const tree = parser.statement();
+        return tree.toStringTree(parser.ruleNames);
+    }
+
+    /**
+     * Get List-like style tree string
+     * @param parserTree
+     */
+    public toString(parserTree: any): string {
+        return parserTree.toStringTree(this._parser.ruleNames);
+    }
+
+    /**
+     * @param listener Listener instance extends ParserListener
+     * @param parserTree parser Tree
+     */
+    public listen(listener: any, parserTree: any) {
+        ParseTreeWalker.DEFAULT.walk(listener, parserTree);
+    }
+}

src/parser/common/parserErrorListener.ts

@@ -0,0 +1,84 @@
+import { Token, Recognizer } from 'antlr4';
+import { ErrorListener } from 'antlr4/error';
+
+export interface ParserError {
+    startLine: number;
+    endLine: number;
+    startCol: number;
+    endCol: number;
+    message: string;
+}
+
+export interface SyntaxError {
+    recognizer: Recognizer;
+    offendingSymbol: Token;
+    line: number;
+    charPositionInLine: number;
+    msg: string;
+    e: any;
+}
+
+export type ErrorHandler = (err: ParserError, errOption: SyntaxError) => void;
+
+export class ParserErrorCollector extends ErrorListener {
+    private _errors: ParserError[];
+
+    constructor(error: ParserError[]) {
+        super();
+        this._errors = error;
+    }
+
+    syntaxError(
+        recognizer: Recognizer, offendingSymbol: Token, line: number,
+        charPositionInLine: number, msg: string, e: any,
+    ) {
+        let endCol = charPositionInLine + 1;
+        if (offendingSymbol &&offendingSymbol.text !== null) {
+            endCol = charPositionInLine + offendingSymbol.text.length;
+        }
+        this._errors.push({
+            startLine: line,
+            endLine: line,
+            startCol: charPositionInLine,
+            endCol: endCol,
+            message: msg,
+        });
+    }
+}
+
+
+export default class ParserErrorListener extends ErrorListener {
+    private _errorHandler;
+
+    constructor(errorListener: ErrorHandler) {
+        super();
+        this._errorHandler = errorListener;
+    }
+
+    syntaxError(
+        recognizer: Recognizer, offendingSymbol: Token, line: number,
+        charPositionInLine: number, msg: string, e: any,
+    ) {
+        let endCol = charPositionInLine + 1;
+        if (offendingSymbol &&offendingSymbol.text !== null) {
+            endCol = charPositionInLine + offendingSymbol.text.length;
+        }
+        if (this._errorHandler) {
+            this._errorHandler({
+                startLine: line,
+                endLine: line,
+                startCol: charPositionInLine,
+                endCol: endCol,
+                message: msg,
+            }, {
+                e,
+                line,
+                msg,
+                recognizer,
+                offendingSymbol,
+                charPositionInLine,
+            });
+        }
+    }
+}
+

src/parser/generic.ts

@@ -0,0 +1,20 @@
+import { InputStream, CommonTokenStream, Lexer } from 'antlr4';
+import { SqlLexer } from '../lib/generic/SqlLexer';
+import { SqlParser } from '../lib/generic/SqlParser';
+export * from '../lib/generic/SqlParserVisitor';
+export * from '../lib/generic/SqlParserListener';
+
+import BasicParser from './common/BasicParser';
+
+export default class GenericSQL extends BasicParser {
+    public createLexer(input: string): Lexer {
+        const chars = new InputStream(input.toUpperCase()); // Some Lexer only support uppercase token, So you need transform
+        const lexer = <unknown> new SqlLexer(chars) as Lexer;
+        return lexer;
+    }
+    public createParserFromLexer(lexer: Lexer) {
+        const tokenStream = new CommonTokenStream(lexer);
+        return new SqlParser(tokenStream);
+    }
+}
+

src/parser/hive.ts

@@ -0,0 +1,20 @@
+import { InputStream, CommonTokenStream, Lexer } from 'antlr4';
+import { HiveSqlLexer } from '../lib/hive/HiveSqlLexer';
+import { HiveSqlParser } from '../lib/hive/HiveSqlParser';
+export * from '../lib/hive/HiveSqlListener';
+export * from '../lib/hive/HiveSqlVisitor';
+
+import BasicParser from './common/BasicParser';
+
+export default class HiveSQL extends BasicParser {
+    public createLexer(input: string): Lexer {
+        const chars = new InputStream(input);
+        const lexer = <unknown> new HiveSqlLexer(chars) as Lexer;
+        return lexer;
+    }
+    public createParserFromLexer(lexer: Lexer) {
+        const tokenStream = new CommonTokenStream(lexer);
+        return new HiveSqlParser(tokenStream);
+    }
+}
+

src/parser/index.ts

@@ -0,0 +1,3 @@
+export * from './generic';
+export * from './plsql';
+export * from './hive';

src/parser/plsql.ts

@@ -0,0 +1,19 @@
+import { InputStream, CommonTokenStream, Lexer } from 'antlr4';
+import { PlSqlLexer } from '../lib/plsql/PlSqlLexer';
+import { PlSqlParser } from '../lib/plsql/PlSqlParser';
+export * from '../lib/plsql/PlSqlParserListener';
+export * from '../lib/plsql/PlSqlParserVisitor';
+
+import BasicParser from './common/BasicParser';
+
+export default class PLSQLParser extends BasicParser {
+    public createLexer(input: string): Lexer {
+        const chars = new InputStream(input.toUpperCase());
+        const lexer = <unknown> new PlSqlLexer(chars) as Lexer;
+        return lexer;
+    }
+    public createParserFromLexer(lexer: Lexer) {
+        const tokenStream = new CommonTokenStream(lexer);
+        return new PlSqlParser(tokenStream);
+    }
+}

test/parser/generic/lexer.test.ts

@@ -0,0 +1,12 @@
+import SQLParser from '../../../src/parser/generic';
+
+describe('GenericSQL Lexer tests', () => {
+    const mysqlParser = new SQLParser();
+
+    const sql = 'select id,name,sex from user1;';
+    const tokens = mysqlParser.getAllTokens(sql);
+
+    test('token counts', () => {
+        expect(tokens.length).toBe(12);
+    });
+});

test/parser/generic/listener.test.ts

@@ -0,0 +1,22 @@
+import SQLParser, { SqlParserListener } from '../../../src/parser/generic';
+
+describe('Generic SQL Listener Tests', () => {
+    const expectTableName = 'user1';
+    const sql = `select id,name,sex from ${expectTableName};`;
+    const parser = new SQLParser();
+
+    const parserTree = parser.parse(sql);
+
+    test('Listener enterTableName', async () => {
+        let result = '';
+        class MyListener extends SqlParserListener {
+            enterTableName(ctx): void {
+                result = ctx.getText().toLowerCase();
+            }
+        }
+        const listenTableName: any = new MyListener();
+
+        await parser.listen(listenTableName, parserTree);
+        expect(result).toBe(expectTableName);
+    });
+});

test/parser/generic/syntax.test.ts

@@ -0,0 +1,18 @@
+import SQLParser from '../../../src/parser/generic';
+
+describe('Generic SQL Syntax Tests', () => {
+    const parser = new SQLParser();
+
+    test('Select Statement', () => {
+        const sql = 'select id,name from user1;';
+        const result = parser.validate(sql);
+
+        expect(result.length).toBe(0);
+    });
+
+    test('Select 1+1', () => {
+        const sql = 'SELECT 1+1;';
+        const result = parser.validate(sql);
+        expect(result.length).toBe(0);
+    });
+});

test/parser/generic/visitor.test.ts

@@ -0,0 +1,27 @@
+import SQLParser, { SqlParserVisitor } from '../../../src/parser/generic';
+
+describe('Generic SQL Visitor Tests', () => {
+    const expectTableName = 'user1';
+    const sql = `select id,name,sex from ${expectTableName};`;
+    const parser = new SQLParser();
+
+    const parserTree = parser.parse(sql, (error) => {
+        console.log('Parse error:', error);
+    });
+
+    console.log('Parser tree string:', parser.toString(parserTree));
+
+    test('Visitor visitTableName', () => {
+        let result = '';
+        class MyVisitor extends SqlParserVisitor {
+            visitTableName(ctx): void {
+                result = ctx.getText().toLowerCase();
+                super.visitTableName(ctx);
+            }
+        }
+        const visitor: any = new MyVisitor();
+        visitor.visit(parserTree);
+
+        expect(result).toBe(expectTableName);
+    });
+});

test/parser/hive/lexer.test.ts

@@ -0,0 +1,12 @@
+import SQLParser from '../../../src/parser/hive';
+
+describe('HiveSQL Lexer tests', () => {
+    const parser = new SQLParser();
+    // select id,name,sex from user1;
+    const sql = 'SELECT * FROM t1';
+    const tokens = parser.getAllTokens(sql);
+
+    test('token counts', () => {
+        expect(tokens.length).toBe(12);
+    });
+});

test/parser/hive/listener.test.ts

@@ -0,0 +1,22 @@
+import SQLParser, { HiveSqlListener } from '../../../src/parser/hive';
+
+describe('Hive SQL Listener Tests', () => {
+    const expectTableName = 'user1';
+    const sql = `select id,name,sex from ${expectTableName};`;
+    const parser = new SQLParser();
+
+    const parserTree = parser.parse(sql);
+
+    test('Listener enterTableName', async () => {
+        let result = '';
+        class MyListener extends HiveSqlListener {
+            enterTableName(ctx): void {
+                result = ctx.getText().toLowerCase();
+            }
+        }
+        const listenTableName: any = new MyListener();
+
+        await parser.listen(listenTableName, parserTree);
+        expect(result).toBe(expectTableName);
+    });
+});

test/parser/hive/syntax.test.ts

@@ -0,0 +1,18 @@
+import SQLParser from '../../../src/parser/hive';
+
+describe('Hive SQL Syntax Tests', () => {
+    const parser = new SQLParser();
+
+    test('Select Statement', () => {
+        const sql = 'SELECT * FROM employee WHERE salary>30000;';
+        const result = parser.validate(sql);
+
+        expect(result.length).toBe(0);
+    });
+
+    test('Select 1+1', () => {
+        const sql = 'SELECT 1+1;';
+        const result = parser.validate(sql);
+        expect(result.length).toBe(0);
+    });
+});

test/parser/hive/visitor.test.ts

@@ -0,0 +1,27 @@
+import SQLParser, { HiveSqlVisitor } from '../../../src/parser/hive';
+
+describe('Generic SQL Visitor Tests', () => {
+    const expectTableName = 'user1';
+    const sql = `select id,name,sex from ${expectTableName};`;
+    const parser = new SQLParser();
+
+    const parserTree = parser.parse(sql, (error) => {
+        console.log('Parse error:', error);
+    });
+
+    console.log('Parser tree string:', parser.toString(parserTree));
+
+    test('Visitor visitTableName', () => {
+        let result = '';
+        class MyVisitor extends HiveSqlVisitor {
+            visitTable_name(ctx): void {
+                result = ctx.getText().toLowerCase();
+                super.visitTable_name(ctx);
+            }
+        }
+        const visitor: any = new MyVisitor();
+        visitor.visit(parserTree);
+
+        expect(result).toBe(expectTableName);
+    });
+});

test/parser/plsql/lexer.test.ts

@@ -0,0 +1,12 @@
+import SQLParser from '../../../src/parser/plsql';
+
+describe('PLSQL Lexer tests', () => {
+    const parser = new SQLParser();
+
+    const sql = 'select id,name,sex from user1;';
+    const tokens = parser.getAllTokens(sql);
+
+    test('token counts', () => {
+        expect(tokens.length).toBe(12);
+    });
+});

test/parser/plsql/listener.test.ts

@@ -0,0 +1,22 @@
+import SQLParser, { PlSqlParserListener } from '../../../src/parser/plsql';
+
+describe('PLSQL Listener Tests', () => {
+    const expectTableName = 'user1';
+    const sql = `select id,name,sex from ${expectTableName};`;
+    const parser = new SQLParser();
+
+    const parserTree = parser.parse(sql);
+
+    test('Listener enterTableName', async () => {
+        let result = '';
+        class MyListener extends PlSqlParserListener {
+            enterTable_ref_list(ctx): void {
+                result = ctx.getText().toLowerCase();
+            }
+        }
+        const listenTableName: any = new MyListener();
+
+        await parser.listen(listenTableName, parserTree);
+        expect(result).toBe(expectTableName);
+    });
+});

test/parser/plsql/syntax.test.ts

@@ -0,0 +1,23 @@
+import SQLParser from '../../../src/parser/plsql';
+
+describe('PLSQL Syntax Tests', () => {
+    const parser = new SQLParser();
+
+    test('Test simple select Statement', () => {
+        const sql = 'select id,name from user1;';
+        const result = parser.validate(sql);
+
+        expect(result.length).toBe(0);
+    });
+
+    test(`Test select, where, order by`, () => {
+        const sql = `
+            select eid, emp_last, mgr_id, reportlevel
+            from reports_to_101 r, auto a
+            where r.c1 = a.c2
+            order by reportlevel, eid
+        `;
+        const result = parser.validate(sql);
+        expect(result.length).toBe(0);
+    });
+});

test/parser/plsql/visitor.test.ts

@@ -0,0 +1,23 @@
+import SQLParser, { PlSqlParserVisitor } from '../../../src/parser/plsql';
+
+describe('PLSQL Visitor Tests', () => {
+    const expectTableName = 'user1';
+    const sql = `select id,name,sex from ${expectTableName};`;
+    const parser = new SQLParser();
+
+    const parserTree = parser.parse(sql);
+
+    test('Visitor visitTable_ref_list', () => {
+        let result = '';
+        class MyVisitor extends PlSqlParserVisitor {
+            visitTable_ref_list(ctx): void {
+                result = ctx.getText().toLowerCase();
+                super.visitTable_ref_list(ctx);
+            }
+        }
+        const visitor: any = new MyVisitor();
+        visitor.visit(parserTree);
+
+        expect(result).toBe(expectTableName);
+    });
+});

test/parsers/mysql/lexer.test.ts

@@ -1,16 +0,0 @@
-import MySQLParser from '../../../src/core/mysql';
-
-describe('MySQL Lexer tests', () => {
-    const mysqlParser = new MySQLParser();
-
-    const sql = 'select id,name,sex from user1;';
-    const tokens = mysqlParser.getAllTokens(sql);
-
-    test('token counts', () => {
-        expect(tokens.length).toBe(12);
-    });
-
-    test('token counts', () => {
-        expect(tokens.length).toBe(12);
-    });
-});

test/parsers/mysql/parser.test.ts

@@ -1,24 +0,0 @@
-import MySQLParser from '../../../src/core/mysql';
-
-describe('MySQL Parser tests', () => {
-    const mysql = new MySQLParser();
-
-    test('Select * FROM Statement', () => {
-        const sql = 'SELECT * FROM tb;';
-        const result = mysql.parserTreeToString(sql);
-        expect(result).toEqual(`
-        (statement (sqlStatements (
-            sqlStatement (
-                dmlStatement (
-                    selectStatement (
-                        querySpecification SELECT (selectElements *) (
-                            fromClause FROM (
-                                tableSources (tableSource (
-                                    tableSourceItem (tableName (
-                                        fullId (uid (
-                                            simpleId TB
-                                            )
-                                        ))))))))))) (emptyStatement ;)) <EOF>
-                            )`);
-    });
-});

test/parsers/mysql/syntax.test.ts

@@ -1,11 +0,0 @@
-import MySQLParser from '../../../src/core/mysql';
-
-describe('MySQL Syntax tests', () => {
-    const mysql = new MySQLParser();
-    test('Select Statement', () => {
-        const sql = 'select id,name from user1;';
-        const result = mysql.validate(sql);
-
-        expect(result.length).toBe(0);
-    });
-});