anon/sqlfun
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Pass parser state ptr to each parser executor callback.

Browse Source
This commit is contained in:
Jeff Garzik
2016-07-28 18:34:21 -04:00
parent ea2ca5f51b
commit 32043a11c3
5 changed files with 346 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -35,4 +35,6 @@ clean:
.SUFFIXES: .l .y .c
exec.o: exec.c sql-parser.h
sql.o: sql-parser.h
sql.tab.o: sql-parser.h

4
README
View File

@ -4,3 +4,7 @@ An SQL parser, generated from Bison (Yacc) and Flex (Lex).
Original version - most of the work - comes from John Levine's
Flex & Bison book published by O'Reilley.
Example usage:
$ echo "SELECT a.name,b.address FROM people ORDER BY name;" | ./sql

156
exec.c
View File

@ -56,12 +56,12 @@ static const char *interval_names[] = {
[SDI_HOUR_SECOND] = "SDI_HOUR_SECOND",
};
void sqlp_alias(const char *alias)
void sqlp_alias(struct psql_state *pstate, const char *alias)
{
printf("exec ALIAS %s\n", alias);
}
void sqlp_assign(const char *db_name, const char *name)
void sqlp_assign(struct psql_state *pstate, const char *db_name, const char *name)
{
printf("exec ASSIGN %s%s%s\n",
db_name ? db_name : "",
@ -69,119 +69,119 @@ void sqlp_assign(const char *db_name, const char *name)
name);
}
void sqlp_assign_at(const char *name)
void sqlp_assign_at(struct psql_state *pstate, const char *name)
{
printf("exec ASSIGN-AT %s\n", name);
}
void sqlp_bool(int val)
void sqlp_bool(struct psql_state *pstate, int val)
{
printf("exec BOOL %d\n", val);
}
void sqlp_call(int n_args, const char *name)
void sqlp_call(struct psql_state *pstate, int n_args, const char *name)
{
printf("exec CALL %d %s\n", n_args, name);
}
void sqlp_call_date(int n_args, enum sqlp_expr_ops op)
void sqlp_call_date(struct psql_state *pstate, int n_args, enum sqlp_expr_ops op)
{
printf("exec CALL %d DATE %s\n",
n_args,
op == SEO_ADD ? "ADD" : "SUB");
}
void sqlp_call_trim_opts(int trim_opts)
void sqlp_call_trim_opts(struct psql_state *pstate, int trim_opts)
{
printf("exec CALL TRIM OPTS %d\n", trim_opts);
}
void sqlp_case(int n_list, int have_else)
void sqlp_case(struct psql_state *pstate, int n_list, int have_else)
{
printf("exec CASE %d %d\n", n_list, have_else);
}
void sqlp_caseval(int n_list, int have_else)
void sqlp_caseval(struct psql_state *pstate, int n_list, int have_else)
{
printf("exec CASEVAL %d %d\n", n_list, have_else);
}
void sqlp_col_attr(enum sqlp_col_attribs attr)
void sqlp_col_attr(struct psql_state *pstate, enum sqlp_col_attribs attr)
{
printf("exec ATTR %s\n", attr_names[attr]);
}
void sqlp_col_attr_uniq(int n_cols)
void sqlp_col_attr_uniq(struct psql_state *pstate, int n_cols)
{
printf("exec ATTR UNIQUE-KEY %d\n", n_cols);
}
void sqlp_col_attr_comm(const char *comm)
void sqlp_col_attr_comm(struct psql_state *pstate, const char *comm)
{
printf("exec ATTR COMMENT %s\n", comm);
}
void sqlp_col_charset(const char *charset)
void sqlp_col_charset(struct psql_state *pstate, const char *charset)
{
printf("exec ATTR CHARSET %s\n", charset);
}
void sqlp_col_collate(const char *collate)
void sqlp_col_collate(struct psql_state *pstate, const char *collate)
{
printf("exec ATTR COLLATE %s\n", collate);
}
void sqlp_col_def_str(const char *str)
void sqlp_col_def_str(struct psql_state *pstate, const char *str)
{
printf("exec ATTR DEFAULT-STR %s\n", str);
}
void sqlp_col_def_num(int num)
void sqlp_col_def_num(struct psql_state *pstate, int num)
{
printf("exec ATTR DEFAULT-NUM %d\n", num);
}
void sqlp_col_def_float(float num)
void sqlp_col_def_float(struct psql_state *pstate, float num)
{
printf("exec ATTR DEFAULT-FLOAT %g\n", num);
}
void sqlp_col_def_bool(int bool)
void sqlp_col_def_bool(struct psql_state *pstate, int bool)
{
printf("exec ATTR DEFAULT-BOOL %d\n", bool);
}
void sqlp_col_key_pri(int n_cols)
void sqlp_col_key_pri(struct psql_state *pstate, int n_cols)
{
printf("exec KEY-PRI %d\n", n_cols);
}
void sqlp_col_key(int n_cols)
void sqlp_col_key(struct psql_state *pstate, int n_cols)
{
printf("exec KEY %d\n", n_cols);
}
void sqlp_col_key_textidx(int n_cols)
void sqlp_col_key_textidx(struct psql_state *pstate, int n_cols)
{
printf("exec KEY-TEXTIDX %d\n", n_cols);
}
void sqlp_column(const char *name)
void sqlp_column(struct psql_state *pstate, const char *name)
{
printf("exec COLUMN %s\n", name);
}
void sqlp_create_db(int if_ne, const char *name)
void sqlp_create_db(struct psql_state *pstate, int if_ne, const char *name)
{
printf("exec CREATE-DB %d %s\n", if_ne, name);
}
void sqlp_create_sel(int ignore_replace)
void sqlp_create_sel(struct psql_state *pstate, int ignore_replace)
{
printf("exec CREATE-SELECT %d\n", ignore_replace);
}
void sqlp_create_tbl(int temp, int if_n_exists, int n_cols,
void sqlp_create_tbl(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
const char *db_name, const char *name)
{
printf("exec CREATE-TABLE %d %d %d %s%s%s\n",
@ -191,7 +191,7 @@ void sqlp_create_tbl(int temp, int if_n_exists, int n_cols,
name);
}
void sqlp_create_tbl_sel(int temp, int if_n_exists, int n_cols,
void sqlp_create_tbl_sel(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
const char *db_name, const char *name)
{
printf("exec CREATE-TABLE-SELECT %d %d %d %s%s%s\n",
@ -201,237 +201,237 @@ void sqlp_create_tbl_sel(int temp, int if_n_exists, int n_cols,
name);
}
void sqlp_date_interval(enum sqlp_date_intervals interval)
void sqlp_date_interval(struct psql_state *pstate, enum sqlp_date_intervals interval)
{
printf("exec DATE-INTERVAL %s\n", interval_names[interval]);
}
void sqlp_def_col(int flags, const char *name)
void sqlp_def_col(struct psql_state *pstate, int flags, const char *name)
{
printf("exec DEFINE-COL %d %s\n", flags, name);
}
void sqlp_delete(int opts, const char *name)
void sqlp_delete(struct psql_state *pstate, int opts, const char *name)
{
printf("exec DELETE %d %s\n", opts, name);
}
void sqlp_delete_multi(int opts, int n_del, int n_tbl_ref)
void sqlp_delete_multi(struct psql_state *pstate, int opts, int n_del, int n_tbl_ref)
{
printf("exec DELETE-MULTI %d %d %d\n", opts, n_del, n_tbl_ref);
}
void sqlp_drop_db(int if_exists, const char *name)
void sqlp_drop_db(struct psql_state *pstate, int if_exists, const char *name)
{
printf("exec DROP-DB %d %s\n", if_exists, name);
}
void sqlp_drop_table(int temp, int if_exists, int n_tables)
void sqlp_drop_table(struct psql_state *pstate, int temp, int if_exists, int n_tables)
{
printf("exec DROP-TABLE %d %d %d\n", temp, if_exists, n_tables);
}
void sqlp_enum_val(const char *val)
void sqlp_enum_val(struct psql_state *pstate, const char *val)
{
printf("exec ENUM-VAL %s\n", val);
}
void sqlp_expr_cmp(int comp)
void sqlp_expr_cmp(struct psql_state *pstate, int comp)
{
printf("exec CMP %d\n", comp);
}
void sqlp_expr_is_bool(int val)
void sqlp_expr_is_bool(struct psql_state *pstate, int val)
{
printf("exec EXPR-IS-BOOL %d\n", val);
}
void sqlp_expr_is_in(int val)
void sqlp_expr_is_in(struct psql_state *pstate, int val)
{
printf("exec EXPR-IS-IN %d\n", val);
}
void sqlp_expr_op(enum sqlp_expr_ops op)
void sqlp_expr_op(struct psql_state *pstate, enum sqlp_expr_ops op)
{
printf("exec EXPR-OP %s\n", op_names[op]);
}
void sqlp_expr_cmp_sel(int sel_type, int comp)
void sqlp_expr_cmp_sel(struct psql_state *pstate, int sel_type, int comp)
{
printf("exec CMP-SELECT %d %d\n", sel_type, comp);
}
void sqlp_fieldname(const char *db_name, const char *name)
void sqlp_fieldname(struct psql_state *pstate, const char *db_name, const char *name)
{
printf("exec FIELD-NAME %s.%s\n", db_name, name);
}
void sqlp_float(float val)
void sqlp_float(struct psql_state *pstate, float val)
{
printf("exec FLOAT %g\n", val);
}
void sqlp_group_by_list(int n_list, int opts)
void sqlp_group_by_list(struct psql_state *pstate, int n_list, int opts)
{
printf("exec GROUPBY-LIST %d %d\n", n_list, opts);
}
void sqlp_group_by(int opts)
void sqlp_group_by(struct psql_state *pstate, int opts)
{
printf("exec GROUPBY %d\n", opts);
}
void sqlp_having(void)
void sqlp_having(struct psql_state *pstate)
{
printf("exec HAVING\n");
}
void sqlp_index(const char *name)
void sqlp_index(struct psql_state *pstate, const char *name)
{
printf("exec INDEX %s\n", name);
}
void sqlp_index_hint(int n_indexed, int opts)
void sqlp_index_hint(struct psql_state *pstate, int n_indexed, int opts)
{
printf("exec INDEX-HINT %d %d\n", n_indexed, opts);
}
void sqlp_ins_cols(int n_cols)
void sqlp_ins_cols(struct psql_state *pstate, int n_cols)
{
printf("exec INSERT-COLS %d\n", n_cols);
}
void sqlp_ins_default(void)
void sqlp_ins_default(struct psql_state *pstate)
{
printf("exec INSERT-DEFAULT\n");
}
void sqlp_ins_dup_update(int n_assn)
void sqlp_ins_dup_update(struct psql_state *pstate, int n_assn)
{
printf("exec INSERT DUP-ONUPDATE %d\n", n_assn);
}
void sqlp_insert(int opts, int n_vals, const char *tbl_name)
void sqlp_insert(struct psql_state *pstate, int opts, int n_vals, const char *tbl_name)
{
printf("exec INSERT %d %d %s\n", opts, n_vals, tbl_name);
}
void sqlp_insert_assn(int opts, int n_assn, const char *tbl_name)
void sqlp_insert_assn(struct psql_state *pstate, int opts, int n_assn, const char *tbl_name)
{
printf("exec INSERT-ASSN %d %d %s\n", opts, n_assn, tbl_name);
}
void sqlp_insert_sel(int opts, const char *tbl_name)
void sqlp_insert_sel(struct psql_state *pstate, int opts, const char *tbl_name)
{
printf("exec INSERT-SEL %d %s\n", opts, tbl_name);
}
void sqlp_into(int n_cols)
void sqlp_into(struct psql_state *pstate, int n_cols)
{
printf("exec INTO %d\n", n_cols);
}
void sqlp_join(int opts)
void sqlp_join(struct psql_state *pstate, int opts)
{
printf("exec JOIN %d\n", opts);
}
void sqlp_join_expr(void)
void sqlp_join_expr(struct psql_state *pstate)
{
printf("exec JOIN-ON EXPR\n");
}
void sqlp_join_using(int n_cols)
void sqlp_join_using(struct psql_state *pstate, int n_cols)
{
printf("exec JOIN-USING %d\n", n_cols);
}
void sqlp_limit(int two_expr)
void sqlp_limit(struct psql_state *pstate, int two_expr)
{
printf("exec LIMIT %d\n", two_expr);
}
void sqlp_name(const char *name)
void sqlp_name(struct psql_state *pstate, const char *name)
{
printf("exec NAME %s\n", name);
}
void sqlp_now(void)
void sqlp_now(struct psql_state *pstate)
{
printf("exec NOW\n");
}
void sqlp_number(int val)
void sqlp_number(struct psql_state *pstate, int val)
{
printf("exec INT/NUMBER %d\n", val);
}
void sqlp_order_by(int n_list)
void sqlp_order_by(struct psql_state *pstate, int n_list)
{
printf("exec ORDER-BY %d\n", n_list);
}
void sqlp_replace_assn(int opts, int n_assn, const char *name)
void sqlp_replace_assn(struct psql_state *pstate, int opts, int n_assn, const char *name)
{
printf("exec REPLACE-ASSN %d %d %s\n", opts, n_assn, name);
}
void sqlp_replace_vals(int opts, int n_vals, const char *name)
void sqlp_replace_vals(struct psql_state *pstate, int opts, int n_vals, const char *name)
{
printf("exec REPLACE-VALS %d %d %s\n", opts, n_vals, name);
}
void sqlp_replace_sel(int opts, const char *name)
void sqlp_replace_sel(struct psql_state *pstate, int opts, const char *name)
{
printf("exec REPLACE-SEL %d %s\n", opts, name);
}
void sqlp_select(int opts, int n_expr, int n_tbl_ref)
void sqlp_select(struct psql_state *pstate, int opts, int n_expr, int n_tbl_ref)
{
printf("exec SELECT %d %d %d\n", opts, n_expr, n_tbl_ref);
}
void sqlp_select_nodata(int opts, int n_expr)
void sqlp_select_nodata(struct psql_state *pstate, int opts, int n_expr)
{
printf("exec SELECT-NODATA %d %d\n", opts, n_expr);
}
void sqlp_select_all(void)
void sqlp_select_all(struct psql_state *pstate)
{
printf("exec SELECT-ALL\n");
}
void sqlp_set(const char *name)
void sqlp_set(struct psql_state *pstate, const char *name)
{
printf("exec SET %s\n", name);
}
void sqlp_start_col(void)
void sqlp_start_col(struct psql_state *pstate)
{
printf("exec START-COL\n");
}
void sqlp_stmt(void)
void sqlp_stmt(struct psql_state *pstate)
{
printf("exec STMT\n");
}
void sqlp_string(const char *str)
void sqlp_string(struct psql_state *pstate, const char *str)
{
printf("exec STRING %s\n", str);
}
void sqlp_subquery(void)
void sqlp_subquery(struct psql_state *pstate)
{
printf("exec SUBQUERY\n");
}
void sqlp_subquery_as(const char *name)
void sqlp_subquery_as(struct psql_state *pstate, const char *name)
{
printf("exec SUBQUERY-AS %s\n", name);
}
void sqlp_table(const char *db_name, const char *name)
void sqlp_table(struct psql_state *pstate, const char *db_name, const char *name)
{
printf("exec TABLE %s%s%s\n",
db_name ? db_name : "",
@ -439,27 +439,27 @@ void sqlp_table(const char *db_name, const char *name)
name);
}
void sqlp_table_refs(int n_refs)
void sqlp_table_refs(struct psql_state *pstate, int n_refs)
{
printf("exec TABLE-REFERENCES %d\n", n_refs);
}
void sqlp_update(int opts, int n_tbl_ref, int n_assn)
void sqlp_update(struct psql_state *pstate, int opts, int n_tbl_ref, int n_assn)
{
printf("exec UPDATE %d %d %d\n", opts, n_tbl_ref, n_assn);
}
void sqlp_uservar(const char *str)
void sqlp_uservar(struct psql_state *pstate, const char *str)
{
printf("exec USER-VAR %s\n", str);
}
void sqlp_values(int n_vals)
void sqlp_values(struct psql_state *pstate, int n_vals)
{
printf("exec VALUES %d\n", n_vals);
}
void sqlp_where(void)
void sqlp_where(struct psql_state *pstate)
{
printf("exec WHERE\n");
}

156
sql-parser.h
View File

@ -56,85 +56,85 @@ struct psql_state {
yyscan_t scanner;
};
extern void sqlp_alias(const char *alias);
extern void sqlp_assign(const char *db_name, const char *name);
extern void sqlp_assign_at(const char *name);
extern void sqlp_bool(int val);
extern void sqlp_call(int n_args, const char *name);
extern void sqlp_call_date(int n_args, enum sqlp_expr_ops op);
extern void sqlp_call_trim_opts(int trim_opts);
extern void sqlp_case(int n_list, int have_else);
extern void sqlp_caseval(int n_list, int have_else);
extern void sqlp_col_attr(enum sqlp_col_attribs attr);
extern void sqlp_col_attr_uniq(int n_cols);
extern void sqlp_col_attr_comm(const char *comm);
extern void sqlp_col_charset(const char *charset);
extern void sqlp_col_collate(const char *collate);
extern void sqlp_col_def_str(const char *str);
extern void sqlp_col_def_num(int num);
extern void sqlp_col_def_float(float num);
extern void sqlp_col_def_bool(int bool);
extern void sqlp_col_key_pri(int n_cols);
extern void sqlp_col_key(int n_cols);
extern void sqlp_col_key_textidx(int n_cols);
extern void sqlp_column(const char *name);
extern void sqlp_create_db(int if_n_exists, const char *name);
extern void sqlp_create_tbl(int temp, int if_n_exists, int n_cols,
extern void sqlp_alias(struct psql_state *pstate, const char *alias);
extern void sqlp_assign(struct psql_state *pstate, const char *db_name, const char *name);
extern void sqlp_assign_at(struct psql_state *pstate, const char *name);
extern void sqlp_bool(struct psql_state *pstate, int val);
extern void sqlp_call(struct psql_state *pstate, int n_args, const char *name);
extern void sqlp_call_date(struct psql_state *pstate, int n_args, enum sqlp_expr_ops op);
extern void sqlp_call_trim_opts(struct psql_state *pstate, int trim_opts);
extern void sqlp_case(struct psql_state *pstate, int n_list, int have_else);
extern void sqlp_caseval(struct psql_state *pstate, int n_list, int have_else);
extern void sqlp_col_attr(struct psql_state *pstate, enum sqlp_col_attribs attr);
extern void sqlp_col_attr_uniq(struct psql_state *pstate, int n_cols);
extern void sqlp_col_attr_comm(struct psql_state *pstate, const char *comm);
extern void sqlp_col_charset(struct psql_state *pstate, const char *charset);
extern void sqlp_col_collate(struct psql_state *pstate, const char *collate);
extern void sqlp_col_def_str(struct psql_state *pstate, const char *str);
extern void sqlp_col_def_num(struct psql_state *pstate, int num);
extern void sqlp_col_def_float(struct psql_state *pstate, float num);
extern void sqlp_col_def_bool(struct psql_state *pstate, int bool);
extern void sqlp_col_key_pri(struct psql_state *pstate, int n_cols);
extern void sqlp_col_key(struct psql_state *pstate, int n_cols);
extern void sqlp_col_key_textidx(struct psql_state *pstate, int n_cols);
extern void sqlp_column(struct psql_state *pstate, const char *name);
extern void sqlp_create_db(struct psql_state *pstate, int if_n_exists, const char *name);
extern void sqlp_create_tbl(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
const char *db_name, const char *name);
extern void sqlp_create_tbl_sel(int temp, int if_n_exists, int n_cols,
extern void sqlp_create_tbl_sel(struct psql_state *pstate, int temp, int if_n_exists, int n_cols,
const char *db_name, const char *name);
extern void sqlp_create_sel(int ignore_replace);
extern void sqlp_date_interval(enum sqlp_date_intervals interval);
extern void sqlp_def_col(int flags, const char *name);
extern void sqlp_delete(int opts, const char *name);
extern void sqlp_delete_multi(int opts, int n_del, int n_tbl_ref);
extern void sqlp_drop_db(int if_exists, const char *name);
extern void sqlp_drop_table(int temp, int if_exists, int n_tables);
extern void sqlp_enum_val(const char *val);
extern void sqlp_expr_op(enum sqlp_expr_ops op);
extern void sqlp_expr_cmp(int comp);
extern void sqlp_expr_cmp_sel(int sel_type, int comp);
extern void sqlp_expr_is_bool(int val);
extern void sqlp_expr_is_in(int val);
extern void sqlp_fieldname(const char *db_name, const char *name);
extern void sqlp_float(float val);
extern void sqlp_group_by_list(int n_list, int opts);
extern void sqlp_group_by(int opts);
extern void sqlp_having(void);
extern void sqlp_index(const char *name);
extern void sqlp_index_hint(int n_indexed, int opts);
extern void sqlp_ins_cols(int n_cols);
extern void sqlp_ins_default(void);
extern void sqlp_ins_dup_update(int n_assn);
extern void sqlp_insert(int opts, int n_vals, const char *tbl_name);
extern void sqlp_insert_assn(int opts, int n_assn, const char *tbl_name);
extern void sqlp_insert_sel(int opts, const char *tbl_name);
extern void sqlp_into(int n_cols);
extern void sqlp_join(int opts);
extern void sqlp_join_expr(void);
extern void sqlp_join_using(int n_cols);
extern void sqlp_limit(int two_expr);
extern void sqlp_name(const char *name);
extern void sqlp_now(void);
extern void sqlp_number(int val);
extern void sqlp_order_by(int n_list);
extern void sqlp_replace_assn(int opts, int n_assn, const char *name);
extern void sqlp_replace_vals(int opts, int n_vals, const char *name);
extern void sqlp_replace_sel(int opts, const char *name);
extern void sqlp_select(int opts, int n_expr, int n_tbl_ref);
extern void sqlp_select_nodata(int opts, int n_expr);
extern void sqlp_select_all(void);
extern void sqlp_set(const char *name);
extern void sqlp_start_col(void);
extern void sqlp_string(const char *str);
extern void sqlp_stmt(void);
extern void sqlp_subquery(void);
extern void sqlp_subquery_as(const char *name);
extern void sqlp_table(const char *db_name, const char *name);
extern void sqlp_table_refs(int n_refs);
extern void sqlp_update(int opts, int n_tbl_ref, int n_assn);
extern void sqlp_uservar(const char *str);
extern void sqlp_values(int n_vals);
extern void sqlp_where(void);
extern void sqlp_create_sel(struct psql_state *pstate, int ignore_replace);
extern void sqlp_date_interval(struct psql_state *pstate, enum sqlp_date_intervals interval);
extern void sqlp_def_col(struct psql_state *pstate, int flags, const char *name);
extern void sqlp_delete(struct psql_state *pstate, int opts, const char *name);
extern void sqlp_delete_multi(struct psql_state *pstate, int opts, int n_del, int n_tbl_ref);
extern void sqlp_drop_db(struct psql_state *pstate, int if_exists, const char *name);
extern void sqlp_drop_table(struct psql_state *pstate, int temp, int if_exists, int n_tables);
extern void sqlp_enum_val(struct psql_state *pstate, const char *val);
extern void sqlp_expr_op(struct psql_state *pstate, enum sqlp_expr_ops op);
extern void sqlp_expr_cmp(struct psql_state *pstate, int comp);
extern void sqlp_expr_cmp_sel(struct psql_state *pstate, int sel_type, int comp);
extern void sqlp_expr_is_bool(struct psql_state *pstate, int val);
extern void sqlp_expr_is_in(struct psql_state *pstate, int val);
extern void sqlp_fieldname(struct psql_state *pstate, const char *db_name, const char *name);
extern void sqlp_float(struct psql_state *pstate, float val);
extern void sqlp_group_by_list(struct psql_state *pstate, int n_list, int opts);
extern void sqlp_group_by(struct psql_state *pstate, int opts);
extern void sqlp_having(struct psql_state *pstate);
extern void sqlp_index(struct psql_state *pstate, const char *name);
extern void sqlp_index_hint(struct psql_state *pstate, int n_indexed, int opts);
extern void sqlp_ins_cols(struct psql_state *pstate, int n_cols);
extern void sqlp_ins_default(struct psql_state *pstate);
extern void sqlp_ins_dup_update(struct psql_state *pstate, int n_assn);
extern void sqlp_insert(struct psql_state *pstate, int opts, int n_vals, const char *tbl_name);
extern void sqlp_insert_assn(struct psql_state *pstate, int opts, int n_assn, const char *tbl_name);
extern void sqlp_insert_sel(struct psql_state *pstate, int opts, const char *tbl_name);
extern void sqlp_into(struct psql_state *pstate, int n_cols);
extern void sqlp_join(struct psql_state *pstate, int opts);
extern void sqlp_join_expr(struct psql_state *pstate);
extern void sqlp_join_using(struct psql_state *pstate, int n_cols);
extern void sqlp_limit(struct psql_state *pstate, int two_expr);
extern void sqlp_name(struct psql_state *pstate, const char *name);
extern void sqlp_now(struct psql_state *pstate);
extern void sqlp_number(struct psql_state *pstate, int val);
extern void sqlp_order_by(struct psql_state *pstate, int n_list);
extern void sqlp_replace_assn(struct psql_state *pstate, int opts, int n_assn, const char *name);
extern void sqlp_replace_vals(struct psql_state *pstate, int opts, int n_vals, const char *name);
extern void sqlp_replace_sel(struct psql_state *pstate, int opts, const char *name);
extern void sqlp_select(struct psql_state *pstate, int opts, int n_expr, int n_tbl_ref);
extern void sqlp_select_nodata(struct psql_state *pstate, int opts, int n_expr);
extern void sqlp_select_all(struct psql_state *pstate);
extern void sqlp_set(struct psql_state *pstate, const char *name);
extern void sqlp_start_col(struct psql_state *pstate);
extern void sqlp_string(struct psql_state *pstate, const char *str);
extern void sqlp_stmt(struct psql_state *pstate);
extern void sqlp_subquery(struct psql_state *pstate);
extern void sqlp_subquery_as(struct psql_state *pstate, const char *name);
extern void sqlp_table(struct psql_state *pstate, const char *db_name, const char *name);
extern void sqlp_table_refs(struct psql_state *pstate, int n_refs);
extern void sqlp_update(struct psql_state *pstate, int opts, int n_tbl_ref, int n_assn);
extern void sqlp_uservar(struct psql_state *pstate, const char *str);
extern void sqlp_values(struct psql_state *pstate, int n_vals);
extern void sqlp_where(struct psql_state *pstate);
#endif /* __SQL_PARSER_H__ */

368
sql.y
View File

@ -369,29 +369,29 @@ stmt_list: error ';'
/* statements: select statement */
stmt: select_stmt { sqlp_stmt(); }
stmt: select_stmt { sqlp_stmt(pstate); }
;
select_stmt: SELECT select_opts select_expr_list
{ sqlp_select_nodata($2, $3); } ;
{ sqlp_select_nodata(pstate, $2, $3); } ;
| SELECT select_opts select_expr_list
FROM table_references
opt_where opt_groupby opt_having opt_orderby opt_limit
opt_into_list { sqlp_select($2, $3, $5); } ;
opt_into_list { sqlp_select(pstate, $2, $3, $5); } ;
;
opt_where: /* nil */
| WHERE expr { sqlp_where(); };
| WHERE expr { sqlp_where(pstate); };
opt_groupby: /* nil */
| GROUP BY groupby_list opt_with_rollup
{ sqlp_group_by_list($3, $4); }
{ sqlp_group_by_list(pstate, $3, $4); }
;
groupby_list: expr opt_asc_desc
{ sqlp_group_by($2); $$ = 1; }
{ sqlp_group_by(pstate, $2); $$ = 1; }
| groupby_list ',' expr opt_asc_desc
{ sqlp_group_by($4); $$ = $1 + 1; }
{ sqlp_group_by(pstate, $4); $$ = $1 + 1; }
;
opt_asc_desc: /* nil */ { $$ = 0; }
@ -403,25 +403,25 @@ opt_with_rollup: /* nil */ { $$ = 0; }
| WITH ROLLUP { $$ = 1; }
;
opt_having: /* nil */ | HAVING expr { sqlp_having(); };
opt_having: /* nil */ | HAVING expr { sqlp_having(pstate); };
opt_orderby: /* nil */ | ORDER BY groupby_list { sqlp_order_by($3); }
opt_orderby: /* nil */ | ORDER BY groupby_list { sqlp_order_by(pstate, $3); }
;
opt_limit: /* nil */ | LIMIT expr { sqlp_limit(0); }
| LIMIT expr ',' expr { sqlp_limit(1); }
opt_limit: /* nil */ | LIMIT expr { sqlp_limit(pstate, 0); }
| LIMIT expr ',' expr { sqlp_limit(pstate, 1); }
;
opt_into_list: /* nil */
| INTO column_list { sqlp_into($2); }
| INTO column_list { sqlp_into(pstate, $2); }
;
column_list: NAME { sqlp_column($1); free($1); $$ = 1; }
column_list: NAME { sqlp_column(pstate, $1); free($1); $$ = 1; }
| STRING { lyyerror(@1, "string %s found where name required", $1);
sqlp_column($1); free($1); $$ = 1; }
| column_list ',' NAME { sqlp_column($3); free($3); $$ = $1 + 1; }
sqlp_column(pstate, $1); free($1); $$ = 1; }
| column_list ',' NAME { sqlp_column(pstate, $3); free($3); $$ = $1 + 1; }
| column_list ',' STRING { lyyerror(@3, "string %s found where name required", $1);
sqlp_column($3); free($3); $$ = $1 + 1; }
sqlp_column(pstate, $3); free($3); $$ = $1 + 1; }
;
select_opts: { $$ = 0; }
@ -437,7 +437,7 @@ select_opts: { $$ = 0; }
select_expr_list: select_expr { $$ = 1; }
| select_expr_list ',' select_expr {$$ = $1 + 1; }
| '*' { sqlp_select_all(); $$ = 1; }
| '*' { sqlp_select_all(pstate); $$ = 1; }
;
select_expr: expr opt_as_alias ;
@ -451,33 +451,33 @@ table_reference: table_factor
;
table_factor:
NAME opt_as_alias index_hint { sqlp_table(NULL, $1); free($1); }
| NAME '.' NAME opt_as_alias index_hint { sqlp_table($1, $3);
NAME opt_as_alias index_hint { sqlp_table(pstate, NULL, $1); free($1); }
| NAME '.' NAME opt_as_alias index_hint { sqlp_table(pstate, $1, $3);
free($1); free($3); }
| table_subquery opt_as NAME { sqlp_subquery_as($3); free($3); }
| '(' table_references ')' { sqlp_table_refs($2); }
| table_subquery opt_as NAME { sqlp_subquery_as(pstate, $3); free($3); }
| '(' table_references ')' { sqlp_table_refs(pstate, $2); }
;
opt_as: AS
| /* nil */
;
opt_as_alias: AS NAME { sqlp_alias($2); free($2); }
| NAME { sqlp_alias($1); free($1); }
opt_as_alias: AS NAME { sqlp_alias(pstate, $2); free($2); }
| NAME { sqlp_alias(pstate, $1); free($1); }
| /* nil */
;
join_table:
table_reference opt_inner_cross JOIN table_factor opt_join_condition
{ sqlp_join(0100+$2); }
{ sqlp_join(pstate, 0100+$2); }
| table_reference STRAIGHT_JOIN table_factor
{ sqlp_join(0200); }
{ sqlp_join(pstate, 0200); }
| table_reference STRAIGHT_JOIN table_factor ON expr
{ sqlp_join(0200); }
{ sqlp_join(pstate, 0200); }
| table_reference left_or_right opt_outer JOIN table_factor join_condition
{ sqlp_join(0300+$2+$3); }
{ sqlp_join(pstate, 0300+$2+$3); }
| table_reference NATURAL opt_left_or_right_outer JOIN table_factor
{ sqlp_join(0400+$3); }
{ sqlp_join(pstate, 0400+$3); }
;
opt_inner_cross: /* nil */ { $$ = 0; }
@ -501,17 +501,17 @@ opt_left_or_right_outer: LEFT opt_outer { $$ = 1 + $2; }
opt_join_condition: join_condition | /* nil */ ;
join_condition:
ON expr { sqlp_join_expr(); }
| USING '(' column_list ')' { sqlp_join_using($3); }
ON expr { sqlp_join_expr(pstate); }
| USING '(' column_list ')' { sqlp_join_using(pstate, $3); }
;
index_hint:
USE KEY opt_for_join '(' index_list ')'
{ sqlp_index_hint($5, 010+$3); }
{ sqlp_index_hint(pstate, $5, 010+$3); }
| IGNORE KEY opt_for_join '(' index_list ')'
{ sqlp_index_hint($5, 020+$3); }
{ sqlp_index_hint(pstate, $5, 020+$3); }
| FORCE KEY opt_for_join '(' index_list ')'
{ sqlp_index_hint($5, 030+$3); }
{ sqlp_index_hint(pstate, $5, 030+$3); }
| /* nil */
;
@ -519,21 +519,21 @@ opt_for_join: FOR JOIN { $$ = 1; }
| /* nil */ { $$ = 0; }
;
index_list: NAME { sqlp_index($1); free($1); $$ = 1; }
| index_list ',' NAME { sqlp_index($3); free($3); $$ = $1 + 1; }
index_list: NAME { sqlp_index(pstate, $1); free($1); $$ = 1; }
| index_list ',' NAME { sqlp_index(pstate, $3); free($3); $$ = $1 + 1; }
;
table_subquery: '(' select_stmt ')' { sqlp_subquery(); }
table_subquery: '(' select_stmt ')' { sqlp_subquery(pstate); }
;
/* statements: delete statement */
stmt: delete_stmt { sqlp_stmt(); }
stmt: delete_stmt { sqlp_stmt(pstate); }
;
delete_stmt: DELETE delete_opts FROM NAME
opt_where opt_orderby opt_limit
{ sqlp_delete($2, $4); free($4); }
{ sqlp_delete(pstate, $2, $4); free($4); }
;
delete_opts: delete_opts LOW_PRIORITY { $$ = $1 + 01; }
@ -545,11 +545,11 @@ delete_opts: delete_opts LOW_PRIORITY { $$ = $1 + 01; }
delete_stmt: DELETE delete_opts
delete_list
FROM table_references opt_where
{ sqlp_delete_multi($2, $3, $5); }
{ sqlp_delete_multi(pstate, $2, $3, $5); }
delete_list: NAME opt_dot_star { sqlp_table(NULL, $1); free($1); $$ = 1; }
delete_list: NAME opt_dot_star { sqlp_table(pstate, NULL, $1); free($1); $$ = 1; }
| delete_list ',' NAME opt_dot_star
{ sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
{ sqlp_table(pstate, NULL, $3); free($3); $$ = $1 + 1; }
;
opt_dot_star: /* nil */ | '.' '*' ;
@ -557,22 +557,22 @@ opt_dot_star: /* nil */ | '.' '*' ;
delete_stmt: DELETE delete_opts
FROM delete_list
USING table_references opt_where
{ sqlp_delete_multi($2, $4, $6); }
{ sqlp_delete_multi(pstate, $2, $4, $6); }
;
/* statements: insert statement */
stmt: insert_stmt { sqlp_stmt(); }
stmt: insert_stmt { sqlp_stmt(pstate); }
;
insert_stmt: INSERT insert_opts opt_into NAME
opt_col_names
VALUES insert_vals_list
opt_ondupupdate { sqlp_insert($2, $7, $4); free($4); }
opt_ondupupdate { sqlp_insert(pstate, $2, $7, $4); free($4); }
;
opt_ondupupdate: /* nil */
| ONDUPLICATE KEY UPDATE insert_asgn_list { sqlp_ins_dup_update($4); }
| ONDUPLICATE KEY UPDATE insert_asgn_list { sqlp_ins_dup_update(pstate, $4); }
;
insert_opts: /* nil */ { $$ = 0; }
@ -586,75 +586,75 @@ opt_into: INTO | /* nil */
;
opt_col_names: /* nil */
| '(' column_list ')' { sqlp_ins_cols($2); }
| '(' column_list ')' { sqlp_ins_cols(pstate, $2); }
;
insert_vals_list: '(' insert_vals ')' { sqlp_values($2); $$ = 1; }
| insert_vals_list ',' '(' insert_vals ')' { sqlp_values($4); $$ = $1 + 1; }
insert_vals_list: '(' insert_vals ')' { sqlp_values(pstate, $2); $$ = 1; }
| insert_vals_list ',' '(' insert_vals ')' { sqlp_values(pstate, $4); $$ = $1 + 1; }
insert_vals:
expr { $$ = 1; }
| DEFAULT { sqlp_ins_default(); $$ = 1; }
| DEFAULT { sqlp_ins_default(pstate); $$ = 1; }
| insert_vals ',' expr { $$ = $1 + 1; }
| insert_vals ',' DEFAULT { sqlp_ins_default(); $$ = $1 + 1; }
| insert_vals ',' DEFAULT { sqlp_ins_default(pstate); $$ = $1 + 1; }
;
insert_stmt: INSERT insert_opts opt_into NAME
SET insert_asgn_list
opt_ondupupdate
{ sqlp_insert_assn($2, $6, $4); free($4); }
{ sqlp_insert_assn(pstate, $2, $6, $4); free($4); }
;
insert_stmt: INSERT insert_opts opt_into NAME opt_col_names
select_stmt
opt_ondupupdate { sqlp_insert_sel($2, $4); free($4); }
opt_ondupupdate { sqlp_insert_sel(pstate, $2, $4); free($4); }
;
insert_asgn_list:
NAME COMPARISON expr
{ if ($2 != 4) { lyyerror(@2,"bad insert assignment to %s", $1); YYERROR; }
sqlp_assign(NULL, $1); free($1); $$ = 1; }
sqlp_assign(pstate, NULL, $1); free($1); $$ = 1; }
| NAME COMPARISON DEFAULT
{ if ($2 != 4) { lyyerror(@2,"bad insert assignment to %s", $1); YYERROR; }
sqlp_ins_default(); sqlp_assign(NULL, $1); free($1); $$ = 1; }
sqlp_ins_default(pstate); sqlp_assign(pstate, NULL, $1); free($1); $$ = 1; }
| insert_asgn_list ',' NAME COMPARISON expr
{ if ($4 != 4) { lyyerror(@4,"bad insert assignment to %s", $1); YYERROR; }
sqlp_assign(NULL, $3); free($3); $$ = $1 + 1; }
sqlp_assign(pstate, NULL, $3); free($3); $$ = $1 + 1; }
| insert_asgn_list ',' NAME COMPARISON DEFAULT
{ if ($4 != 4) { lyyerror(@4,"bad insert assignment to %s", $1); YYERROR; }
sqlp_ins_default(); sqlp_assign(NULL, $3); free($3); $$ = $1 + 1; }
sqlp_ins_default(pstate); sqlp_assign(pstate, NULL, $3); free($3); $$ = $1 + 1; }
;
/** replace just like insert **/
stmt: replace_stmt { sqlp_stmt(); }
stmt: replace_stmt { sqlp_stmt(pstate); }
;
replace_stmt: REPLACE insert_opts opt_into NAME
opt_col_names
VALUES insert_vals_list
opt_ondupupdate { sqlp_replace_vals($2, $7, $4); free($4); }
opt_ondupupdate { sqlp_replace_vals(pstate, $2, $7, $4); free($4); }
;
replace_stmt: REPLACE insert_opts opt_into NAME
SET insert_asgn_list
opt_ondupupdate
{ sqlp_replace_assn($2, $6, $4); free($4); }
{ sqlp_replace_assn(pstate, $2, $6, $4); free($4); }
;
replace_stmt: REPLACE insert_opts opt_into NAME opt_col_names
select_stmt
opt_ondupupdate { sqlp_replace_sel($2, $4); free($4); }
opt_ondupupdate { sqlp_replace_sel(pstate, $2, $4); free($4); }
;
/** update **/
stmt: update_stmt { sqlp_stmt(); }
stmt: update_stmt { sqlp_stmt(pstate); }
;
update_stmt: UPDATE update_opts table_references
SET update_asgn_list
opt_where
opt_orderby
opt_limit { sqlp_update($2, $3, $5); }
opt_limit { sqlp_update(pstate, $2, $3, $5); }
;
update_opts: /* nil */ { $$ = 0; }
@ -665,27 +665,27 @@ update_opts: /* nil */ { $$ = 0; }
update_asgn_list:
NAME COMPARISON expr
{ if ($2 != 4) { lyyerror(@2,"bad update assignment to %s", $1); YYERROR; }
sqlp_assign(NULL, $1); free($1); $$ = 1; }
sqlp_assign(pstate, NULL, $1); free($1); $$ = 1; }
| NAME '.' NAME COMPARISON expr
{ if ($4 != 4) { lyyerror(@4,"bad update assignment to %s", $1); YYERROR; }
sqlp_assign($1, $3); free($1); free($3); $$ = 1; }
sqlp_assign(pstate, $1, $3); free($1); free($3); $$ = 1; }
| update_asgn_list ',' NAME COMPARISON expr
{ if ($4 != 4) { lyyerror(@4,"bad update assignment to %s", $3); YYERROR; }
sqlp_assign(NULL, $3); free($3); $$ = $1 + 1; }
sqlp_assign(pstate, NULL, $3); free($3); $$ = $1 + 1; }
| update_asgn_list ',' NAME '.' NAME COMPARISON expr
{ if ($6 != 4) { lyyerror(@6,"bad update assignment to %s.$s", $3, $5); YYERROR; }
sqlp_assign($3, $5); free($3); free($5); $$ = 1; }
sqlp_assign(pstate, $3, $5); free($3); free($5); $$ = 1; }
;
/** create database **/
stmt: create_database_stmt { sqlp_stmt(); }
stmt: create_database_stmt { sqlp_stmt(pstate); }
;
create_database_stmt:
CREATE DATABASE opt_if_not_exists NAME { sqlp_create_db($3, $4); free($4); }
| CREATE SCHEMA opt_if_not_exists NAME { sqlp_create_db($3, $4); free($4); }
CREATE DATABASE opt_if_not_exists NAME { sqlp_create_db(pstate, $3, $4); free($4); }
| CREATE SCHEMA opt_if_not_exists NAME { sqlp_create_db(pstate, $3, $4); free($4); }
;
opt_if_not_exists: /* nil */ { $$ = 0; }
@ -695,12 +695,12 @@ opt_if_not_exists: /* nil */ { $$ = 0; }
/** drop database **/
stmt: drop_database_stmt { sqlp_stmt(); }
stmt: drop_database_stmt { sqlp_stmt(pstate); }
;
drop_database_stmt:
DROP DATABASE opt_if_exists NAME { sqlp_drop_db($3, $4); free($4); }
| DROP SCHEMA opt_if_exists NAME { sqlp_drop_db($3, $4); free($4); }
DROP DATABASE opt_if_exists NAME { sqlp_drop_db(pstate, $3, $4); free($4); }
| DROP SCHEMA opt_if_exists NAME { sqlp_drop_db(pstate, $3, $4); free($4); }
;
opt_if_exists: /* nil */ { $$ = 0; }
@ -709,35 +709,35 @@ opt_if_exists: /* nil */ { $$ = 0; }
/** create table **/
stmt: create_table_stmt { sqlp_stmt(); }
stmt: create_table_stmt { sqlp_stmt(pstate); }
;
create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME
'(' create_col_list ')' { sqlp_create_tbl($2, $4, $7, NULL, $5); free($5); }
'(' create_col_list ')' { sqlp_create_tbl(pstate, $2, $4, $7, NULL, $5); free($5); }
;
create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME '.' NAME
'(' create_col_list ')' { sqlp_create_tbl($2, $4, $9, $5, $7);
'(' create_col_list ')' { sqlp_create_tbl(pstate, $2, $4, $9, $5, $7);
free($5); free($7); }
;
create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME
'(' create_col_list ')'
create_select_statement { sqlp_create_tbl_sel($2, $4, $7, NULL, $5); free($5); }
create_select_statement { sqlp_create_tbl_sel(pstate, $2, $4, $7, NULL, $5); free($5); }
;
create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME
create_select_statement { sqlp_create_tbl_sel($2, $4, 0, NULL, $5); free($5); }
create_select_statement { sqlp_create_tbl_sel(pstate, $2, $4, 0, NULL, $5); free($5); }
;
create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME '.' NAME
'(' create_col_list ')'
create_select_statement { sqlp_create_tbl_sel($2, $4, 0, $5, $7);
create_select_statement { sqlp_create_tbl_sel(pstate, $2, $4, 0, $5, $7);
free($5); free($7); }
;
create_table_stmt: CREATE opt_temporary TABLE opt_if_not_exists NAME '.' NAME
create_select_statement { sqlp_create_tbl_sel($2, $4, 0, $5, $7);
create_select_statement { sqlp_create_tbl_sel(pstate, $2, $4, 0, $5, $7);
free($5); free($7); }
;
@ -745,29 +745,29 @@ create_col_list: create_definition { $$ = 1; }
| create_col_list ',' create_definition { $$ = $1 + 1; }
;
create_definition: { sqlp_start_col(); } NAME data_type column_atts
{ sqlp_def_col($3, $2); free($2); }
create_definition: { sqlp_start_col(pstate); } NAME data_type column_atts
{ sqlp_def_col(pstate, $3, $2); free($2); }
| PRIMARY KEY '(' column_list ')' { sqlp_col_key_pri($4); }
| KEY '(' column_list ')' { sqlp_col_key($3); }
| INDEX '(' column_list ')' { sqlp_col_key($3); }
| FULLTEXT INDEX '(' column_list ')' { sqlp_col_key_textidx($4); }
| FULLTEXT KEY '(' column_list ')' { sqlp_col_key_textidx($4); }
| PRIMARY KEY '(' column_list ')' { sqlp_col_key_pri(pstate, $4); }
| KEY '(' column_list ')' { sqlp_col_key(pstate, $3); }
| INDEX '(' column_list ')' { sqlp_col_key(pstate, $3); }
| FULLTEXT INDEX '(' column_list ')' { sqlp_col_key_textidx(pstate, $4); }
| FULLTEXT KEY '(' column_list ')' { sqlp_col_key_textidx(pstate, $4); }
;
column_atts: /* nil */ { $$ = 0; }
| column_atts NOT NULLX { sqlp_col_attr(SCA_NOTNULL); $$ = $1 + 1; }
| column_atts NOT NULLX { sqlp_col_attr(pstate, SCA_NOTNULL); $$ = $1 + 1; }
| column_atts NULLX
| column_atts DEFAULT STRING { sqlp_col_def_str($3); free($3); $$ = $1 + 1; }
| column_atts DEFAULT INTNUM { sqlp_col_def_num($3); $$ = $1 + 1; }
| column_atts DEFAULT APPROXNUM { sqlp_col_def_float($3); $$ = $1 + 1; }
| column_atts DEFAULT BOOL { sqlp_col_def_bool($3); $$ = $1 + 1; }
| column_atts AUTO_INCREMENT { sqlp_col_attr(SCA_AUTOINC); $$ = $1 + 1; }
| column_atts UNIQUE '(' column_list ')' { sqlp_col_attr_uniq($4); $$ = $1 + 1; }
| column_atts UNIQUE KEY { sqlp_col_attr_uniq(0); $$ = $1 + 1; }
| column_atts PRIMARY KEY { sqlp_col_attr(SCA_PRIMARY_KEY); $$ = $1 + 1; }
| column_atts KEY { sqlp_col_attr(SCA_PRIMARY_KEY); $$ = $1 + 1; }
| column_atts COMMENT STRING { sqlp_col_attr_comm($3); free($3); $$ = $1 + 1; }
| column_atts DEFAULT STRING { sqlp_col_def_str(pstate, $3); free($3); $$ = $1 + 1; }
| column_atts DEFAULT INTNUM { sqlp_col_def_num(pstate, $3); $$ = $1 + 1; }
| column_atts DEFAULT APPROXNUM { sqlp_col_def_float(pstate, $3); $$ = $1 + 1; }
| column_atts DEFAULT BOOL { sqlp_col_def_bool(pstate, $3); $$ = $1 + 1; }
| column_atts AUTO_INCREMENT { sqlp_col_attr(pstate, SCA_AUTOINC); $$ = $1 + 1; }
| column_atts UNIQUE '(' column_list ')' { sqlp_col_attr_uniq(pstate, $4); $$ = $1 + 1; }
| column_atts UNIQUE KEY { sqlp_col_attr_uniq(pstate, 0); $$ = $1 + 1; }
| column_atts PRIMARY KEY { sqlp_col_attr(pstate, SCA_PRIMARY_KEY); $$ = $1 + 1; }
| column_atts KEY { sqlp_col_attr(pstate, SCA_PRIMARY_KEY); $$ = $1 + 1; }
| column_atts COMMENT STRING { sqlp_col_attr_comm(pstate, $3); free($3); $$ = $1 + 1; }
;
opt_length: /* nil */ { $$ = 0; }
@ -785,8 +785,8 @@ opt_uz: /* nil */ { $$ = 0; }
;
opt_csc: /* nil */
| opt_csc CHAR SET STRING { sqlp_col_charset($4); free($4); }
| opt_csc COLLATE STRING { sqlp_col_collate($3); free($3); }
| opt_csc CHAR SET STRING { sqlp_col_charset(pstate, $4); free($4); }
| opt_csc COLLATE STRING { sqlp_col_collate(pstate, $3); free($3); }
;
data_type:
@ -822,11 +822,11 @@ data_type:
| SET '(' enum_list ')' opt_csc { $$ = 210000 + $3; }
;
enum_list: STRING { sqlp_enum_val($1); free($1); $$ = 1; }
| enum_list ',' STRING { sqlp_enum_val($3); free($3); $$ = $1 + 1; }
enum_list: STRING { sqlp_enum_val(pstate, $1); free($1); $$ = 1; }
| enum_list ',' STRING { sqlp_enum_val(pstate, $3); free($3); $$ = $1 + 1; }
;
create_select_statement: opt_ignore_replace opt_as select_stmt { sqlp_create_sel($1); }
create_select_statement: opt_ignore_replace opt_as select_stmt { sqlp_create_sel(pstate, $1); }
;
opt_ignore_replace: /* nil */ { $$ = 0; }
@ -840,24 +840,24 @@ opt_temporary: /* nil */ { $$ = 0; }
/** drop table **/
stmt: drop_table_stmt { sqlp_stmt(); }
stmt: drop_table_stmt { sqlp_stmt(pstate); }
;
drop_table_stmt:
DROP opt_temporary TABLE opt_if_exists table_list { sqlp_drop_table($2, $4, $5); }
DROP opt_temporary TABLE opt_if_exists table_list { sqlp_drop_table(pstate, $2, $4, $5); }
;
table_list: NAME { sqlp_table(NULL, $1); free($1); $$ = 1; }
table_list: NAME { sqlp_table(pstate, NULL, $1); free($1); $$ = 1; }
| STRING { lyyerror(@1, "string %s found where name required", $1);
sqlp_table(NULL, $1); free($1); $$ = 1; }
| table_list ',' NAME { sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
sqlp_table(pstate, NULL, $1); free($1); $$ = 1; }
| table_list ',' NAME { sqlp_table(pstate, NULL, $3); free($3); $$ = $1 + 1; }
| table_list ',' STRING { lyyerror(@3, "string %s found where name required", $1);
sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
sqlp_table(pstate, NULL, $3); free($3); $$ = $1 + 1; }
;
/**** set user variables ****/
stmt: set_stmt { sqlp_stmt(); }
stmt: set_stmt { sqlp_stmt(pstate); }
;
set_stmt: SET set_list ;
@ -866,52 +866,52 @@ set_list: set_expr | set_list ',' set_expr ;
set_expr:
USERVAR COMPARISON expr { if ($2 != 4) { lyyerror(@2,"bad set to @%s", $1); YYERROR; }
sqlp_set($1); free($1); }
| USERVAR ASSIGN expr { sqlp_set($1); free($1); }
sqlp_set(pstate, $1); free($1); }
| USERVAR ASSIGN expr { sqlp_set(pstate, $1); free($1); }
;
/**** expressions ****/
expr: NAME { sqlp_name($1); free($1); }
| USERVAR { sqlp_uservar($1); free($1); }
| NAME '.' NAME { sqlp_fieldname($1, $3); free($1); free($3); }
| STRING { sqlp_string($1); free($1); }
| INTNUM { sqlp_number($1); }
| APPROXNUM { sqlp_float($1); }
| BOOL { sqlp_bool($1); }
expr: NAME { sqlp_name(pstate, $1); free($1); }
| USERVAR { sqlp_uservar(pstate, $1); free($1); }
| NAME '.' NAME { sqlp_fieldname(pstate, $1, $3); free($1); free($3); }
| STRING { sqlp_string(pstate, $1); free($1); }
| INTNUM { sqlp_number(pstate, $1); }
| APPROXNUM { sqlp_float(pstate, $1); }
| BOOL { sqlp_bool(pstate, $1); }
;
expr: expr '+' expr { sqlp_expr_op(SEO_ADD); }
| expr '-' expr { sqlp_expr_op(SEO_SUB); }
| expr '*' expr { sqlp_expr_op(SEO_MUL); }
| expr '/' expr { sqlp_expr_op(SEO_DIV); }
| expr '%' expr { sqlp_expr_op(SEO_MOD); }
| expr MOD expr { sqlp_expr_op(SEO_MOD); }
| '-' expr %prec UMINUS { sqlp_expr_op(SEO_NEG); }
| expr ANDOP expr { sqlp_expr_op(SEO_AND); }
| expr OR expr { sqlp_expr_op(SEO_OR); }
| expr XOR expr { sqlp_expr_op(SEO_XOR); }
| expr COMPARISON expr { sqlp_expr_cmp($2); }
| expr COMPARISON '(' select_stmt ')' { sqlp_expr_cmp_sel(0, $2); }
| expr COMPARISON ANY '(' select_stmt ')' { sqlp_expr_cmp_sel(1, $2); }
| expr COMPARISON SOME '(' select_stmt ')' { sqlp_expr_cmp_sel(2, $2); }
| expr COMPARISON ALL '(' select_stmt ')' { sqlp_expr_cmp_sel(3, $2); }
| expr '|' expr { sqlp_expr_op(SEO_BITOR); }
| expr '&' expr { sqlp_expr_op(SEO_BITAND); }
| expr '^' expr { sqlp_expr_op(SEO_BITXOR); }
| expr SHIFT expr { sqlp_expr_op($2 == 1 ? SEO_SHL : SEO_SHR); }
| NOT expr { sqlp_expr_op(SEO_NOT); }
| '!' expr { sqlp_expr_op(SEO_NOT); }
| USERVAR ASSIGN expr { sqlp_assign_at($1); free($1); }
expr: expr '+' expr { sqlp_expr_op(pstate, SEO_ADD); }
| expr '-' expr { sqlp_expr_op(pstate, SEO_SUB); }
| expr '*' expr { sqlp_expr_op(pstate, SEO_MUL); }
| expr '/' expr { sqlp_expr_op(pstate, SEO_DIV); }
| expr '%' expr { sqlp_expr_op(pstate, SEO_MOD); }
| expr MOD expr { sqlp_expr_op(pstate, SEO_MOD); }
| '-' expr %prec UMINUS { sqlp_expr_op(pstate, SEO_NEG); }
| expr ANDOP expr { sqlp_expr_op(pstate, SEO_AND); }
| expr OR expr { sqlp_expr_op(pstate, SEO_OR); }
| expr XOR expr { sqlp_expr_op(pstate, SEO_XOR); }
| expr COMPARISON expr { sqlp_expr_cmp(pstate, $2); }
| expr COMPARISON '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 0, $2); }
| expr COMPARISON ANY '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 1, $2); }
| expr COMPARISON SOME '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 2, $2); }
| expr COMPARISON ALL '(' select_stmt ')' { sqlp_expr_cmp_sel(pstate, 3, $2); }
| expr '|' expr { sqlp_expr_op(pstate, SEO_BITOR); }
| expr '&' expr { sqlp_expr_op(pstate, SEO_BITAND); }
| expr '^' expr { sqlp_expr_op(pstate, SEO_BITXOR); }
| expr SHIFT expr { sqlp_expr_op(pstate, $2 == 1 ? SEO_SHL : SEO_SHR); }
| NOT expr { sqlp_expr_op(pstate, SEO_NOT); }
| '!' expr { sqlp_expr_op(pstate, SEO_NOT); }
| USERVAR ASSIGN expr { sqlp_assign_at(pstate, $1); free($1); }
;
expr: expr IS NULLX { sqlp_expr_op(SEO_IS_NULL); }
| expr IS NOT NULLX { sqlp_expr_op(SEO_IS_NULL); sqlp_expr_op(SEO_NOT); }
| expr IS BOOL { sqlp_expr_is_bool($3); }
| expr IS NOT BOOL { sqlp_expr_is_bool($4); sqlp_expr_op(SEO_NOT); }
expr: expr IS NULLX { sqlp_expr_op(pstate, SEO_IS_NULL); }
| expr IS NOT NULLX { sqlp_expr_op(pstate, SEO_IS_NULL); sqlp_expr_op(pstate, SEO_NOT); }
| expr IS BOOL { sqlp_expr_is_bool(pstate, $3); }
| expr IS NOT BOOL { sqlp_expr_is_bool(pstate, $4); sqlp_expr_op(pstate, SEO_NOT); }
;
expr: expr BETWEEN expr AND expr %prec BETWEEN { sqlp_expr_op(SEO_BETWEEN); }
expr: expr BETWEEN expr AND expr %prec BETWEEN { sqlp_expr_op(pstate, SEO_BETWEEN); }
;
@ -923,71 +923,71 @@ opt_val_list: /* nil */ { $$ = 0; }
| val_list
;
expr: expr IN '(' val_list ')' { sqlp_expr_is_in($4); }
| expr NOT IN '(' val_list ')' { sqlp_expr_is_in($5); sqlp_expr_op(SEO_NOT); }
| expr IN '(' select_stmt ')' { sqlp_expr_op(SEO_IN_SELECT); }
| expr NOT IN '(' select_stmt ')' { sqlp_expr_op(SEO_IN_SELECT); sqlp_expr_op(SEO_NOT); }
| EXISTS '(' select_stmt ')' { sqlp_expr_op(SEO_EXISTS); if($1)sqlp_expr_op(SEO_NOT); }
expr: expr IN '(' val_list ')' { sqlp_expr_is_in(pstate, $4); }
| expr NOT IN '(' val_list ')' { sqlp_expr_is_in(pstate, $5); sqlp_expr_op(pstate, SEO_NOT); }
| expr IN '(' select_stmt ')' { sqlp_expr_op(pstate, SEO_IN_SELECT); }
| expr NOT IN '(' select_stmt ')' { sqlp_expr_op(pstate, SEO_IN_SELECT); sqlp_expr_op(pstate, SEO_NOT); }
| EXISTS '(' select_stmt ')' { sqlp_expr_op(pstate, SEO_EXISTS); if($1)sqlp_expr_op(pstate, SEO_NOT); }
;
expr: NAME '(' opt_val_list ')' { sqlp_call($3, $1); free($1); }
expr: NAME '(' opt_val_list ')' { sqlp_call(pstate, $3, $1); free($1); }
;
/* functions with special syntax */
expr: FCOUNT '(' '*' ')' { sqlp_call(0, "COUNTALL"); }
| FCOUNT '(' expr ')' { sqlp_call(1, "COUNT"); }
expr: FCOUNT '(' '*' ')' { sqlp_call(pstate, 0, "COUNTALL"); }
| FCOUNT '(' expr ')' { sqlp_call(pstate, 1, "COUNT"); }
expr: FSUBSTRING '(' val_list ')' { sqlp_call($3, "SUBSTR");}
| FSUBSTRING '(' expr FROM expr ')' { sqlp_call(2, "SUBSTR"); }
| FSUBSTRING '(' expr FROM expr FOR expr ')' { sqlp_call(3, "SUBSTR"); }
| FTRIM '(' val_list ')' { sqlp_call($3, "TRIM"); }
| FTRIM '(' trim_ltb expr FROM val_list ')' { sqlp_call(3, "TRIM"); }
expr: FSUBSTRING '(' val_list ')' { sqlp_call(pstate, $3, "SUBSTR");}
| FSUBSTRING '(' expr FROM expr ')' { sqlp_call(pstate, 2, "SUBSTR"); }
| FSUBSTRING '(' expr FROM expr FOR expr ')' { sqlp_call(pstate, 3, "SUBSTR"); }
| FTRIM '(' val_list ')' { sqlp_call(pstate, $3, "TRIM"); }
| FTRIM '(' trim_ltb expr FROM val_list ')' { sqlp_call(pstate, 3, "TRIM"); }
;
trim_ltb: LEADING { sqlp_call_trim_opts(0); }
| TRAILING { sqlp_call_trim_opts(1); }
| BOTH { sqlp_call_trim_opts(2); }
trim_ltb: LEADING { sqlp_call_trim_opts(pstate, 0); }
| TRAILING { sqlp_call_trim_opts(pstate, 1); }
| BOTH { sqlp_call_trim_opts(pstate, 2); }
;
expr: FDATE_ADD '(' expr ',' interval_exp ')' { sqlp_call_date(3, SEO_ADD); }
| FDATE_SUB '(' expr ',' interval_exp ')' { sqlp_call_date(3, SEO_SUB); }
expr: FDATE_ADD '(' expr ',' interval_exp ')' { sqlp_call_date(pstate, 3, SEO_ADD); }
| FDATE_SUB '(' expr ',' interval_exp ')' { sqlp_call_date(pstate, 3, SEO_SUB); }
;
interval_exp: INTERVAL expr DAY_HOUR { sqlp_date_interval(SDI_DAY_HOUR); }
| INTERVAL expr DAY_MICROSECOND { sqlp_date_interval(SDI_DAY_MICROSECOND); }
| INTERVAL expr DAY_MINUTE { sqlp_date_interval(SDI_DAY_MINUTE); }
| INTERVAL expr DAY_SECOND { sqlp_date_interval(SDI_DAY_SECOND); }
| INTERVAL expr YEAR_MONTH { sqlp_date_interval(SDI_YEAR_MONTH); }
| INTERVAL expr YEAR { sqlp_date_interval(SDI_YEAR); }
| INTERVAL expr HOUR_MICROSECOND { sqlp_date_interval(SDI_HOUR_MICROSECOND); }
| INTERVAL expr HOUR_MINUTE { sqlp_date_interval(SDI_HOUR_MINUTE); }
| INTERVAL expr HOUR_SECOND { sqlp_date_interval(SDI_HOUR_SECOND); }
interval_exp: INTERVAL expr DAY_HOUR { sqlp_date_interval(pstate, SDI_DAY_HOUR); }
| INTERVAL expr DAY_MICROSECOND { sqlp_date_interval(pstate, SDI_DAY_MICROSECOND); }
| INTERVAL expr DAY_MINUTE { sqlp_date_interval(pstate, SDI_DAY_MINUTE); }
| INTERVAL expr DAY_SECOND { sqlp_date_interval(pstate, SDI_DAY_SECOND); }
| INTERVAL expr YEAR_MONTH { sqlp_date_interval(pstate, SDI_YEAR_MONTH); }
| INTERVAL expr YEAR { sqlp_date_interval(pstate, SDI_YEAR); }
| INTERVAL expr HOUR_MICROSECOND { sqlp_date_interval(pstate, SDI_HOUR_MICROSECOND); }
| INTERVAL expr HOUR_MINUTE { sqlp_date_interval(pstate, SDI_HOUR_MINUTE); }
| INTERVAL expr HOUR_SECOND { sqlp_date_interval(pstate, SDI_HOUR_SECOND); }
;
expr: CASE expr case_list END { sqlp_caseval($3, 0); }
| CASE expr case_list ELSE expr END { sqlp_caseval($3, 1); }
| CASE case_list END { sqlp_case($2, 0); }
| CASE case_list ELSE expr END { sqlp_case($2, 1); }
expr: CASE expr case_list END { sqlp_caseval(pstate, $3, 0); }
| CASE expr case_list ELSE expr END { sqlp_caseval(pstate, $3, 1); }
| CASE case_list END { sqlp_case(pstate, $2, 0); }
| CASE case_list ELSE expr END { sqlp_case(pstate, $2, 1); }
;
case_list: WHEN expr THEN expr { $$ = 1; }
| case_list WHEN expr THEN expr { $$ = $1+1; }
;
expr: expr LIKE expr { sqlp_expr_op(SEO_LIKE); }
| expr NOT LIKE expr { sqlp_expr_op(SEO_LIKE); sqlp_expr_op(SEO_NOT); }
expr: expr LIKE expr { sqlp_expr_op(pstate, SEO_LIKE); }
| expr NOT LIKE expr { sqlp_expr_op(pstate, SEO_LIKE); sqlp_expr_op(pstate, SEO_NOT); }
;
expr: expr REGEXP expr { sqlp_expr_op(SEO_REGEX); }
| expr NOT REGEXP expr { sqlp_expr_op(SEO_REGEX); sqlp_expr_op(SEO_NOT); }
expr: expr REGEXP expr { sqlp_expr_op(pstate, SEO_REGEX); }
| expr NOT REGEXP expr { sqlp_expr_op(pstate, SEO_REGEX); sqlp_expr_op(pstate, SEO_NOT); }
;
expr: CURRENT_TIMESTAMP { sqlp_now(); };
| CURRENT_DATE { sqlp_now(); };
| CURRENT_TIME { sqlp_now(); };
expr: CURRENT_TIMESTAMP { sqlp_now(pstate); };
| CURRENT_DATE { sqlp_now(pstate); };
| CURRENT_TIME { sqlp_now(pstate); };
;
expr: BINARY expr %prec UMINUS { sqlp_expr_op(SEO_STRTOBIN); }
expr: BINARY expr %prec UMINUS { sqlp_expr_op(pstate, SEO_STRTOBIN); }
;
%%