{

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,

'EXCEPT': true,

'FALSE': true,

'FROM': true,

'FULL': true,

'FOR': true,

'GROUP': true,

'HAVING': true,

'IN': true,

'INNER': true,

'INSERT': true,

'INTERSECT': true,

'INTO': true,

'IS': true,

'JOIN': true,

'JSON': true,

'KEY': false,

'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': false,

'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 getLocationObject() {

return options.includeLocations ? {loc: location()} : {}

}

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,

...getLocationObject(),

};

}

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))

}

function getSurroundFromLiteralType(literal) {

switch (literal.type) {

case 'double_quote_string':

return '"'

case 'single_quote_string':

return "'"

case 'backticks_quote_string':

return '`'

default:

return ''

}

}

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) {

return n

}

multiple_stmt

= head:stmt tail:(__ SEMICOLON __ stmt)* {

const headAst = head && head.ast || head

const cur = tail && tail.length && tail[0].length >= 4 ? [headAst] : headAst;

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

}

}

stmt

= query_statement / crud_stmt

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? {

const addTableFun = (tableInfo) => {

const { server, db, schema, as, table, join } = tableInfo

const action = join ? 'select' : 'update'

const fullName = [server, db, schema].filter(Boolean).join('.') || null

if (db) dbObj[table] = fullName

if (table) tableList.add(`${action}::${fullName}::${table}`)

}

if (t) t.forEach(addTableFun);

if (f) f.forEach(addTableFun);

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(tableInfo => {

const { db, as, table, join } = tableInfo

const action = join ? 'select' : 'delete'

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

if (!join) columnList.add(`delete::${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.values)) {

v.values.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_list

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

return createList(head, tail);

}

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

},

...getLocationObject(),

};

}

/ name:proc_func_name {

return {

type: 'function',

name: name,

args: null,

...getLocationObject(),

};

}

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, brackets: true };

}

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_without_kw __ '=' __ v:expr {

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

}

/ tbl:(ident __ DOT)? __ c:column_without_kw __ '=' __ 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

/ u:union_stmt {

return u.ast

}

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

/ create_view_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_list {

a.keyword = kw

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'set',

keyword: kw,

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,

};

}

/ n:literal_numeric {

return {

type: 'var',

name: n.value,

members: [],

quoted: null,

prefix: null,

}

}

value_item

= LPAREN __ l:expr_list __ RPAREN {

return l;

}

value_clause

= KW_VALUES __ l:value_list { return { type: 'values', values: l } }

drop_index_opt

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

return createList(head, tail, 1)

}

if_not_exists_stmt

= 'IF'i __ KW_NOT __ KW_EXISTS {

return 'IF NOT EXISTS'

}

create_table_stmt

= a:KW_CREATE __

or:(KW_OR __ KW_REPLACE)? __

tp:(KW_TEMP / KW_TEMPORARY)? __

KW_TABLE __

ife:if_not_exists_stmt? __

t:table_name __

c:create_table_definition? __

to:table_options? __

as:KW_AS? __

qe:union_stmt? {

if(t) tableList.add(`create::${t.db}::${t.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,

table: [t],

replace: or && 'or replace',

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

query_expr: qe && qe.ast,

create_definitions: c,

table_options: to

}

}

}

/ a:KW_CREATE __

tp:KW_TEMPORARY? __

KW_TABLE __

ife:if_not_exists_stmt? __

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,

table: t,

like: lt

}

}

}

create_db_stmt

= a:KW_CREATE __

k:(KW_DATABASE / KW_SCHEMA) __

ife:if_not_exists_stmt? __

t:proc_func_name __

c:create_db_definition? {

const keyword = k.toLowerCase()

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword,

if_not_exists:ife,

[keyword]: { db: t.schema, schema: t.name },

create_definitions: c,

}

}

}

view_with

= KW_WITH __ c:("CASCADED"i / "LOCAL"i) __ "CHECK"i __ "OPTION" {

// => string

return `with ${c.toLowerCase()} check option`

}

/ KW_WITH __ "CHECK"i __ "OPTION" {

// => string

return 'with check option'

}

with_view_option

= 'check_option'i __ KW_ASSIGIN_EQUAL __ t:("CASCADED"i / "LOCAL"i) {

return { type: 'check_option', value: t, symbol: '=' }

}

/ k:('security_barrier'i / 'security_invoker'i) __ KW_ASSIGIN_EQUAL __ t:literal_bool {

return { type: k.toLowerCase(), value: t.value ? 'true' : 'false', symbol: '=' }

}

with_view_options

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

return createList(head, tail);

}

create_view_stmt

= a:KW_CREATE __ or:(KW_OR __ KW_REPLACE)? __ tp:(KW_TEMP / KW_TEMPORARY)? __ r:KW_RECURSIVE? __

KW_VIEW __ v:table_name __ c:(LPAREN __ column_list __ RPAREN)? __ wo:(KW_WITH __ LPAREN __ with_view_options __ RPAREN)? __

KW_AS __ s:select_stmt __ w:view_with? {

v.view = v.table

delete v.table

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: 'view',

replace: or && 'or replace',

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

recursive: r && r.toLowerCase(),

columns: c && c[2],

select: s,

view: v,

with_options: wo && wo[4],

with: w,

}

}

}

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