{

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,

'INTERVAL': true,

'IS': true,

'JOIN': true,

'JSON': true,

'KEY': true,

'LEFT': true,

'LIKE': true,

'LIMIT': true,

'NOT': true,

'NULL': true,

'NULLS': true,

'ON': true,

'OR': true,

'ORDER': true,

'OUTER': true,

'RECURSIVE': true,

'RENAME': true,

// 'REPLACE': true,

'RIGHT': true,

'SELECT': true,

'SESSION_USER': true,

'SET': true,

'SHOW': true,

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

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

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

}

function commonStrToLiteral(strOrLiteral) {

return typeof strOrLiteral === 'string' ? { type: 'same', value: strOrLiteral } : strOrLiteral

}

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 / cmd_stmt / crud_stmt) {

// => multiple_stmt | cmd_stmt | crud_stmt

return n

}

cmd_stmt

= drop_stmt

/ create_stmt

/ truncate_stmt

/ rename_stmt

/ call_stmt

/ use_stmt

/ alter_stmt

/ set_stmt

/ lock_stmt

create_stmt

= create_table_stmt

/ create_constraint_trigger

/ create_extension_stmt

/ create_index_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)+ {

/*

// is in reality: { tableList: any[]; columnList: any[]; ast: T; }

export type AstStatement<T> = T;

=> AstStatement<crud_stmt[]> */

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

}

}

union_stmt

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

/* export interface union_stmt_node extends select_stmt_node {

_next: union_stmt_node;

union: 'union' | 'union all';

}

=> AstStatement<union_stmt_node>

*/

let cur = head

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

cur._next = tail[i][5]

cur.union = tail[i][3] ? 'union all' : 'union'

cur = cur._next

}

if(ob) head._orderby = ob

if(l) head._limit = l

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: head

}

}

if_not_exists_stmt

= 'IF'i __ KW_NOT __ KW_EXISTS {

return 'IF NOT EXISTS'

}

create_extension_stmt

= a:KW_CREATE __

e:'EXTENSION'i __

ife: if_not_exists_stmt? __

n:(ident_name / literal_string) __

w:KW_WITH? __

s:('SCHEMA'i __ ident_name / literal_string)? __

v:('VERSION'i __ (ident_name / literal_string))? __

f:(KW_FROM __ (ident_name / literal_string))? {

/*

export type nameOrLiteral = literal_string | { type: 'same', value: string; };

=> {

type: 'create';

keyword: 'extension';

if_not_exists?: 'if not exists';

extension: nameOrLiteral;

with: 'with';

schema: nameOrLiteral;

version: nameOrLiteral;

from: nameOrLiteral;

}

*/

return {

type: 'create',

keyword: e.toLowerCase(),

if_not_exists:ife,

extension: commonStrToLiteral(n),

with: w && w[0].toLowerCase(),

schema: commonStrToLiteral(s && s[2].toLowerCase()), // <== wont that be a bug ?

version: commonStrToLiteral(v && v[2]),

from: commonStrToLiteral(f && f[2]),

}

}

create_db_definition

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

return createList(head, tail, 1)

}

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

/*

export type create_table_stmt_node = create_table_stmt_node_simple | create_table_stmt_node_like;

export interface create_table_stmt_node_base {

type: 'create';

keyword: 'table';

temporary?: 'temporary';

if_not_exists?: 'if not exists';

table: table_ref_list;

}

export interface create_table_stmt_node_simple extends create_table_stmt_node_base{

ignore_replace?: 'ignore' | 'replace';

as?: 'as';

query_expr?: union_stmt_node;

create_definition?: create_table_definition;

table_options?: table_options;

}

=> AstStatement<create_table_stmt_node>

*/

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 {

/*

export interface create_table_stmt_node_like extends create_table_stmt_node_base{

like: create_like_table;

}

=> AstStatement<create_table_stmt_node>;

*/

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_index_stmt

= a:KW_CREATE __

kw:KW_UNIQUE? __

t:KW_INDEX __

co:KW_CONCURRENTLY? __

n:ident? __

on:KW_ON __

ta:table_name __

um:index_type? __

LPAREN __ cols:column_order_list __ RPAREN __

wr:(KW_WITH __ LPAREN __ index_options_list __ RPAREN)? __

ts:(KW_TABLESPACE __ ident_name)? __

w:where_clause? __ {

/*

export interface create_index_stmt_node {

type: 'create';

index_type?: 'unique';

keyword: 'index';

concurrently?: 'concurrently';

index: string;

on_kw: string;

table: table_name;

index_using?: index_type;

index_columns: column_order[];

with?: index_option[];

with_before_where: true;

tablespace?: {type: 'origin'; value: string; }

where?: where_clause;

}

=> AstStatement<create_index_stmt_node>

*/

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

index_type: kw && kw.toLowerCase(),

keyword: t.toLowerCase(),

concurrently: co && co.toLowerCase(),

index: n,

on_kw: on[0].toLowerCase(),

table: ta,

index_using: um,

index_columns: cols,

with: wr && wr[4],

with_before_where: true,

tablespace: ts && { type: 'origin', value: ts[2] },

where: w,

}

}

}

column_order_list

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

// => column_order[]

return createList(head, tail)

}

column_order

= c:expr __

ca:collate_expr? __

op:ident? __

o:(KW_ASC / KW_DESC)? __

nf:('NULLS'i __ ('FIRST'i / 'LAST'i))? {

/*

=> {

column: expr;

collate: collate_expr;

opclass: ident;

order: 'asc' | 'desc';

nulls: 'nulls last' | 'nulls first';

}

*/

return {

column: c,

collate: ca,

opclass: op,

order: o && o.toLowerCase() || 'asc',

nulls: nf && `${nf[0].toLowerCase()} ${nf[2].toLowerCase()}`,

}

}

create_like_table_simple

= KW_LIKE __ t: table_ref_list {

// => { type: 'like'; table: table_ref_list; }

return {

type: 'like',

table: t

}

}

create_like_table

= create_like_table_simple

/ LPAREN __ e:create_like_table __ RPAREN {

// => create_like_table_simple & { parentheses?: boolean; }

e.parentheses = true;

return e;

}

create_table_definition

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

// => create_definition[]

return createList(head, tail);

}

create_definition

= create_column_definition

/ create_index_definition

/ create_fulltext_spatial_index_definition

/ create_constraint_definition

create_column_definition

= c:column_ref __

d:data_type __

clc:column_constraint? __

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

/*

=> {

column: column_ref;

definition: data_type;

nullable: column_constraint['nullable'];

default_val: column_constraint['default_val'];

auto_increment?: 'auto_increment';

unique_or_primary?: 'unique' | 'primary key';

comment?: keyword_comment;

collate?: collate_expr;

column_format?: column_format;

storage?: storage;

reference_definition?: reference_definition;

resource: 'column';

}

*/

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

return {

column: c,

definition: d,

nullable: clc && clc.nullable,

default_val: clc && clc.default_val,

auto_increment: a && a.toLowerCase(),

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

comment: co,

collate: ca,

column_format: cf,

storage:s,

reference_definition: re,

resource: 'column'

}

}

column_constraint

= n:(literal_not_null / literal_null) __ df:default_expr? {

// => { nullable: literal_null | literal_not_null; default_val: default_expr; }

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

return {

default_val: df,

nullable: n

}

}

/ df:default_expr __ n:(literal_not_null / literal_null)? {

// => { nullable: literal_null | literal_not_null; default_val: default_expr; }

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

return {

default_val: df,

nullable: n

}

}

collate_expr

= KW_COLLATE __ ca:ident {

// => { type: 'collate'; value: ident; }

return {

type: 'collate',

value: ca,

}

}

column_format

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

// => { type: 'column_format'; value: 'fixed' | 'dynamic' | 'default'; }

return {

type: 'column_format',

value: f.toLowerCase()

}

}

storage

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

// => { type: 'storage'; value: 'disk' | 'memory' }

return {

type: 'storage',

value: s.toLowerCase()

}

}

default_expr

= KW_DEFAULT __ ce: (literal / expr) {

// => { type: 'default'; value: 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 {

/*

export interface truncate_stmt_node {

type: 'trucate';

keyword: 'table';

name: table_ref_list;

}

=> AstStatement<truncate_stmt_node>

*/

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 {

/*

export interface use_stmt_node {

type: 'use';

db: ident;

}

=> AstStatement<use_stmt_node>

*/

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 {

/*

export interface alter_table_stmt_node {

type: 'alter';

table: table_ref_list;

expr: alter_action_list;

}

=> AstStatement<alter_table_stmt_node>

*/

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

// => 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 {

/*

=> {

action: 'add';

keyword: KW_COLUMN;

resource: 'column';

type: 'alter';

} & create_column_definition;

*/

return {

action: 'add',

...cd,

keyword: kc,

resource: 'column',

type: 'alter',

}

}

ALTER_DROP_COLUMN

= KW_DROP __

kc:KW_COLUMN? __

c:column_ref {

/* => {

action: 'drop';

collumn: column_ref;

keyword: KW_COLUMN;

resource: 'column';

type: 'alter';

} */

return {

action: 'drop',

column: c,

keyword: kc,

resource: 'column',

type: 'alter',

}

}

ALTER_ADD_INDEX_OR_KEY

= KW_ADD __

id:create_index_definition

{

/* => {

action: 'add';

type: 'alter';

} & create_index_definition */

return {

action: 'add',

type: 'alter',

...id,

}

}

ALTER_RENAME_TABLE

= KW_RENAME __

kw:(KW_TO / KW_AS)? __

tn:ident {

/* => {

action: 'rename';

type: 'alter';

resource: 'table';

keyword?: 'to' | 'as';

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

/* => {

type: 'alter';

keyword: 'algorithm';

resource: 'algorithm';

symbol?: '=';

algorithm: 'DEFAULT' | 'INSTANT' | 'INPLACE' | 'COPY';

}*/

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

/* => {

type: 'alter';

keyword: 'lock';

resource: 'lock';

symbol?: '=';

lock: 'DEFAULT' | 'NONE' | 'SHARED' | 'EXCLUSIVE';

}*/

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

{

/* => {

index: column;

definition: cte_column_definition;

keyword: 'index' | 'key';

index_type?: index_type;

resource: 'index';

index_options?: 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? __

{

/* => {

index: column;

definition: cte_column_definition;

keyword: 'fulltext' | 'spatial' | 'fulltext key' | 'spatial key' | 'fulltext index' | 'spatial index';

index_options?: index_options;

resource: 'index';

}*/

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

// => { keyword: 'constraint'; constraint: 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? {

/* => {

constraint?: constraint_name['constraint'];

definition: cte_column_definition;

constraint_type: 'primary key';

index_type?: index_type;

resource: 'constraint';

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

/* => {

constraint?: constraint_name['constraint'];

definition: cte_column_definition;

constraint_type: 'unique key' | 'unique' | 'unique index';

index_type?: index_type;

resource: 'constraint';

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

/* => {

constraint?: constraint_name['constraint'];

definition: cte_column_definition;

constraint_type: 'FOREIGN KEY';

keyword: constraint_name['keyword'];

index?: column;

resource: 'constraint';

reference_definition?: reference_definition;

}*/

return {

constraint: kc && kc.constraint,

definition: de,

constraint_type: p,

keyword: kc && kc.keyword,

index: i,

resource: 'constraint',

reference_definition: id

}

}