{

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,

'EXCEPT': true,

'FALSE': true,

'FROM': true,

'FULL': true,

'GROUP': true,

'HAVING': true,

'IN': true,

'INNER': true,

'INSERT': true,

'INTERSECT': true,

'INTO': true,

'IS': true,

'JOIN': true,

'JSON': true,

// 'KEY': true,

'LEFT': true,

'LIKE': true,

'LIMIT': true,

'NOT': true,

'NULL': true,

'NULLS': true,

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

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

'WINDOW': true,

'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 = Array.isArray(head) ? head : [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:(create_function_stmt / multiple_stmt) {

// => multiple_stmt

return n

}

cmd_stmt

= drop_stmt

/ create_stmt

/ declare_stmt

/ truncate_stmt

/ rename_stmt

/ call_stmt

/ use_stmt

/ alter_stmt

/ set_stmt

/ lock_stmt

/ show_stmt

/ deallocate_stmt

/ grant_revoke_stmt

/ if_else_stmt

/ raise_stmt

/ execute_stmt

/ for_loop_stmt

create_stmt

= create_table_stmt

/ create_constraint_trigger

/ create_extension_stmt

/ create_index_stmt

/ create_sequence

/ create_db_stmt

/ create_domain_stmt

/ create_type_stmt

/ create_view_stmt

/ create_aggregate_stmt

alter_stmt

= alter_table_stmt

/ alter_schema_stmt

/ alter_domain_type_stmt

/ alter_function_stmt

/ alter_aggregate_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<curd_stmt | 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 __ a:(KW_ALL / KW_DISTINCT)? {

// => 'union' | 'union all' | 'union distinct'

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

}

/ KW_INTERSECT { return 'intersect' }

/ KW_EXCEPT { return 'except' }

union_stmt

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

/* export interface union_stmt_node extends select_stmt_node {

_next: union_stmt_node;

set_op: 'union' | 'union all' | 'union distinct';

}

=> AstStatement<union_stmt_node>

*/

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 && l.value && l.value.length > 0) head._limit = l

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: head

}

}

if_not_exists_stmt

= 'IF'i __ KW_NOT __ KW_EXISTS {

// => 'IF NOT 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)* {

// => create_option_character_set[]

return createList(head, tail, 1)

}

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

// => {type: string; value: string; symbol: string; }

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

}

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

// => {type: string; value: string; symbol: string; }

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

}

with_view_options

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

// => 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_nake __ w:view_with? {

/*

export type create_view_stmt = {

type: 'create',

keyword: 'view',

replace?: 'or replace',

temporary?: 'temporary' | 'temp',

recursive?: 'recursive',

view: table_name,

columns?: column_list,

select: select_stmt_nake,

with_options?: with_options,

with?: string,

}

=> AstStatement<create_view_stmt>

*/

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,

}

}

}

create_aggregate_opt_required

= 'SFUNC'i __ KW_ASSIGIN_EQUAL __ n:table_name __ COMMA __ 'STYPE'i __ KW_ASSIGIN_EQUAL __ d:data_type {

// => { type: string; symbol: '='; value: expr; }[]

return [

{

type: 'sfunc',

symbol: '=',

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

},

{

type: 'stype',

symbol: '=',

value: d,

}

]

}

create_aggregate_opt_optional

= n:ident __ KW_ASSIGIN_EQUAL __ e:(ident / expr) {

// => { type: string; symbol: '='; value: ident | expr; }

return {

type: n,

symbol: '=',

value: typeof e === 'string' ? { type: 'default', value: e } : e

}

}

create_aggregate_opts

= head:create_aggregate_opt_required tail:(__ COMMA __ create_aggregate_opt_optional)* {

// => create_aggregate_opt_optional[]

return createList(head, tail)

}

create_aggregate_stmt

= a:KW_CREATE __ or:(KW_OR __ KW_REPLACE)? __ t:'AGGREGATE'i __ s:table_name __ LPAREN __ as:aggregate_signature __ RPAREN __ LPAREN __ opts:create_aggregate_opts __ RPAREN {

/*

export type create_aggregate_stmt = {

type: 'create',

keyword: 'aggregate',

replace?: 'or replace',

name: table_name,

args?: aggregate_signature,

options: create_aggregate_opt_optional[]

}

=> AstStatement<create_aggregate_stmt>

*/

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'create',

keyword: 'aggregate',

replace: or && 'or replace',

name: { schema: s.db, name: s.table },

args: {

parentheses: true,

expr: as,

orderby: as.orderby

},

options: opts

}

};

}

column_data_type

= c:column_ref __ d:data_type {

// => { column: column_ref; definition: data_type; }

return {

column: c,

definition: d,

}

}

column_data_type_list

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

// => column_data_type[]

return createList(head, tail)

}

func_returns

= 'RETURNS'i __ k:'SETOF'i? __ t:(data_type / table_name) {

// => { type: "returns"; keyword?: "setof"; expr: data_type; }

return {

type: 'returns',

keyword: k,

expr: t

}

}

/ 'RETURNS'i __ KW_TABLE __ LPAREN __ e:column_data_type_list __ RPAREN {

// => { type: "returns"; keyword?: "table"; expr: column_data_type_list; }

return {

type: 'returns',

keyword: 'table',

expr: e

}

}

declare_variable_item

= n:ident_name &{ return n.toLowerCase() !== 'begin' } __ c:'CONSTANT'i? __ d:data_type __ collate:collate_expr? __ nu:(KW_NOT __ KW_NULL)? __ expr:((KW_DEFAULT / ':=')? __ (&'BEGIN'i / literal / expr))? __ s:SEMICOLON? {

// => { keyword: 'variable'; name: string, constant?: string; datatype: data_type; collate?: collate; not_null?: string; default?: { type: 'default'; keyword: string; value: literal | expr; }; }

return {

keyword: 'variable',

name: n,

constant: c,

datatype: d,

collate,

not_null: nu && 'not null',

definition: expr && expr[0] && {

type: 'default',

keyword: expr[0],

value: expr[2]

},

}

}

declare_variables

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

// => declare_variable_item[]

return createList(head, tail, 1)

}

declare_stmt

= 'DECLARE'i __ vars:declare_variables {

/*

export type declare_stmt = { type: 'declare'; declare: declare_variable_item[]; }

=> AstStatement<declare_stmt>

*/

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: 'declare',

declare: vars,

symbol: ';',

}

}

}

create_func_opt

= 'LANGUAGE' __ ln:ident_name __ {

// => literal_string

return {

prefix: 'LANGUAGE',

type: 'default',

value: ln

}

}

/ 'TRANSORM'i __ ft:('FOR' __ 'TYPE' __ ident_name)? __ {

// => literal_string

if (!ft) return { type: 'origin', value: 'TRANSORM' }

return {

prefix: ['TRANSORM', ft[0].toUpperCase(), ft[2].toUpperCase()].join(' '),

type: 'default',

value: ft[4]

}

}

/ i:('WINDOW'i / 'IMMUTABLE'i / 'STABLE'i / 'VOLATILE'i / 'STRICT'i) __ {

// => literal_string

return {

type: 'origin',

value: i

}

}

/ n:('NOT'i)? __ 'LEAKPROOF'i __ {

// => literal_string

return {

type: 'origin',

value: [n, 'LEAKPROOF'].filter(v => v).join(' ')

}

}

/ i:('CALLED'i / ('RETURNS'i __ 'NULL'i))? __ 'ON'i __ 'NULL'i __ 'INPUT'i __ {

// => literal_string

if (Array.isArray(i)) i = [i[0], i[2]].join(' ')

return {

type: 'origin',

value: `${i} ON NULL INPUT`

}

}

/ e:('EXTERNAL'i)? __ 'SECURITY'i __ i:('INVOKER'i / 'DEFINER'i) __ {

// => literal_string

return {

type: 'origin',

value: [e, 'SECURITY', i].filter(v => v).join(' ')

}

}

/ 'PARALLEL'i __ i:('UNSAFE'i / 'RESTRICTED'i / 'SAFE'i) __ {

// => literal_string

return {

type: 'origin',

value: ['PARALLEL', i].join(' ')

}

}

/ KW_AS __ c:[^ \s\t\n\r]+ __ de:declare_stmt? __ b:('BEGIN'i)? __ s:multiple_stmt __ e:KW_END? &{ return (b && e) || (!b && !e) } __ SEMICOLON? __ l:[^ \s\t\n\r;]+ __ {

// => { type: 'as'; begin?: string; declare?: declare_stmt; expr: multiple_stmt; end?: string; symbol: string; }

const start = c.join('')

const end = l.join('')

if (start !== end) throw new Error(`start symbol '${start}'is not same with end symbol '${end}'`)

return {

type: 'as',

declare: de && de.ast,

begin: b,

expr: Array.isArray(s.ast) ? s.ast.flat() : [s.ast],

end: e && e[0],

symbol: start,

}

}

/ p:('COST'i / 'ROWS'i) __ n:literal_numeric __ {

// => literal_numeric

n.prefix = p

return n

}

/ 'SUPPORT'i __ n:proc_func_name __ {

// => literal_string

return {

prefix: 'support',

type: 'default',

value: n

}

}

/ KW_SET __ ca:ident_name __ e:((('TO'i / '=') __ ident_list) / (KW_FROM __ 'CURRENT'i))? __ {

// => { type: "set"; parameter: ident_name; value?: { prefix: string; expr: expr }}

let value

if (e) {

const val = Array.isArray(e[2]) ? e[2] : [e[2]]

value = {

prefix: e[0],

expr: val.map(v => ({ type: 'default', value: v }))

}

}

return {

type: 'set',

parameter: ca,

value,

}

}

create_function_stmt

= a:KW_CREATE __

or:(KW_OR __ KW_REPLACE)? __

t:'FUNCTION'i __

c:table_name __ LPAREN __ args:alter_func_args? __ RPAREN __

r:func_returns? __

fo:create_func_opt* __ SEMICOLON? __ {

/*

export type create_function_stmt = {

type: 'create';

replace?: string;

name: { schema?: string; name: string };

args?: alter_func_args;

returns?: func_returns;

keyword: 'function';

options?: create_func_opt[];

}

=> AstStatement<create_function_stmt>

*/

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

args: args || [],

type: 'create',

replace: or && 'or replace',

name: { schema: c.db, name: c.table },

returns: r,

keyword: t && t.toLowerCase(),

options: fo || [],

}

}

}

create_type_stmt

= a:KW_CREATE __ k:'TYPE'i __ s:table_name __ as:KW_AS __ r:KW_ENUM __ LPAREN __ e:expr_list? __ RPAREN {

/*

export type create_type_stmt = {

type: 'create',

keyword: 'type',

name: { schema: string; name: string },

as?: string,

resource?: string,

create_definitions?: any

}

=> AstStatement<create_type_stmt>

*/

e.parentheses = true

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: k.toLowerCase(),

name: { schema: s.db, name: s.table },

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

resource: r.toLowerCase(),

create_definitions: e,

}

}

}

/ a:KW_CREATE __ k:'TYPE'i __ s:table_name {

// => AstStatement<create_type_stmt>

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: k.toLowerCase(),

name: { schema: s.db, name: s.table },

}

}

}

create_domain_stmt

= a:KW_CREATE __ k:'DOMAIN'i __ s:table_name __ as:KW_AS? __ d:data_type __ ce:collate_expr? __ de:default_expr? __ ccc: create_constraint_check? {

/*

export type create_domain_stmt = {

type: 'create',

keyword: 'domain',

domain: { schema: string; name: string },

as?: string,

target: data_type,

create_definitions?: any[]

}

=> AstStatement<create_domain_stmt>

*/

if (ccc) ccc.type = 'constraint'

const definitions = [ce, de, ccc].filter(v => v)

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: k.toLowerCase(),

domain: { schema: s.db, name: s.table },

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

target: d,

create_definitions: definitions,

}

}

}

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_definitions?: create_table_definition;

table_options?: table_options;

}

=> AstStatement<create_table_stmt_node>

*/

if(t) t.forEach(tt => tableList.add(`create::${[tt.db, tt.schema].filter(Boolean).join('.') || null}::${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.schema].filter(Boolean).join('.') || null}::${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_sequence

= a:KW_CREATE __

tp:(KW_TEMPORARY / KW_TEMP)? __

KW_SEQUENCE __

ife:if_not_exists_stmt? __

t:table_name __ as:(KW_AS __ alias_ident)?__

c:create_sequence_definition_list? {

/*

export type create_sequence_stmt = {

type: 'create',

keyword: 'sequence',

temporary?: 'temporary' | 'temp',

if_not_exists?: 'if not exists',

table: table_ref_list,

create_definitions?: create_sequence_definition_list

}

=> AstStatement<create_sequence_stmt>

*/

t.as = as && as[2]

return {

tableList: Array.from(tableList),

columnList: columnListTableAlias(columnList),

ast: {

type: a[0].toLowerCase(),

keyword: 'sequence',

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

if_not_exists:ife,

sequence: [t],

create_definitions: c,

}

}

}

sequence_definition_increment

= k:'INCREMENT'i __ b:KW_BY? __ n:literal_numeric {

/*

export type sequence_definition = { "resource": "sequence", prefix?: string,value: literal | column_ref }

=> sequence_definition

*/

return {

resource: 'sequence',

prefix: b ? `${k.toLowerCase()} by` : k.toLowerCase(),

value: n

}

}

sequence_definition_minval

= k:'MINVALUE'i __ n:literal_numeric {

// => sequence_definition

return {

resource: 'sequence',

prefix: k.toLowerCase(),

value: n

}

}

/ 'NO'i __ 'MINVALUE'i {

// => sequence_definition

return {

resource: 'sequence',

value: {

type: 'origin',

value: 'no minvalue'

}

}

}

sequence_definition_maxval

= k:'MAXVALUE'i __ n:literal_numeric {

// => sequence_definition

return {

resource: 'sequence',

prefix: k.toLowerCase(),

value: n

}

}

/ 'NO'i __ 'MAXVALUE'i {

// => sequence_definition

return {

resource: 'sequence',

value: {

type: 'origin',

value: 'no maxvalue'

}

}

}

sequence_definition_start

= k:'START'i __ w:KW_WITH? __ n:literal_numeric {

// => sequence_definition

return {

resource: 'sequence',

prefix: w ? `${k.toLowerCase()} with` : k.toLowerCase(),

value: n

}

}

sequence_definition_cache

= k:'CACHE'i __ n:literal_numeric {

// => sequence_definition

return {

resource: 'sequence',

prefix: k.toLowerCase(),

value: n

}

}

sequence_definition_cycle

= n:'NO'i? __ 'CYCLE'i {

// => sequence_definition

return {

resource: 'sequence',

value: {

type: 'origin',

value: n ? 'no cycle' : 'cycle'

}

}

}

sequence_definition_owned

= 'OWNED'i __ KW_BY __ 'NONE'i {

// => sequence_definition

return {

resource: 'sequence',

prefix: 'owned by',

value: {

type: 'origin',

value: 'none'

}

}

}

/ n:'OWNED'i __ KW_BY __ col:column_ref {

// => sequence_definition

return {

resource: 'sequence',

prefix: 'owned by',

value: col

}

}

create_sequence_definition

= sequence_definition_increment

/ sequence_definition_minval

/ sequence_definition_maxval

/ sequence_definition_start

/ sequence_definition_cache

/ sequence_definition_cycle

/ sequence_definition_owned

create_sequence_definition_list

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

// => create_sequence_definition[]

return createList(head, tail, 1)

}