{

const reservedMap = {

'ARRAY': true,

'ALTER': true,

'ALL': true,

'ADD': true,

'AND': true,

'AS': true,

'ASC': true,

'BETWEEN': true,

'BY': true,

'CALL': true,

'CASE': true,

'CREATE': true,

'CROSS': true,

'CONTAINS': true,

'CURRENT_DATE': true,

'CURRENT_TIME': true,

'CURRENT_TIMESTAMP': true,

'CURRENT_USER': true,

'DELETE': true,

'DESC': true,

'DISTINCT': true,

'DROP': true,

'ELSE': true,

'END': true,

'EXISTS': true,

'EXPLAIN': true,

'FALSE': true,

'FROM': true,

'FULL': true,

'FOR': true,

'GROUP': true,

'HAVING': true,

'IN': true,

'INNER': true,

'INSERT': true,

'INTO': true,

'IS': true,

'JOIN': true,

'JSON': true,

'KEY': true,

'LEFT': true,

'LIKE': true,

'LIMIT': true,

'LOW_PRIORITY': true, // for lock table

'NOT': true,

'NULL': true,

'ON': true,

'OR': true,

'ORDER': true,

'OUTER': true,

'PARTITION': true,

'PIVOT': true,

'RECURSIVE': true,

'RENAME': true,

'READ': true, // for lock table

'RIGHT': true,

'SELECT': true,

'SESSION_USER': true,

'SET': true,

'SHOW': true,

'SYSTEM_USER': true,

'TABLE': true,

'THEN': true,

'TRUE': true,

'TRUNCATE': true,

'TYPE': true, // reserved (MySQL)

'UNION': true,

'UPDATE': true,

'USING': true,

'VALUES': true,

'WINDOW': true,

'WITH': true,

'WHEN': true,

'WHERE': true,

'WRITE': true, // for lock table

'GLOBAL': true,

'SESSION': true,

'LOCAL': true,

'PERSIST': true,

'PERSIST_ONLY': true,

'UNNEST': true,

};

const DATA_TYPES = {

'BOOL': true,

'BYTE': true,

'DATE': true,

'DATETIME': true,

'FLOAT64': true,

'INT64': true,

'NUMERIC': true,

'STRING': true,

'TIME': true,

'TIMESTAMP': true,

'ARRAY': true,

'STRUCT': true,

}

function createUnaryExpr(op, e) {

return {

type: 'unary_expr',

operator: op,

expr: e

};

}

function createBinaryExpr(op, left, right) {

return {

type: 'binary_expr',

operator: op,

left: left,

right: right

};

}

function isBigInt(numberStr) {

const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER)

const num = BigInt(numberStr)

if (num < previousMaxSafe) return false

return true

}

function createList(head, tail, po = 3) {

const result = [head];

for (let i = 0; i < tail.length; i++) {

delete tail[i][po].tableList

delete tail[i][po].columnList

result.push(tail[i][po]);

}

return result;

}

function createBinaryExprChain(head, tail) {

let result = head;

for (let i = 0; i < tail.length; i++) {

result = createBinaryExpr(tail[i][1], result, tail[i][3]);

}

return result;

}

function queryTableAlias(tableName) {

const alias = tableAlias[tableName]

if (alias) return alias

if (tableName) return tableName

return null

}

function columnListTableAlias(columnList) {

const newColumnsList = new Set()

const symbolChar = '::'

for(let column of columnList.keys()) {

const columnInfo = column.split(symbolChar)

if (!columnInfo) {

newColumnsList.add(column)

break

}

if (columnInfo && columnInfo[1]) columnInfo[1] = queryTableAlias(columnInfo[1])

newColumnsList.add(columnInfo.join(symbolChar))

}

return Array.from(newColumnsList)

}

function refreshColumnList(columnList) {

const columns = columnListTableAlias(columnList)

columnList.clear()

columns.forEach(col => columnList.add(col))

}

const cmpPrefixMap = {

'+': true,

'-': true,

'*': true,

'/': true,

'>': true,

'<': true,

'!': true,

'=': true,

//between

'B': true,

'b': true,

//for is or in

'I': true,

'i': true,

//for like

'L': true,

'l': true,

//for not

'N': true,

'n': true

};

// used for dependency analysis

let varList = [];

const tableList = new Set();

const columnList = new Set();

const tableAlias = {};

}

start

= __ n:(multiple_stmt / query_statement / crud_stmt) {

return n

}

multiple_stmt

= head:query_statement tail:(__ SEMICOLON __ query_statement)+ {

const cur = [head && head.ast || head];

for (let i = 0; i < tail.length; i++) {

if(!tail[i][3] || tail[i][3].length === 0) continue;

cur.push(tail[i][3] && tail[i][3].ast || tail[i][3]);

}

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: cur

}

}

crud_stmt

= union_stmt

/ update_stmt

/ replace_insert_stmt

/ insert_no_columns_stmt

/ insert_into_set

/ delete_stmt

/ cmd_stmt

/ proc_stmts

update_stmt

= KW_UPDATE __

t:table_ref_list __

KW_SET __

l:set_list __

f:from_clause? __

w:where_clause? __

or:order_by_clause? __

lc:limit_clause? {

if (t) t.forEach(tableInfo => {

const { db, as, table } = tableInfo

tableList.add(`update::${db}::${table}`)

});

if(f) f.forEach(info => {

info.table && tableList.add(`update::${info.db}::${info.table}`);

});

if(l) {

l.forEach(col => columnList.add(`update::${col.table}::${col.column}`));

}

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'update',

table: t,

set: l,

where: w,

orderby: or,

limit: lc,

}

};

}

delete_stmt

= KW_DELETE __

t: table_ref_list? __

f:from_clause? __

w:where_clause? __

or:order_by_clause? __

l:limit_clause? {

if(t) t.forEach(tt => tableList.add(`delete::${tt.db}::${tt.table}`));

if(f) f.forEach(info => {

info.table && tableList.add(`delete::${info.db}::${info.table}`);

columnList.add(`delete::${info.table}::(.*)`);

});

if (t === null && f.length === 1) {

const tableInfo = f[0]

t = [{

db: tableInfo.db,

table: tableInfo.table,

as: tableInfo.as,

addition: true

}]

}

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'delete',

table: t,

from: f,

where: w,

orderby: or,

limit: l,

}

};

}

replace_insert_stmt

= ri:replace_insert __

KW_INTO? __

t:table_name __

p:insert_partition? __ LPAREN __ c:column_list __ RPAREN __

v:insert_value_clause __

odp:on_duplicate_update_stmt? {

if (t) {

tableList.add(`insert::${t.db}::${t.table}`)

t.as = null

}

if (c) {

let table = t && t.table || null

if(Array.isArray(v)) {

v.forEach((row, idx) => {

if(row.value.length != c.length) {

throw new Error(`Error: column count doesn't match value count at row ${idx+1}`)

}

})

}

c.forEach(c => columnList.add(`insert::${table}::${c}`));

}

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: ri,

table: [t],

columns: c,

values: v,

partition: p,

on_duplicate_update: odp,

}

};

}

insert_no_columns_stmt

= ri:replace_insert __

ig:KW_IGNORE? __

it:KW_INTO? __

t:table_name __

p:insert_partition? __

v:insert_value_clause __

odp: on_duplicate_update_stmt? {

if (t) {

tableList.add(`insert::${t.db}::${t.table}`)

columnList.add(`insert::${t.table}::(.*)`);

t.as = null

}

const prefix = [ig, it].filter(v => v).map(v => v[0] && v[0].toLowerCase()).join(' ')

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: ri,

table: [t],

columns: null,

values: v,

partition: p,

prefix,

on_duplicate_update: odp,

}

};

}

insert_into_set

= ri:replace_insert __

KW_INTO? __

t:table_name __

p:insert_partition? __

KW_SET __

l:set_list __

odp:on_duplicate_update_stmt? {

if (t) {

tableList.add(`insert::${t.db}::${t.table}`)

columnList.add(`insert::${t.table}::(.*)`);

t.as = null

}

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: ri,

table: [t],

columns: null,

partition: p,

set: l,

on_duplicate_update: odp,

}

};

}

cmd_stmt

= analyze_stmt

/ attach_stmt

/ drop_stmt

/ create_stmt

/ truncate_stmt

/ rename_stmt

/ call_stmt

/ use_stmt

/ alter_stmt

/ set_stmt

/ lock_stmt

/ unlock_stmt

/ show_stmt

/ desc_stmt

proc_stmts

= proc_stmt*

proc_stmt

= &{ varList = []; return true; } __ s:(assign_stmt / return_stmt) {

return { stmt: s, vars: varList };

}

assign_stmt

= va:(var_decl / without_prefix_var_decl) __ s: (KW_ASSIGN / KW_ASSIGIN_EQUAL) __ e:proc_expr {

return {

type: 'assign',

left: va,

symbol: s,

right: e

};

}

return_stmt

= KW_RETURN __ e:proc_expr {

return { type: 'return', expr: e };

}

proc_expr

= select_stmt

/ proc_join

/ proc_additive_expr

/ proc_array

proc_additive_expr

= head:proc_multiplicative_expr

tail:(__ additive_operator __ proc_multiplicative_expr)* {

return createBinaryExprChain(head, tail);

}

proc_multiplicative_expr

= head:proc_primary

tail:(__ multiplicative_operator __ proc_primary)* {

return createBinaryExprChain(head, tail);

}

proc_join

= lt:var_decl __ op:join_op __ rt:var_decl __ expr:on_clause {

return {

type: 'join',

ltable: lt,

rtable: rt,

op: op,

on: expr

};

}

proc_primary

= literal

/ var_decl

/ proc_func_call

/ param

/ LPAREN __ e:proc_additive_expr __ RPAREN {

e.parentheses = true;

return e;

}

proc_func_call

= name:proc_func_name __ LPAREN __ l:proc_primary_list? __ RPAREN {

//compatible with original func_call

return {

type: 'function',

name: name,

args: {

type: 'expr_list',

value: l

}

};

}

/ name:proc_func_name {

return {

type: 'function',

name: name,

args: null

};

}

proc_primary_list

= head:proc_primary tail:(__ COMMA __ proc_primary)* {

return createList(head, tail);

}

proc_array =

LBRAKE __ l:proc_primary_list __ RBRAKE {

return { type: 'array', value: l };

}

set_list

= head:set_item tail:(__ COMMA __ set_item)* {

return createList(head, tail);

}

/**

* here only use `additive_expr` to support 'col1 = col1+2'

* if you want to use lower operator, please use '()' like below

* 'col1 = (col2 > 3)'

*/

set_item

= tbl:(ident __ DOT)? __ c:column __ '=' __ v:additive_expr {

return { column: c, value: v, table: tbl && tbl[0] };

}

/ tbl:(ident __ DOT)? __ c:column __ '=' __ KW_VALUES __ LPAREN __ v:column_ref __ RPAREN {

return { column: c, value: v, table: tbl && tbl[0], keyword: 'values' };

}

replace_insert

= KW_INSERT { return 'insert'; }

/ KW_REPLACE { return 'replace'; }

insert_partition

= KW_PARTITION __ LPAREN __ head:ident_name tail:(__ COMMA __ ident_name)* __ RPAREN {

return createList(head, tail)

}

/ KW_PARTITION __ v: value_item {

return v

}

insert_value_clause

= value_clause

/ select_stmt_nake

on_duplicate_update_stmt

= KW_ON __ 'DUPLICATE'i __ KW_KEY __ KW_UPDATE __ s:set_list {

return {

keyword: 'on duplicate key update',

set: s

}

}

analyze_stmt

= a:KW_ANALYZE __ t:table_name __ {

tableList.add(`${a}::${t.db}::${t.table}`);

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a.toLowerCase(),

table: t

}

};

}

attach_stmt

= a:KW_ATTACH __ db: KW_DATABASE __ e:expr __ as:KW_AS __ schema:ident __ {

// tableList.add(`${a}::${t.db}::${t.table}`);

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a.toLowerCase(),

database: db,

expr: e,

as: as && as[0].toLowerCase(),

schema,

}

};

}

drop_stmt

= a:KW_DROP __

r:KW_TABLE __

t:table_ref_list {

if(t) t.forEach(tt => tableList.add(`${a}::${tt.db}::${tt.table}`));

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a.toLowerCase(),

keyword: r.toLowerCase(),

name: t

}

};

}

/ a:KW_DROP __

r:KW_INDEX __

i:column_ref __

KW_ON __

t:table_name __

op:drop_index_opt? __ {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a.toLowerCase(),

keyword: r.toLowerCase(),

name: i,

table: t,

options: op

}

};

}

create_stmt

= create_table_stmt

/ create_db_stmt

truncate_stmt

= a:KW_TRUNCATE __

kw:KW_TABLE? __

t:table_ref_list {

if(t) t.forEach(tt => tableList.add(`${a}::${tt.db}::${tt.table}`));

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a.toLowerCase(),

keyword: kw && kw.toLowerCase() || 'table',

name: t

}

};

}

rename_stmt

= KW_RENAME __

KW_TABLE __

t:table_to_list {

t.forEach(tg => tg.forEach(dt => dt.table && tableList.add(`rename::${dt.db}::${dt.table}`)))

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'rename',

table: t

}

};

}

call_stmt

= KW_CALL __

e: proc_func_call {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'call',

expr: e

}

}

}

use_stmt

= KW_USE __

d:ident {

tableList.add(`use::${d}::null`);

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'use',

db: d

}

};

}

alter_stmt

= alter_table_stmt

set_stmt

= KW_SET __

kw: (KW_GLOBAL / KW_SESSION / KW_LOCAL / KW_PERSIST / KW_PERSIST_ONLY)? __

a: assign_stmt {

a.keyword = kw

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'set',

expr: a

}

}

}

lock_stmt

= KW_LOCK __ KW_TABLES __ ltl:lock_table_list {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'lock',

keyword: 'tables',

tables: ltl

}

}

}

unlock_stmt

= KW_UNLOCK __ KW_TABLES {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'unlock',

keyword: 'tables'

}

}

}

show_stmt

= KW_SHOW __ t:('BINARY'i / 'MASTER'i) __ 'LOGS'i {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'show',

suffix: 'logs',

keyword: t.toLowerCase()

}

}

}

/ KW_SHOW __ 'BINLOG'i __ 'EVENTS'i __ ins:in_op_right? __ from: from_clause? __ limit: limit_clause? {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'show',

suffix: 'events',

keyword: 'binlog',

in: ins,

from,

limit,

}

}

}

/ KW_SHOW __ k:(('CHARACTER'i __ 'SET'i) / 'COLLATION'i) __ e:(like_op_right / where_clause)? {

let keyword = Array.isArray(k) && k || [k]

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'show',

suffix: keyword[2] && keyword[2].toLowerCase(),

keyword: keyword[0].toLowerCase(),

expr: e

}

}

}

/ show_grant_stmt

desc_stmt

= (KW_DESC / KW_DESCRIBE) __ t:ident {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'desc',

table: t

}

};

}

var_decl

= p: KW_VAR_PRE d: without_prefix_var_decl {

//push for analysis

return {

type: 'var',

...d,

prefix: p

};

}

without_prefix_var_decl

= name:ident_name m:mem_chain {

//push for analysis

varList.push(name);

return {

type: 'var',

name: name,

members: m,

prefix: null,

};

}

value_item

= LPAREN __ l:expr_list __ RPAREN {

return l;

}

value_clause

= KW_VALUES __ l:value_list { return l; }

drop_index_opt

= head:(ALTER_ALGORITHM / ALTER_LOCK) tail:(__ (ALTER_ALGORITHM / ALTER_LOCK))* {

return createList(head, tail, 1)

}

create_table_stmt

= a:KW_CREATE __

tp:KW_TEMPORARY? __

KW_TABLE __

ife:KW_IF_NOT_EXISTS? __

t:table_ref_list __

c:create_table_definition __

con:(create_constraint_definition)* __

to:table_options? __

ir: (KW_IGNORE / KW_REPLACE)? __

as: KW_AS? __

qe: union_stmt? {

if(t) t.forEach(tt => tableList.add(`create::${tt.db}::${tt.table}`));

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: 'table',

temporary: tp && tp[0].toLowerCase(),

if_not_exists: ife && ife[0].toLowerCase(),

table: t,

ignore_replace: ir && ir[0].toLowerCase(),

as: as && as[0].toLowerCase(),

query_expr: qe && qe.ast,

create_definitions: c,

constraint : con,

table_options: to

}

}

}

/ a:KW_CREATE __

tp:KW_TEMPORARY? __

KW_TABLE __

ife:KW_IF_NOT_EXISTS? __

t:table_ref_list __

lt:create_like_table {

if(t) t.forEach(tt => tableList.add(`create::${tt.db}::${tt.table}`));

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: 'table',

temporary: tp && tp[0].toLowerCase(),

if_not_exists: ife && ife[0].toLowerCase(),

table: t,

like: lt

}

}

}

create_db_stmt

= a:KW_CREATE __

k:(KW_DATABASE / KW_SCHEMA) __

ife:KW_IF_NOT_EXISTS? __

t:ident_name __

c:create_db_definition? {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: 'database',

if_not_exists: ife && ife[0].toLowerCase(),

database: t,

create_definitions: c,

}

}

}

alter_table_stmt

= KW_ALTER __

KW_TABLE __

t:table_ref_list __

e:alter_action_list {

if (t && t.length > 0) t.forEach(table => tableList.add(`alter::${table.db}::${table.table}`));

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'alter',

table: t,

expr: e

}

};

}

lock_table_list

= head:lock_table tail:(__ COMMA __ lock_table)* {

return createList(head, tail);

}

show_grant_stmt

= KW_SHOW __ 'GRANTS'i __ f:show_grant_for? {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'show',

keyword: 'grants',

for: f,

}

}

}

mem_chain

= l:('.' ident_name)* {

const s = [];

for (let i = 0; i < l.length; i++) {

s.push(l[i][1]);

}

return s;

}

value_list

= head:value_item tail:(__ COMMA __ value_item)* {

return createList(head, tail);

}

ALTER_ALGORITHM

= "ALGORITHM"i __ s:KW_ASSIGIN_EQUAL? __ val:("DEFAULT"i / "INSTANT"i / "INPLACE"i / "COPY"i) {

return {

type: 'alter',

keyword: 'algorithm',

resource: 'algorithm',

symbol: s,

algorithm: val

}

}

ALTER_LOCK

= "LOCK"i __ s:KW_ASSIGIN_EQUAL? __ val:("DEFAULT"i / "NONE"i / "SHARED"i / "EXCLUSIVE"i) {

return {

type: 'alter',

keyword: 'lock',

resource: 'lock',

symbol: s,

lock: val

}

}

create_table_definition

= LPAREN __ head:create_definition tail:(__ COMMA __ create_definition)* __ RPAREN {

return createList(head, tail);

}

create_definition

= create_column_definition

/ create_index_definition

/ create_fulltext_spatial_index_definition

create_column_definition

= c:column_ref __

d:data_type __

n:(literal_not_null / literal_null)? __

df:default_expr? __

a:('AUTO_INCREMENT'i)? __

u:(('UNIQUE'i / 'PRIMARY'i)? __ 'KEY'i)? __

co:keyword_comment? __

ca:collate_expr? __

cf:column_format? __

s:storage? __

re:reference_definition? {

columnList.add(`create::${c.table}::${c.column}`)

if (n && !n.value) n.value = 'null'

return {

column: c,

definition: d,

nullable: n,

default_val: df,

auto_increment: a && a.toLowerCase(),

unique_or_primary: u && `${u[0].toLowerCase()} ${u[2].toLowerCase()}`,

comment: co,

collate: ca,

column_format: cf,

storage:s,

reference_definition: re,

resource: 'column'

}

}