{

const reservedMap = {

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

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

'RECURSIVE': true,

'RENAME': true,

// 'REPLACE': 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,

'UNION': true,

'UPDATE': true,

'USING': true,

'VALUES': true,

'WITH': true,

'WHEN': true,

'WHERE': true,

'WRITE': true, // for lock table

'GLOBAL': true,

'SESSION': true,

'LOCAL': true,

'PERSIST': true,

'PERSIST_ONLY': 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) {

return n

}

cmd_stmt

= drop_stmt

/ create_stmt

/ truncate_stmt

/ rename_stmt

/ call_stmt

/ use_stmt

/ alter_stmt

/ set_stmt

/ lock_stmt

/ unlock_stmt

create_stmt

= create_table_stmt

/ create_db_stmt

alter_stmt

= alter_table_stmt

crud_stmt

= union_stmt

/ update_stmt

/ replace_insert_stmt

/ insert_no_columns_stmt

/ delete_stmt

/ cmd_stmt

/ proc_stmts

multiple_stmt

= head:crud_stmt tail:(__ SEMICOLON __ crud_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

}

}

set_op

= KW_UNION __ s:(KW_ALL / KW_DISTINCT)? {

return s ? `union ${s.toLowerCase()}` : 'union'

}

union_stmt

= head:select_stmt tail:(__ set_op __ select_stmt)* __ ob: order_by_clause? __ l:limit_clause? {

tail.forEach(item => item.slice(1, 1))

let cur = head

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

cur._next = tail[i][3]

cur.set_op = tail[i][1]

cur = cur._next

}

if(ob) head._orderby = ob

if(l) head._limit = l

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: head

}

}

create_db_definition

= head:create_option_character_set tail:(__ create_option_character_set)* {

return createList(head, tail, 1)

}

if_not_exists_stmt

= 'IF'i __ KW_NOT __ KW_EXISTS {

return 'IF NOT EXISTS'

}

create_db_stmt

= a:KW_CREATE __

k:(KW_DATABASE / KW_SCHEME) __

ife:if_not_exists_stmt? __

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,

database: t,

create_definitions: c,

}

}

}

create_table_stmt

= a:KW_CREATE __

tp:KW_TEMPORARY? __

KW_TABLE __

ife:if_not_exists_stmt? __

t:table_ref_list __

c:create_table_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,

table: t,

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

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_like_table_simple

= KW_LIKE __ t: table_ref_list {

return {

type: 'like',

table: t

}

}

create_like_table

= create_like_table_simple

/ LPAREN __ e:create_like_table __ RPAREN {

e.parentheses = true;

return e;

}

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_constraint_definition

column_definition_opt

= n:(literal_not_null / literal_null) {

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

return { nullable: n }

}

/ d:default_expr {

return { default_val: d }

}

/ a:('AUTO_INCREMENT'i) {

return { auto_increment: a.toLowerCase() }

}

/ 'UNIQUE'i __ k:('KEY'i)? {

const sql = ['unique']

if (k) sql.push(k)

return { unique: sql.join(' ').toLowerCase('') }

}

/ p:('PRIMARY'i)? __ 'KEY'i {

const sql = []

if (p) sql.push('primary')

sql.push('key')

return { primary_key: sql.join(' ').toLowerCase('') }

}

/ co:keyword_comment {

return { comment: co }

}

/ ca:collate_expr {

return { collate: ca }

}

/ cf:column_format {

return { column_format: cf }

}

/ s:storage {

return { storage: s }

}

/ re:reference_definition {

return { reference_definition: re }

}

column_definition_opt_list

= head:column_definition_opt __ tail:(__ column_definition_opt)* {

let opt = head

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

opt = { ...opt, ...tail[i][1] }

}

return opt

}

create_column_definition

= c:column_ref __

d:data_type __

cdo:column_definition_opt_list? {

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

return {

column: c,

definition: d,

resource: 'column',

...(cdo || {})

}

}

collate_expr

= KW_COLLATE __ ca:ident_name {

return {

type: 'collate',

value: ca,

}

}

column_format

= k:'COLUMN_FORMAT'i __ f:('FIXED'i / 'DYNAMIC'i / 'DEFAULT'i) {

return {

type: 'column_format',

value: f.toLowerCase()

}

}

storage

= k:'STORAGE'i __ s:('DISK'i / 'MEMORY'i) {

return {

type: 'storage',

value: s.toLowerCase()

}

}

default_expr

= KW_DEFAULT __ ce: (literal / expr) {

return {

type: 'default',

value: ce

}

}

drop_index_opt

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

return createList(head, tail, 1)

}

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

}

};

}

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

}

};

}

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

}

};

}

alter_action_list

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

return createList(head, tail);

}

alter_action

= ALTER_ADD_COLUMN

/ ALTER_DROP_COLUMN

/ ALTER_ADD_INDEX_OR_KEY

/ ALTER_ADD_FULLETXT_SPARITAL_INDEX

/ ALTER_RENAME_TABLE

/ ALTER_ALGORITHM

/ ALTER_LOCK

ALTER_ADD_COLUMN

= KW_ADD __

kc:KW_COLUMN? __

cd:create_column_definition {

return {

action: 'add',

...cd,

keyword: kc,

resource: 'column',

type: 'alter',

}

}

ALTER_DROP_COLUMN

= KW_DROP __

kc:KW_COLUMN? __

c:column_ref {

return {

action: 'drop',

column: c,

keyword: kc,

resource: 'column',

type: 'alter',

}

}

ALTER_ADD_INDEX_OR_KEY

= KW_ADD __

id:create_index_definition

{

return {

action: 'add',

type: 'alter',

...id,

}

}

ALTER_RENAME_TABLE

= KW_RENAME __

kw:(KW_TO / KW_AS)? __

tn:ident {

return {

action: 'rename',

type: 'alter',

resource: 'table',

keyword: kw && kw[0].toLowerCase(),

table: tn

}

}

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_index_definition

= kc:(KW_INDEX / KW_KEY) __

c:column? __

t:index_type? __

de:cte_column_definition __

id:index_options? __

{

return {

index: c,

definition: de,

keyword: kc.toLowerCase(),

index_type: t,

resource: 'index',

index_options: id,

}

}

create_fulltext_spatial_index_definition

= p: (KW_FULLTEXT / KW_SPATIAL) __

kc:(KW_INDEX / KW_KEY)? __

c:column? __

de: cte_column_definition __

id: index_options? __

{

return {

index: c,

definition: de,

keyword: kc && `${p.toLowerCase()} ${kc.toLowerCase()}` || p.toLowerCase(),

index_options: id,

resource: 'index',

}

}

create_constraint_definition

= create_constraint_primary

/ create_constraint_unique

/ create_constraint_foreign

constraint_name

= kc:KW_CONSTRAINT __

c:ident? {

return {

keyword: kc.toLowerCase(),

constraint: c

}

}

create_constraint_primary

= kc:constraint_name? __

p:('PRIMARY KEY'i) __

t:index_type? __

de:cte_column_definition __

id:index_options? {

return {

constraint: kc && kc.constraint,

definition: de,

constraint_type: p.toLowerCase(),

keyword: kc && kc.keyword,

index_type: t,

resource: 'constraint',

index_options: id,

}

}

create_constraint_unique

= kc:constraint_name? __

u:KW_UNIQUE __

p:(KW_INDEX / KW_KEY)? __

i:column? __

t:index_type? __

de:cte_column_definition __

id:index_options? {

return {

constraint: kc && kc.constraint,

definition: de,

constraint_type: p && `${u.toLowerCase()} ${p.toLowerCase()}` || u.toLowerCase(),

keyword: kc && kc.keyword,

index_type: t,

index: i,

resource: 'constraint',

index_options: id

}

}

create_constraint_foreign

= kc:constraint_name? __

p:('FOREIGN KEY'i) __

i:column? __

de:cte_column_definition __

id:reference_definition? {

return {

constraint: kc && kc.constraint,

definition: de,

constraint_type: p,

keyword: kc && kc.keyword,

index: i,

resource: 'constraint',

reference_definition: id

}

}

reference_definition

= kc:KW_REFERENCES __

t:table_ref_list __

de:cte_column_definition __

m:('MATCH FULL'i / 'MATCH PARTIAL'i / 'MATCH SIMPLE'i)? __

od:on_reference? __

ou:on_reference? {

return {

definition: de,

table: t,

keyword: kc.toLowerCase(),

match: m && m.toLowerCase(),

on_action: [od, ou].filter(v => v)

}

}

/ oa:on_reference {

return {

on_action: [oa]

}

}

on_reference

= KW_ON __ kw:(KW_DELETE / KW_UPDATE) __ ro:reference_option {

// => { type: 'on delete' | 'on update'; value: reference_option; }

return {

type: `on ${kw[0].toLowerCase()}`,

value: ro

}

}

reference_option

= kw:KW_CURRENT_TIMESTAMP __ LPAREN __ l:expr_list? __ RPAREN {

return {

type: 'function',

name: kw,

args: l

}

}

/ kc:('RESTRICT'i / 'CASCADE'i / 'SET NULL'i / 'NO ACTION'i / 'SET DEFAULT'i / KW_CURRENT_TIMESTAMP) {

return {

type: 'origin',

value: kc.toLowerCase()

}

}

table_options

= head:table_option tail:(__ COMMA? __ table_option)* {

return createList(head, tail)

}

create_option_character_set_kw

= 'CHARACTER'i __ 'SET'i {

return 'CHARACTER SET'

}

create_option_character_set

= kw:KW_DEFAULT? __ t:(create_option_character_set_kw / 'CHARSET'i / 'COLLATE'i) __ s:(KW_ASSIGIN_EQUAL)? __ v:ident_name {

return {

keyword: kw && `${kw[0].toLowerCase()} ${t.toLowerCase()}` || t.toLowerCase(),

symbol: s,

value: v

}

}

table_option

= kw:('AUTO_INCREMENT'i / 'AVG_ROW_LENGTH'i / 'KEY_BLOCK_SIZE'i / 'MAX_ROWS'i / 'MIN_ROWS'i / 'STATS_SAMPLE_PAGES'i) __ s:(KW_ASSIGIN_EQUAL)? __ v:literal_numeric {

return {

keyword: kw.toLowerCase(),

symbol: s,

value: v.value

}

}

/ create_option_character_set

/ kw:(KW_COMMENT / 'CONNECTION'i) __ s:(KW_ASSIGIN_EQUAL)? __ c:literal_string {

return {

keyword: kw.toLowerCase(),

symbol: s,

value: `'${c.value}'`

}

}

/ kw:'COMPRESSION'i __ s:(KW_ASSIGIN_EQUAL)? __ v:("'"('ZLIB'i / 'LZ4'i / 'NONE'i)"'") {

return {

keyword: kw.toLowerCase(),

symbol: s,

value: v.join('').toUpperCase()

}

}

/ kw:'ENGINE'i __ s:(KW_ASSIGIN_EQUAL)? __ c:ident_name {

return {

keyword: kw.toLowerCase(),

symbol: s,

value: c.toUpperCase()

}

}

ALTER_ADD_FULLETXT_SPARITAL_INDEX

= KW_ADD __

fsid:create_fulltext_spatial_index_definition

{

return {

action: 'add',

type: 'alter',

...fsid,

}

}

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

}

};

}

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

}

}

}

unlock_stmt

= KW_UNLOCK __ KW_TABLES {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'unlock',

keyword: 'tables'

}

}

}

lock_type

= "READ"i __ s:("LOCAL"i)? {

return {

type: 'read',

suffix: s && 'local'

}

}

/ p:("LOW_PRIORITY"i)? __ "WRITE"i {

return {

type: 'write',

prefix: p && 'low_priority'

}

}

lock_table

= t:table_base __ lt:lock_type {

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

return {

table: t,

lock_type: lt

}

}

lock_table_list

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

return createList(head, tail);

}

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

}

}

}

call_stmt

= KW_CALL __

e: proc_func_call {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'call',

expr: e

}

}

}

select_stmt

= select_stmt_nake

/ s:('(' __ select_stmt __ ')') {

return {

...s[2],

parentheses_symbol: true,

}

}

with_clause

= KW_WITH __ head:cte_definition tail:(__ COMMA __ cte_definition)* {

return createList(head, tail);

}

/ __ KW_WITH __ KW_RECURSIVE __ cte:cte_definition {

cte.recursive = true;

return [cte]

}

cte_definition

= name:(literal_string / ident_name) __ columns:cte_column_definition? __ KW_AS __ LPAREN __ stmt:union_stmt __ RPAREN {

if (typeof name === 'string') name = { type: 'default', value: name }

return { name, stmt, columns };

}

cte_column_definition

= LPAREN __ l:column_ref_list __ RPAREN {

return l

}

select_stmt_nake

= __ cte:with_clause? __ KW_SELECT ___

opts:option_clause? __

d:KW_DISTINCT? __

c:column_clause __

f:from_clause? __

w:where_clause? __

g:group_by_clause? __

h:having_clause? __

o:order_by_clause? __

l:limit_clause? {

if(f) f.forEach(info => info.table && tableList.add(`select::${info.db}::${info.table}`));

return {

with: cte,

type: 'select',

options: opts,

distinct: d,

columns: c,

from: f,

where: w,

groupby: g,

having: h,

orderby: o,

limit: l

};

}

// MySQL extensions to standard SQL

option_clause

= head:query_option tail:(__ query_option)* {

const opts = [head];

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

opts.push(tail[i][1]);

}

return opts;