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
Show Stats 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 .SUFFIXES: .l .y .c
exec.o: exec.c sql-parser.h 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 Original version - most of the work - comes from John Levine's
Flex & Bison book published by O'Reilley. 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", [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); 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", printf("exec ASSIGN %s%s%s\n",
db_name ? db_name : "", db_name ? db_name : "",
@ -69,119 +69,119 @@ void sqlp_assign(const char *db_name, const char *name)
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); 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); 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); 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", printf("exec CALL %d DATE %s\n",
n_args, n_args,
op == SEO_ADD ? "ADD" : "SUB"); 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); 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); 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); 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]); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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) const char *db_name, const char *name)
{ {
printf("exec CREATE-TABLE %d %d %d %s%s%s\n", 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); 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) const char *db_name, const char *name)
{ {
printf("exec CREATE-TABLE-SELECT %d %d %d %s%s%s\n", 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); 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]); 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); 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); 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); 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); 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); 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); 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); 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); 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); 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]); 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); 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); 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); 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); 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); printf("exec GROUPBY %d\n", opts);
} }
void sqlp_having(void) void sqlp_having(struct psql_state *pstate)
{ {
printf("exec HAVING\n"); 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); 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); 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); 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"); 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); 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); 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); 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); 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); 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); 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"); 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); 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); 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); printf("exec NAME %s\n", name);
} }
void sqlp_now(void) void sqlp_now(struct psql_state *pstate)
{ {
printf("exec NOW\n"); 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); 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); 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); 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); 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); 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); 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); 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"); 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); printf("exec SET %s\n", name);
} }
void sqlp_start_col(void) void sqlp_start_col(struct psql_state *pstate)
{ {
printf("exec START-COL\n"); printf("exec START-COL\n");
} }
void sqlp_stmt(void) void sqlp_stmt(struct psql_state *pstate)
{ {
printf("exec STMT\n"); 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); printf("exec STRING %s\n", str);
} }
void sqlp_subquery(void) void sqlp_subquery(struct psql_state *pstate)
{ {
printf("exec SUBQUERY\n"); 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); 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", printf("exec TABLE %s%s%s\n",
db_name ? db_name : "", db_name ? db_name : "",
@ -439,27 +439,27 @@ void sqlp_table(const char *db_name, const char *name)
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); 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); 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); 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); printf("exec VALUES %d\n", n_vals);
} }
void sqlp_where(void) void sqlp_where(struct psql_state *pstate)
{ {
printf("exec WHERE\n"); printf("exec WHERE\n");
} }

156
sql-parser.h
View File

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

368
sql.y
View File

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