{

const reservedMap = {

'ALTER': true,

'ALL': true,

'ADD': true,

'AND': true,

'AS': true,

'ASC': true,

'BETWEEN': true,

'BY': true,

'CALL': true,

'CASE': true,

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

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

'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 = {};

}

= __ n:(multiple_stmt) {

return n

}

= 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

= create_table_stmt

/ create_db_stmt

/ create_trigger_stmt

/ create_view_stmt

= alter_table_stmt

= union_stmt

/ update_stmt

/ replace_insert_stmt

/ insert_no_columns_stmt

/ insert_into_set

/ delete_stmt

/ cmd_stmt

/ proc_stmts

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

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

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

if (!tail) tail = []

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

}

}

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

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

}

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

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

}

}

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

return createList(head, tail, 1)

}

= 'IF'i __ KW_NOT __ KW_EXISTS {

return 'IF NOT EXISTS'

}

= kw: KW_CREATE __

tp:(KW_TEMPORARY / KW_TEMP)? __

t:('TRIGGER'i) __

ife:if_not_exists_stmt? __

c:table_name __

p:('BEFORE'i / 'AFTER'i / 'INSTEAD OF'i)? __

te:trigger_event_list __

on:'ON'i __

tn:table_name __

fe:trigger_for_row? __

tw:trigger_when? __

ta:trigger_action {

return {

type: 'create',

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

time: p && p.toLowerCase(),

events: te,

trigger: c,

table: tn,

for_each: fe,

if_not_exists: ife,

when: tw,

execute: ta,

keyword: t && t.toLowerCase(),

}

}

= kw:(KW_INSERT / KW_DELETE) {

return {

keyword: kw[0].toLowerCase(),

}

}

/ kw:KW_UPDATE __ a:('OF'i __ column_ref_list)? {

return {

keyword: kw[0].toLowerCase(),

args: a && { keyword: a[0], columns: a[2] } || null

}

}

= head:trigger_event tail:(__ KW_OR __ trigger_event)* {

return createList(head, tail)

}

= b:'BEGIN'i __ ms:multiple_stmt __ e:'END'i {

return {

type: 'multiple',

prefix: b,

expr: ms,

suffix: e,

}

}

= kw:'FOR'i __ e:('EACH'i)? __ ob:('ROW'i / 'STATEMENT'i) {

return {

keyword: e ? `${kw.toLowerCase()} ${e.toLowerCase()}` : kw.toLowerCase(),

args: ob.toLowerCase()

}

}

= KW_WHEN __ condition:expr {

return {

type: 'when',

cond: condition,

}

}

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

}

}

}

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

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

}

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

return 'with check option'

}

= a:KW_CREATE __ tp:(KW_TEMP / KW_TEMPORARY)? __

KW_VIEW __ ife:if_not_exists_stmt? __ v:table_name __ c:(LPAREN __ column_list __ RPAREN)? __

KW_AS __ s:select_stmt_nake {

v.view = v.table

delete v.table

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: 'view',

if_not_exists: ife,

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

columns: c && c[2],

select: s,

view: v,

}

}

}

= a:KW_CREATE __

tp:KW_TEMPORARY? __

KW_TABLE __

ife:if_not_exists_stmt? __

t:table_name __

c:create_table_definition? __

to:table_options? __

ir: (KW_IGNORE / KW_REPLACE)? __

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

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_name __

lt:create_like_table {

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

like: lt

}

}

}

= KW_LIKE __ t: table_ref_list {

return {

type: 'like',

table: t

}

}

= create_like_table_simple

/ LPAREN __ e:create_like_table __ RPAREN {

e.parentheses = true;

return e;

}

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

return createList(head, tail);

}

= create_constraint_definition

/ create_column_definition

/ create_index_definition

/ create_fulltext_spatial_index_definition

= 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 / 'AUTOINCREMENT'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 }

}

/ t:create_option_character_set_kw __ s:KW_ASSIGIN_EQUAL? __ v:ident_name {

return { character_set: { type: t, value: v, symbol: s }}

}

= 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

}

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

}

}

= KW_COLLATE __ s:KW_ASSIGIN_EQUAL? __ ca:ident_name {

return {

type: 'collate',

symbol: s,

value: ca,

}

}

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

return {

type: 'column_format',

value: f.toLowerCase()

}

}

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

return {

type: 'storage',

value: s.toLowerCase()

}

}

= KW_DEFAULT __ ce: (literal / expr) {

return {

type: 'default',

value: ce

}

}

= 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

}

};

}

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

}

};

}

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

return createList(head, tail, 1)

}

= 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

}

};

}

= 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

}

};

}

= KW_USE __

d:ident {

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

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'use',

db: d

}

};

}

= 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

}

};

}

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

return createList(head, tail);

}

= ALTER_ADD_COLUMN

/ ALTER_DROP_COLUMN

/ ALTER_RENAME_TABLE

= KW_ADD __

kc:KW_COLUMN? __

cd:create_column_definition {

return {

action: 'add',

...cd,

keyword: kc,

resource: 'column',

type: 'alter',

}

}

= KW_DROP __

kc:KW_COLUMN? __

c:column_ref {

return {

action: 'drop',

column: c,

keyword: kc,

resource: 'column',

type: 'alter',

}

}

= KW_RENAME __

kw:(KW_TO / KW_AS)? __

tn:ident {

return {

action: 'rename',

type: 'alter',

resource: 'table',

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

table: tn

}

}

= "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

}

}

= "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

}

}

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

}

}

= 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_primary

/ create_constraint_unique

/ create_constraint_foreign

/ create_constraint_check

= kc:KW_CONSTRAINT __

c:ident? {

return {

keyword: kc.toLowerCase(),

constraint: c

}

}

= kc:constraint_name? __

p:('PRIMARY'i __ 'KEY'i) __

t:index_type? __

de:cte_column_definition __

id:index_options? {

return {

constraint: kc && kc.constraint,

definition: de,

constraint_type: `${p[0].toLowerCase()} ${p[2].toLowerCase()}`,

keyword: kc && kc.keyword,

index_type: t,

resource: 'constraint',

index_options: id,

}

}

= 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

}

}

= kc:constraint_name? __ u:'CHECK'i __ nfr:('NOT'i __ 'FOR'i __ 'REPLICATION'i __)? LPAREN __ c:expr __ RPAREN {

return {

constraint_type: u.toLowerCase(),

keyword: kc && kc.keyword,

constraint: kc && kc.constraint,

index_type: nfr && { keyword: 'not for replication' },

definition: [c],

resource: 'constraint',

}

}

= 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

}

}

= 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]

}

}

= 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

}

}

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

}

}

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

return createList(head, tail)

}

= 'CHARACTER'i __ 'SET'i {

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

}

}

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

}

}

= 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

}

};

}

= 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

}

}

}

= KW_UNLOCK __ KW_TABLES {

return {

tableList: Array.from(tableList),