export type start = multiple_stmt | create_function_stmt;

export type 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 | transaction_stmt | comment_on_stmt;

export type 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;

export type alter_stmt = alter_table_stmt | alter_schema_stmt | alter_domain_type_stmt | alter_function_stmt | alter_aggregate_stmt;

export type crud_stmt = union_stmt | update_stmt | replace_insert_stmt | insert_no_columns_stmt | delete_stmt | cmd_stmt | proc_stmts;

export type AstStatement<T> = T;

export type multiple_stmt = AstStatement<crud_stmt | crud_stmt[]>;

export type set_op = 'union' | 'union all' | 'union distinct' | 'intersect' | 'except';

export interface union_stmt_node extends select_stmt_node {

_next: union_stmt_node;

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

}

export type union_stmt = AstStatement<union_stmt_node>;

export type if_not_exists_stmt = 'IF NOT EXISTS';

export type if_exists = 'IF EXISTS';

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

export type create_extension_stmt = {

};

export type create_db_definition = create_option_character_set[];

export type create_db_stmt_t = {

}

export type create_db_stmt = AstStatement<create_db_stmt_t>;

export type view_with = string;

export type with_view_option = {type: string; value: string; symbol: string; };

export type with_view_options = with_view_option[];

export type create_view_stmt_t = {

}

export type create_view_stmt = AstStatement<create_view_stmt_t>;

export type create_aggregate_opt_required = { type: string; symbol: '='; value: expr; }[];

export type create_aggregate_opt_optional = { type: string; symbol: '='; value: ident | expr; };

export type create_aggregate_opts = create_aggregate_opt_optional[];

export type create_aggregate_stmt_t = {

}

export type create_aggregate_stmt = AstStatement<create_aggregate_stmt_t>;

export type column_data_type = { column: column_ref; definition: data_type; };

export type column_data_type_list = column_data_type[];

export type func_returns = { type: "returns"; keyword?: "setof"; expr: data_type; } | { type: "returns"; keyword?: "table"; expr: column_data_type_list; };

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

export type declare_variables = declare_variable_item[];

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

export type declare_stmt = AstStatement<declare_stmt_t>;

export type create_func_opt = literal_string | { type: 'as'; begin?: string; declare?: declare_stmt; expr: multiple_stmt; end?: string; symbol: string; } | literal_numeric | { type: "set"; parameter: ident_name; value?: { prefix: string; expr: expr }} | return_stmt;

export type create_function_stmt_t = {

}

export type create_function_stmt = AstStatement<create_function_stmt_t>;

export type create_type_stmt_option = { as: 'as'; resource: string; create_definitions: expr_list | create_column_definition_list; } | ignore;

export type create_type_stmt_t = {

}

export type create_type_stmt = AstStatement<create_type_stmt_t>;

export type create_domain_stmt_t = {

}

export type create_domain_stmt = AstStatement<create_domain_stmt_t>;

export type create_table_stmt_node = create_table_stmt_node_simple | create_table_stmt_node_like;

export interface create_table_stmt_node_base {

}

export interface create_table_stmt_node_simple extends create_table_stmt_node_base{

}

export interface create_table_stmt_node_like extends create_table_stmt_node_base{

like: create_like_table;

}

export type create_table_stmt = AstStatement<create_table_stmt_node_base & { partition_of: create_table_partition_of }> | AstStatement<create_table_stmt_node>;

export type create_sequence_stmt = {

}

export type create_sequence = AstStatement<create_sequence_stmt>;

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

export type sequence_definition_increment = sequence_definition;

export type sequence_definition_minval = sequence_definition;

export type sequence_definition_maxval = sequence_definition;

export type sequence_definition_start = sequence_definition;

export type sequence_definition_cache = sequence_definition;

export type sequence_definition_cycle = sequence_definition;

export type sequence_definition_owned = sequence_definition;

export type create_sequence_definition = sequence_definition_increment | sequence_definition_minval | sequence_definition_maxval | sequence_definition_start | sequence_definition_cache | sequence_definition_cycle | sequence_definition_owned;

export type create_sequence_definition_list = create_sequence_definition[];

export type include_column = { type: 'include', keyword: 'include', columns: column_list };

export interface create_index_stmt_node {

}

export type create_index_stmt = AstStatement<create_index_stmt_node>;

export type column_order_list = column_order[];

export type column_order = {

};

export type create_like_table_simple = { type: 'like'; table: table_ref_list; };

export type create_like_table = create_like_table_simple | create_like_table_simple & { parentheses?: boolean; };

export type for_values_item = {

};

export type for_values = {

};

export type create_table_partition_of = {

};

export type create_table_definition = create_definition[];

export type create_definition = create_column_definition | create_index_definition | create_fulltext_spatial_index_definition | create_constraint_definition;

export type column_definition_opt = column_constraint | { auto_increment: 'auto_increment'; } | { unique: 'unique' | 'unique key'; } | { unique: 'key' | 'primary key'; } | { comment: keyword_comment; } | { collate: collate_expr; } | { column_format: column_format; } | { storage: storage } | { reference_definition: reference_definition; } | { check: check_constraint_definition; } | { character_set: { type: 'CHARACTER SET'; symbol: '=' | null; value: ident_without_kw_type; } };

export type column_definition_opt_list = {

};

export type create_column_definition_list = create_column_definition[];

export type create_column_definition = {

};

export type column_constraint = { constraint: constraint_name; } | { nullable: literal_null | literal_not_null; default_val: default_expr; };

export type collate_expr = { type: 'collate'; keyword: 'collate'; collate: { symbol: '=' ; name: ident_type; value: ident_type; }} | { type: 'collate'; keyword: 'collate'; collate: { symbol: '=' | null ; name: ident_type; }};

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

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

export type default_arg_expr = { type: 'default'; keyword: string, value: expr; };

export type default_expr = { type: 'default'; value: expr; };

export type drop_index_opt = (ALTER_ALGORITHM | ALTER_LOCK)[];

export interface drop_stmt_node {

}

export interface drop_index_stmt_node {

}

export type drop_stmt = AstStatement<drop_stmt_node> | AstStatement<drop_index_stmt_node>;

export type truncate_table_name = table_name & { suffix?: string };

export type truncate_table_name_list = truncate_table_name[];

export interface truncate_stmt_node {

}

export type truncate_stmt = AstStatement<truncate_stmt_node>;

export interface use_stmt_node {

type: 'use';

db: ident;

}

export type use_stmt = AstStatement<use_stmt_node>;

export type aggregate_signature = { name: "*" } | alter_func_args;

export type alter_func_argmode = "IN" | "OUT" | "VARIADIC";

export type alter_func_arg_item = { mode?: string; name?: string; type: data_type; default: default_arg_expr; };

export type alter_func_args = alter_func_arg_item[];

export type alter_aggregate_stmt = AstStatement<alter_resource_stmt_node>;

export type alter_function_stmt = AstStatement<alter_resource_stmt_node>;

export interface alter_resource_stmt_node {

}

export type alter_domain_type_stmt = AstStatement<alter_resource_stmt_node>;

export type alter_schema_stmt = AstStatement<alter_resource_stmt_node>;

export interface alter_table_stmt_node {

}

export type alter_table_stmt = AstStatement<alter_table_stmt_node>;

export type alter_action_list = alter_action[];

export type alter_action = ALTER_ADD_COLUMN | ALTER_ADD_CONSTRAINT | ALTER_DROP_COLUMN | ALTER_ADD_INDEX_OR_KEY | ALTER_ADD_FULLETXT_SPARITAL_INDEX | ALTER_RENAME | ALTER_ALGORITHM | ALTER_LOCK | ALTER_COLUMN_DATA_TYPE | ALTER_COLUMN_DEFAULT | ALTER_COLUMN_NOT_NULL;

export type ALTER_ADD_COLUMN = {

} & create_column_definition;;

export type ALTER_DROP_COLUMN = {

};

export type ALTER_ADD_CONSTRAINT = {

};

export type ALTER_ADD_INDEX_OR_KEY = {

action: 'add';

type: 'alter';

} & create_index_definition;

export interface alter_rename_owner {

}

export type ALTER_RENAME = AstStatement<alter_rename_owner>;

export type ALTER_OWNER_TO = AstStatement<alter_rename_owner>;

export type ALTER_SET_SCHEMA = AstStatement<alter_rename_owner>;

export type ALTER_ALGORITHM = {

};

export type ALTER_LOCK = {

};

export type ALTER_COLUMN_DATA_TYPE = {

} & create_column_definition;;

export type ALTER_COLUMN_DEFAULT = {

} & create_column_definition;;

export type ALTER_COLUMN_NOT_NULL = {

} & create_column_definition;;

export type create_index_definition = {

};

export type create_fulltext_spatial_index_definition = {

};

export type create_constraint_definition = create_constraint_primary | create_constraint_unique | create_constraint_foreign | create_constraint_check;

export type constraint_name = { keyword: 'constraint'; constraint: ident; };

export type create_constraint_check = {

};

export type create_constraint_primary = {

};

export type create_constraint_unique = {

};

export type create_constraint_foreign = {

};

export type check_constraint_definition = {

};

export type reference_definition = {

};

export type on_reference = { type: 'on delete' | 'on update'; value: reference_option; };

export type reference_option = { type: 'function'; name: string; args: expr_list; } | 'restrict' | 'cascade' | 'set null' | 'no action' | 'set default' | 'current_timestamp';

export type create_constraint_trigger = {

};

export type trigger_event = { keyword: 'insert' | 'delete' | 'truncate' } | { keyword: 'update'; args?: { keyword: 'of', columns: column_ref_list; }};

export type trigger_event_list = trigger_event[];;

export type trigger_deferrable = { keyword: 'deferrable' | 'not deferrable'; args: 'initially immediate' | 'initially deferred' };

export type trigger_for_row = { keyword: 'for' | 'for each'; args: 'row' | 'statement' };

export type trigger_when = { type: 'when'; cond: expr; parentheses: true; };

export type table_options = table_option[];

export type create_option_character_set_kw = string;

export type create_option_character_set = {

};

export type table_option = {

} | create_option_character_set | { keyword: 'connection' | 'comment'; symbol: '='; value: string; } | { keyword: 'compression'; symbol?: '='; value: "'ZLIB'" | "'LZ4'" | "'NONE'" } | { keyword: 'engine'; symbol?: '='; value: string; } | { keyword: 'partition by'; value: expr; };

export type ALTER_ADD_FULLETXT_SPARITAL_INDEX = create_fulltext_spatial_index_definition & { action: 'add'; type: 'alter' };

export interface rename_stmt_node {

type: 'rename';

table: table_to_list;

}

export type rename_stmt = AstStatement<rename_stmt_node>;

export interface set_stmt_node {

}

export type set_stmt = AstStatement<set_stmt_node>;

export type lock_mode = { mode: string; };

export interface lock_stmt_node {

}

export type lock_stmt = AstStatement<lock_stmt_node>;

export interface call_stmt_node {

type: 'call';

expr: proc_func_call;

}

export type call_stmt = AstStatement<call_stmt_node>;

export interface show_stmt_node {

}

export type show_stmt = AstStatement<show_stmt_node>;

export interface deallocate_stmt_node {

}

export type deallocate_stmt = AstStatement<deallocate_stmt_node>;

export interface origin_str_stmt {

type: 'origin';

value: string;

}

export type priv_type_table = origin_str_stmt;

export type priv_type_sequence = origin_str_stmt;

export type priv_type_database = origin_str_stmt;

export type prive_type_all = origin_str_stmt;

export type prive_type_usage = origin_str_stmt | prive_type_all;

export type prive_type_execute = origin_str_stmt | prive_type_all;

export type priv_type = priv_type_table | priv_type_sequence | priv_type_database | prive_type_usage | prive_type_execute;

export type priv_item = { priv: priv_type; columns: column_ref_list; };

export type priv_list = priv_item[];

export type object_type = origin_str_stmt;

export type priv_level = { prefix: string; name: string; };

export type priv_level_list = priv_level[];

export type user_or_role = origin_str_stmt;

export type user_or_role_list = user_or_role[];

export type with_grant_option = origin_str_stmt;

export type with_admin_option = origin_str_stmt;

export type grant_revoke_keyword = { type: 'grant' } | { type: 'revoke'; grant_option_for?: origin_str_stmt; };

export interface grant_revoke_stmt_t {

}

export type grant_revoke_stmt = AstStatement<grant_revoke_stmt_t>;

export type elseif_stmt = { type: 'elseif'; boolean_expr: expr; then: crud_stmt; semicolon?: string; };

export type elseif_stmt_list = elseif_stmt[];

export interface if_else_stmt_t {

}

export type if_else_stmt = AstStatement<if_else_stmt_t>;

export type raise_level = "DEBUG" | "LOG" | "INFO" | "NOTICE" | "WARNING" | "EXCEPTION";

export type raise_opt = { type: 'using'; option: string; symbol: '='; expr: expr[]; };

type raise_item = never;

export interface raise_stmt_t {

}

export type raise_stmt = AstStatement<raise_stmt_t>;

export interface execute_stmt_t {

}

export type execute_stmt = AstStatement<execute_stmt_t>;

export type for_label = { label?: string; keyword: 'for'; };

export interface for_loop_stmt_t {

}

export type for_loop_stmt = AstStatement<for_loop_stmt_t>;

export type transaction_mode_isolation_level = { type: 'origin'; value: string; } | ignore;

export type transaction_mode = { type: 'origin'; value: string; } | ignore;

export type transaction_mode_list = transaction_mode[];

export interface transaction_stmt_t {

}

export type transaction_stmt = AstStatement<transaction_stmt_t> | ignore;

export type comment_on_option = { type: string; name: table_name; } | { type: string; name: column_ref; } | { type: string; name: ident; };

export type comment_on_is = { keyword: 'is'; expr: literal_string | literal_null; };

export interface comment_on_stmt_t {

}

export type comment_on_stmt = AstStatement<comment_on_stmt_t>;

export interface select_stmt_node extends select_stmt_nake {

parentheses: true;

}

export type select_stmt_parentheses = select_stmt_node;

export type select_stmt = { type: 'select'; } | select_stmt_nake | select_stmt_parentheses;

export type with_clause = cte_definition[] | [cte_definition & { recursive: true; }];

export type cte_definition = { name: { type: 'default'; value: string; }; stmt: crud_stmt; columns?: cte_column_definition; };

export type cte_column_definition = column_ref_list;

export type distinct_on = {type: string; columns: column_list_items;} | { type: string | undefined; };

export type select_stmt_nake = {

};

export type option_clause = query_option[];

export type query_option = 'SQL_CALC_FOUND_ROWS'| 'SQL_CACHE'| 'SQL_NO_CACHE'| 'SQL_BIG_RESULT'| 'SQL_SMALL_RESULT'| 'SQL_BUFFER_RESULT';

export type column_list_items = column_list_item[];

export type column_clause = 'ALL' | '*' | column_list_item[] | column_list_items;

export type array_index = { brackets: boolean, number: number };

export type array_index_list = array_index[];

export type expr_item = binary_column_expr & { array_index: array_index };

export type cast_data_type = data_type & { quoted?: string };

export type column_item_suffix = [{ type: 'origin'; value: string; }, quoted_ident_type | column_ref];

export type column_list_item = { expr: expr; as: null; } | { type: 'cast'; expr: expr; symbol: '::'; target: cast_data_type; as?: null; } | { expr: column_ref; as: null; } | { type: 'expr'; expr: expr; as?: alias_clause; };

export type value_alias_clause = alias_ident;