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

emit() sweep: convert expressions, values, DELETE and SELECT

Browse Source 
Signed-off-by: Jeff Garzik <jgarzik@redhat.com>
This commit is contained in:
Jeff Garzik
2009-11-08 22:19:53 -05:00
committed by Jeff Garzik
parent 5f11c7e1e0
commit 38ec0eb526
3 changed files with 263 additions and 70 deletions

148
exec.c

@ -16,6 +16,42 @@ static const char *attr_names[] = {
[SCA_COMMENT] = "SCA_COMMENT",
};
static const char *op_names[] = {
[SEO_ADD] = "SEO_ADD",
[SEO_SUB] = "SEO_SUB",
[SEO_MUL] = "SEO_MUL",
[SEO_DIV] = "SEO_DIV",
[SEO_MOD] = "SEO_MOD",
[SEO_NEG] = "SEO_NEG",
[SEO_AND] = "SEO_AND",
[SEO_OR] = "SEO_OR",
[SEO_XOR] = "SEO_XOR",
[SEO_BITOR] = "SEO_BITOR",
[SEO_BITAND] = "SEO_BITAND",
[SEO_BITXOR] = "SEO_BITXOR",
[SEO_SHIFT] = "SEO_SHIFT",
[SEO_NOT] = "SEO_NOT",
[SEO_ASSIGN] = "SEO_ASSIGN",
[SEO_IS_NULL] = "SEO_IS_NULL",
[SEO_SHR] = "SEO_SHR",
[SEO_SHL] = "SEO_SHL",
[SEO_BETWEEN] = "SEO_BETWEEN",
[SEO_EXISTS] = "SEO_EXISTS",
[SEO_IN_SELECT] = "SEO_IN_SELECT",
[SEO_LIKE] = "SEO_LIKE",
[SEO_REGEX] = "SEO_REGEX",
};
void sqlp_alias(const char *alias)
{
printf("exec ALIAS %s\n", alias);
}
void sqlp_bool(int val)
{
printf("exec BOOL %d\n", val);
}
void sqlp_col_attr(enum sqlp_col_attribs attr)
{
printf("exec ATTR %s\n", attr_names[attr]);
@ -61,6 +97,11 @@ void sqlp_col_def_bool(int bool)
printf("exec ATTR DEFAULT-BOOL %d\n", bool);
}
void sqlp_column(const char *name)
{
printf("exec COLUMN %s\n", name);
}
void sqlp_create_db(int if_ne, const char *name)
{
printf("exec CREATE-DB %d %s\n", if_ne, name);
@ -81,6 +122,16 @@ void sqlp_def_col(int flags, const char *name)
printf("exec DEFINE-COL %d %s\n", flags, name);
}
void sqlp_delete(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)
{
printf("exec DELETE-MULTI %d %d %d\n", opts, n_del, n_tbl_ref);
}
void sqlp_drop_db(int if_exists, const char *name)
{
printf("exec DROP-DB %d %s\n", if_exists, name);
@ -96,6 +147,76 @@ void sqlp_enum_val(const char *val)
printf("exec ENUM-VAL %s\n", val);
}
void sqlp_expr_cmp(int comp)
{
printf("exec CMP %d\n", comp);
}
void sqlp_expr_is_bool(int val)
{
printf("exec EXPR-IS-BOOL %d\n", val);
}
void sqlp_expr_is_in(int val)
{
printf("exec EXPR-IS-IN %d\n", val);
}
void sqlp_expr_op(enum sqlp_expr_ops op)
{
printf("exec EXPR-OP %s\n", op_names[op]);
}
void sqlp_expr_cmp_sel(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)
{
printf("exec FIELD-NAME %s.%s\n", db_name, name);
}
void sqlp_float(float val)
{
printf("exec FLOAT %g\n", val);
}
void sqlp_ins_cols(int n_cols)
{
printf("exec INSERT-COLS %d\n", n_cols);
}
void sqlp_ins_default(void)
{
printf("exec INSERT-DEFAULT\n");
}
void sqlp_insert(int opts, int n_vals, const char *tbl_name)
{
printf("exec INSERT %d %d %s\n", opts, n_vals, tbl_name);
}
void sqlp_name(const char *name)
{
printf("exec NAME %s\n", name);
}
void sqlp_number(int val)
{
printf("exec INT/NUMBER %d\n", val);
}
void sqlp_select(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_all(void)
{
printf("exec SELECT-ALL\n");
}
void sqlp_start_col(void)
{
printf("exec START-COL\n");
@ -106,8 +227,31 @@ void sqlp_stmt(void)
printf("exec STMT\n");
}
void sqlp_table(const char *name)
void sqlp_string(const char *str)
{
printf("exec TABLE %s\n", name);
printf("exec STRING %s\n", str);
}
void sqlp_table(const char *db_name, const char *name)
{
printf("exec TABLE %s%s%s\n",
db_name ? db_name : "",
db_name ? "." : "",
name);
}
void sqlp_uservar(const char *str)
{
printf("exec USER-VAR %s\n", str);
}
void sqlp_values(int n_vals)
{
printf("exec VALUES %d\n", n_vals);
}
void sqlp_where(void)
{
printf("exec WHERE\n");
}

51
sql-parser.h

@ -13,6 +13,34 @@ enum sqlp_col_attribs {
SCA_COMMENT = (1 << 8),
};
enum sqlp_expr_ops {
SEO_ADD = 0,
SEO_SUB = 1,
SEO_MUL = 2,
SEO_DIV = 3,
SEO_MOD = 4,
SEO_NEG = 5,
SEO_AND = 6,
SEO_OR = 7,
SEO_XOR = 8,
SEO_BITOR = 9,
SEO_BITAND = 10,
SEO_BITXOR = 11,
SEO_SHIFT = 12,
SEO_NOT = 13,
SEO_ASSIGN = 14,
SEO_IS_NULL = 15,
SEO_SHR = 16,
SEO_SHL = 17,
SEO_BETWEEN = 18,
SEO_EXISTS = 19,
SEO_IN_SELECT = 20,
SEO_LIKE = 21,
SEO_REGEX = 22,
};
extern void sqlp_alias(const char *alias);
extern void sqlp_bool(int val);
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);
@ -22,15 +50,36 @@ 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_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,
const char *db_name, const char *name);
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_ins_cols(int n_cols);
extern void sqlp_ins_default(void);
extern void sqlp_insert(int opts, int n_vals, const char *tbl_name);
extern void sqlp_name(const char *name);
extern void sqlp_number(int val);
extern void sqlp_select(int opts, int n_expr, int n_tbl_ref);
extern void sqlp_select_all(void);
extern void sqlp_start_col(void);
extern void sqlp_string(const char *str);
extern void sqlp_stmt(void);
extern void sqlp_table(const char *name);
extern void sqlp_table(const char *db_name, const char *name);
extern void sqlp_uservar(const char *str);
extern void sqlp_values(int n_vals);
extern void sqlp_where(void);
#endif /* __SQL_PARSER_H__ */

134
sql.y

@ -356,11 +356,11 @@ select_stmt: SELECT select_opts select_expr_list
| SELECT select_opts select_expr_list
FROM table_references
opt_where opt_groupby opt_having opt_orderby opt_limit
opt_into_list { emit("SELECT %d %d %d", $2, $3, $5); } ;
opt_into_list { sqlp_select($2, $3, $5); } ;
;
opt_where: /* nil */
| WHERE expr { emit("WHERE"); };
| WHERE expr { sqlp_where(); };
opt_groupby: /* nil */
| GROUP BY groupby_list opt_with_rollup
@ -395,12 +395,12 @@ opt_into_list: /* nil */
| INTO column_list { emit("INTO %d", $2); }
;
column_list: NAME { emit("COLUMN %s", $1); free($1); $$ = 1; }
column_list: NAME { sqlp_column($1); free($1); $$ = 1; }
| STRING { lyyerror(@1, "string %s found where name required", $1);
emit("COLUMN %s", $1); free($1); $$ = 1; }
| column_list ',' NAME { emit("COLUMN %s", $3); free($3); $$ = $1 + 1; }
sqlp_column($1); free($1); $$ = 1; }
| column_list ',' NAME { sqlp_column($3); free($3); $$ = $1 + 1; }
| column_list ',' STRING { lyyerror(@3, "string %s found where name required", $1);
emit("COLUMN %s", $3); free($3); $$ = $1 + 1; }
sqlp_column($3); free($3); $$ = $1 + 1; }
;
select_opts: { $$ = 0; }
@ -416,7 +416,7 @@ select_opts: { $$ = 0; }
select_expr_list: select_expr { $$ = 1; }
| select_expr_list ',' select_expr {$$ = $1 + 1; }
| '*' { emit("SELECTALL"); $$ = 1; }
| '*' { sqlp_select_all(); $$ = 1; }
;
select_expr: expr opt_as_alias ;
@ -430,8 +430,8 @@ table_reference: table_factor
;
table_factor:
NAME opt_as_alias index_hint { emit("TABLE %s", $1); free($1); }
| NAME '.' NAME opt_as_alias index_hint { emit("TABLE %s.%s", $1, $3);
NAME opt_as_alias index_hint { sqlp_table(NULL, $1); free($1); }
| NAME '.' NAME opt_as_alias index_hint { sqlp_table($1, $3);
free($1); free($3); }
| table_subquery opt_as NAME { emit("SUBQUERYAS %s", $3); free($3); }
| '(' table_references ')' { emit("TABLEREFERENCES %d", $2); }
@ -441,8 +441,8 @@ opt_as: AS
| /* nil */
;
opt_as_alias: AS NAME { emit ("ALIAS %s", $2); free($2); }
| NAME { emit ("ALIAS %s", $1); free($1); }
opt_as_alias: AS NAME { sqlp_alias($2); free($2); }
| NAME { sqlp_alias($1); free($1); }
| /* nil */
;
@ -512,7 +512,7 @@ stmt: delete_stmt { sqlp_stmt(); }
delete_stmt: DELETE delete_opts FROM NAME
opt_where opt_orderby opt_limit
{ emit("DELETEONE %d %s", $2, $4); free($4); }
{ sqlp_delete($2, $4); free($4); }
;
delete_opts: delete_opts LOW_PRIORITY { $$ = $1 + 01; }
@ -524,11 +524,11 @@ delete_opts: delete_opts LOW_PRIORITY { $$ = $1 + 01; }
delete_stmt: DELETE delete_opts
delete_list
FROM table_references opt_where
{ emit("DELETEMULTI %d %d %d", $2, $3, $5); }
{ sqlp_delete_multi($2, $3, $5); }
delete_list: NAME opt_dot_star { emit("TABLE %s", $1); free($1); $$ = 1; }
delete_list: NAME opt_dot_star { sqlp_table(NULL, $1); free($1); $$ = 1; }
| delete_list ',' NAME opt_dot_star
{ emit("TABLE %s", $3); free($3); $$ = $1 + 1; }
{ sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
;
opt_dot_star: /* nil */ | '.' '*' ;
@ -547,7 +547,7 @@ stmt: insert_stmt { sqlp_stmt(); }
insert_stmt: INSERT insert_opts opt_into NAME
opt_col_names
VALUES insert_vals_list
opt_ondupupdate { emit("INSERTVALS %d %d %s", $2, $7, $4); free($4) }
opt_ondupupdate { sqlp_insert($2, $7, $4); free($4) }
;
opt_ondupupdate: /* nil */
@ -565,17 +565,17 @@ opt_into: INTO | /* nil */
;
opt_col_names: /* nil */
| '(' column_list ')' { emit("INSERTCOLS %d", $2); }
| '(' column_list ')' { sqlp_ins_cols($2); }
;
insert_vals_list: '(' insert_vals ')' { emit("VALUES %d", $2); $$ = 1; }
| insert_vals_list ',' '(' insert_vals ')' { emit("VALUES %d", $4); $$ = $1 + 1; }
insert_vals_list: '(' insert_vals ')' { sqlp_values($2); $$ = 1; }
| insert_vals_list ',' '(' insert_vals ')' { sqlp_values($4); $$ = $1 + 1; }
insert_vals:
expr { $$ = 1; }
| DEFAULT { emit("DEFAULT"); $$ = 1; }
| DEFAULT { sqlp_ins_default(); $$ = 1; }
| insert_vals ',' expr { $$ = $1 + 1; }
| insert_vals ',' DEFAULT { emit("DEFAULT"); $$ = $1 + 1; }
| insert_vals ',' DEFAULT { sqlp_ins_default(); $$ = $1 + 1; }
;
insert_stmt: INSERT insert_opts opt_into NAME
@ -826,12 +826,12 @@ drop_table_stmt:
DROP opt_temporary TABLE opt_if_exists table_list { sqlp_drop_table($2, $4, $5); }
;
table_list: NAME { sqlp_table($1); free($1); $$ = 1; }
table_list: NAME { sqlp_table(NULL, $1); free($1); $$ = 1; }
| STRING { lyyerror(@1, "string %s found where name required", $1);
sqlp_table($1); free($1); $$ = 1; }
| table_list ',' NAME { sqlp_table($3); free($3); $$ = $1 + 1; }
sqlp_table(NULL, $1); free($1); $$ = 1; }
| table_list ',' NAME { sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
| table_list ',' STRING { lyyerror(@3, "string %s found where name required", $1);
sqlp_table($3); free($3); $$ = $1 + 1; }
sqlp_table(NULL, $3); free($3); $$ = $1 + 1; }
;
/**** set user variables ****/
@ -851,46 +851,46 @@ USERVAR COMPARISON expr { if ($2 != 4) { lyyerror(@2,"bad set to @%s", $1); YYER
/**** expressions ****/
expr: NAME { emit("NAME %s", $1); free($1); }
| USERVAR { emit("USERVAR %s", $1); free($1); }
| NAME '.' NAME { emit("FIELDNAME %s.%s", $1, $3); free($1); free($3); }
| STRING { emit("STRING %s", $1); free($1); }
| INTNUM { emit("NUMBER %d", $1); }
| APPROXNUM { emit("FLOAT %g", $1); }
| BOOL { emit("BOOL %d", $1); }
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: expr '+' expr { emit("ADD"); }
| expr '-' expr { emit("SUB"); }
| expr '*' expr { emit("MUL"); }
| expr '/' expr { emit("DIV"); }
| expr '%' expr { emit("MOD"); }
| expr MOD expr { emit("MOD"); }
| '-' expr %prec UMINUS { emit("NEG"); }
| expr ANDOP expr { emit("AND"); }
| expr OR expr { emit("OR"); }
| expr XOR expr { emit("XOR"); }
| expr COMPARISON expr { emit("CMP %d", $2); }
| expr COMPARISON '(' select_stmt ')' { emit("CMPSELECT %d", $2); }
| expr COMPARISON ANY '(' select_stmt ')' { emit("CMPANYSELECT %d", $2); }
| expr COMPARISON SOME '(' select_stmt ')' { emit("CMPANYSELECT %d", $2); }
| expr COMPARISON ALL '(' select_stmt ')' { emit("CMPALLSELECT %d", $2); }
| expr '|' expr { emit("BITOR"); }
| expr '&' expr { emit("BITAND"); }
| expr '^' expr { emit("BITXOR"); }
| expr SHIFT expr { emit("SHIFT %s", $2==1?"left":"right"); }
| NOT expr { emit("NOT"); }
| '!' expr { emit("NOT"); }
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 { emit("ASSIGN @%s", $1); free($1); }
;
expr: expr IS NULLX { emit("ISNULL"); }
| expr IS NOT NULLX { emit("ISNULL"); emit("NOT"); }
| expr IS BOOL { emit("ISBOOL %d", $3); }
| expr IS NOT BOOL { emit("ISBOOL %d", $4); emit("NOT"); }
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 BETWEEN expr AND expr %prec BETWEEN { emit("BETWEEN"); }
expr: expr BETWEEN expr AND expr %prec BETWEEN { sqlp_expr_op(SEO_BETWEEN); }
;
@ -902,11 +902,11 @@ opt_val_list: /* nil */ { $$ = 0 }
| val_list
;
expr: expr IN '(' val_list ')' { emit("ISIN %d", $4); }
| expr NOT IN '(' val_list ')' { emit("ISIN %d", $5); emit("NOT"); }
| expr IN '(' select_stmt ')' { emit("INSELECT"); }
| expr NOT IN '(' select_stmt ')' { emit("INSELECT"); emit("NOT"); }
| EXISTS '(' select_stmt ')' { emit("EXISTS"); if($1)emit("NOT"); }
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: NAME '(' opt_val_list ')' { emit("CALL %d %s", $3, $1); free($1); }
@ -953,12 +953,12 @@ case_list: WHEN expr THEN expr { $$ = 1; }
| case_list WHEN expr THEN expr { $$ = $1+1; }
;
expr: expr LIKE expr { emit("LIKE"); }
| expr NOT LIKE expr { emit("LIKE"); emit("NOT"); }
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 REGEXP expr { emit("REGEXP"); }
| expr NOT REGEXP expr { emit("REGEXP"); emit("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: CURRENT_TIMESTAMP { emit("NOW") };