{

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

};

}

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

}

= 'if'i __ 'exists'i {

return 'if 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_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,

}

}

}

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

return createList(head, tail)

}

= c:expr __ ce:collate_expr? __ o:(KW_ASC / KW_DESC)? {

return {

collate: ce,

...c,

order_by: o && o.toLowerCase(),

}

}

/ column_order

= c:column_ref __ o:(KW_ASC / KW_DESC)? {

return {

...c,

order_by: o && o.toLowerCase(),

}

}

= a:KW_CREATE __

kw:(KW_UNIQUE)? __

t:KW_INDEX __

ife:if_not_exists_stmt? __

n:table_name __

um:index_type? __

on:KW_ON __

ta:table_name __ LPAREN __ cols:column_order_list __ RPAREN __

where:where_clause? {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

index_type: kw && kw.toLowerCase(),

keyword: t.toLowerCase(),

if_not_exists: ife,

index: { schema: n.db, name: n.table },

on_kw: on[0].toLowerCase(),

table: ta,

index_columns: cols,

where,

}

}

}

= 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_TEMP)? __

KW_TABLE __

ife:if_not_exists_stmt? __

t:table_name __

c:create_table_definition __

to:table_options? {

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

create_definitions: c,

table_options: to

}

}

}

/ a:KW_CREATE __

tp:(KW_TEMPORARY / KW_TEMP)? __

KW_TABLE __

ife:if_not_exists_stmt? __

t:table_name __

as:KW_AS __

qe:select_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],

as: 'as',

query_expr: qe,

}

}

}

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

}

/ kc:KW_CONSTRAINT __ n:ident_without_kw_type {

return { constraint: { keyword: kc.toLowerCase(), constraint: n } }

}

/ 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 }

}

/ ck:check_constraint_definition {

return { check: ck }

}

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

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

d:data_type? __

cdo:column_definition_opt_list? {

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

return {

column: {

type: 'column_ref',

table: null,

column: c

},

definition: d,

resource: 'column',

...(cdo || {})

}

}

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

return {

type: 'collate',

keyword: 'collate',

collate: {

name: ca,

symbol: s,

}

}

}

= 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: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 __

ife:if_exists? __

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

prefix: ife,

name: t

}

};

}

/ a:KW_DROP __

r:KW_VIEW __

ife:if_exists? __

t:table_ref_list {

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a.toLowerCase(),

keyword: r.toLowerCase(),

prefix: ife,

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

}

};

}

= k:"first"i {

return { keyword: k };

}

/ k:"after"i __ i:column_ref {

return { keyword: k, expr: i };

}

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

return createList(head, tail);

}

= ALTER_ADD_CONSTRAINT

/ ALTER_DROP_CONSTRAINT

/ ALTER_DROP_KEY_INDEX

/ ALTER_ADD_COLUMN

/ ALTER_DROP_COLUMN

/ ALTER_MODIFY_COLUMN

/ ALTER_ADD_INDEX_OR_KEY

/ ALTER_RENAME_COLUMN

/ ALTER_RENAME_TABLE

/ ALTER_ALGORITHM

/ ALTER_LOCK

/ ALTER_CHANGE_COLUMN

/ t:table_option {

t.resource = t.keyword

t[t.keyword] = t.value

delete t.value

return {

type: 'alter',

...t,

}

}

= KW_ADD __ c:create_constraint_definition {

return {

action: 'add',

create_definitions: c,

resource: 'constraint',

type: 'alter',

}

}

= KW_DROP __ kc:'CHECK'i __ c:ident_name {

return {

action: 'drop',

constraint: c,

keyword: kc.toLowerCase(),

resource: 'constraint',

type: 'alter',

}

}

= KW_DROP __ 'PRIMARY'i __ KW_KEY {

return {

action: 'drop',

key: '',

keyword: 'primary key',

resource: 'key',

type: 'alter',

}

}

/ KW_DROP __ k:(('FOREIGN'i? __ KW_KEY) / (KW_INDEX)) __ c:ident {

const resource = Array.isArray(k) ? 'key' : 'index'

return {

action: 'drop',

[resource]: c,

keyword: Array.isArray(k) ? `${[k[0], k[2]].filter(v => v).join(' ').toLowerCase()}` : k.toLowerCase(),

resource,

type: 'alter',

}

}

= 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_MODIFY __

kc:KW_COLUMN? __

cd:create_column_definition __ af:alter_column_suffix? {

return {

action: 'modify',

keyword: kc,

...cd,

suffix: af,

resource: 'column',

type: 'alter',

}

}

= KW_ADD __

id:create_index_definition {

return {

action: 'add',

type: 'alter',

...id,

}

}

= KW_RENAME __ KW_COLUMN __ c:column_ref __

kw:(KW_TO / KW_AS)? __

tn:column_ref {

return {

action: 'rename',

type: 'alter',

resource: 'column',

keyword: 'column',

old_column: c,

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

column: tn

}

}

= KW_RENAME __

kw:(KW_TO / KW_AS)? __

tn:ident {

return {

action: 'rename',

type: 'alter',

resource: 'table',

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

table: tn

}

}

= 'CHANGE'i __ kc:KW_COLUMN? __ od:column_ref __ cd:create_column_definition __ af:alter_column_suffix? {

return {

action: 'change',

old_column: od,

...cd,

keyword: kc,

resource: 'column',

type: 'alter',

suffix: af,

}

}

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