15 let def_param_name name (id,t) =
18 | Next | Numbered _ -> name
26 %token <string> IDENT TEXT BLOB
27 %token <Stmt.param_id> PARAM
28 %token <Sql.Type.t option> FUNCTION
29 %token LPAREN RPAREN COMMA EOF DOT NULL
31 %token SELECT INSERT OR INTO CREATE UPDATE TABLE VALUES WHERE ASTERISK DISTINCT ALL
32 LIMIT ORDER BY DESC ASC EQUAL DELETE FROM DEFAULT OFFSET SET JOIN LIKE_OP
33 EXCL TILDE NOT TEST_NULL BETWEEN AND ESCAPE USING COMPOUND_OP AS
34 CONCAT_OP JOIN_TYPE1 JOIN_TYPE2 NATURAL REPLACE
35 %token UNIQUE PRIMARY KEY AUTOINCREMENT ON CONFLICT
36 %token NUM_BINARY_OP PLUS MINUS
37 %token T_INTEGER T_BLOB T_TEXT
41 %nonassoc NUM_BINARY_OP
45 %type <Syntax.expr> expr
47 %start <RA.Scheme.t * Stmt.params * Stmt.kind> input
51 input: statement EOF { $1 } ;
53 statement: CREATE TABLE name=IDENT LPAREN scheme=column_defs RPAREN
54 { let () = Tables.add (name,scheme) in ([],[],Create name) }
55 | CREATE TABLE name=IDENT AS select=select_stmt
62 { let (s,p) = $1 in s,p,Select }
63 | insert_cmd table=IDENT cols=columns_list? VALUES
65 let s = Tables.get_scheme table in
66 let s = match cols with
67 | Some cols -> RA.Scheme.project cols s
70 let p = Syntax.scheme_as_params s in
73 | update_cmd table=IDENT SET assignments=separated_nonempty_list(COMMA,set_column) w=where?
75 let t = Tables.get table in
76 let p2 = get_params_opt [t] w in
77 let (cols,exprs) = List.split assignments in
78 let _ = RA.Scheme.project cols (snd t) in (* validates columns *)
79 let p1 = Syntax.get_params_l [t] exprs in
80 [], p1 @ p2, Update table
82 | DELETE FROM table=IDENT w=where?
84 let p = get_params_opt [Tables.get table] w in
88 columns_list: LPAREN cols=separated_nonempty_list(COMMA,IDENT) RPAREN { cols }
90 select_stmt: select_core list(preceded(COMPOUND_OP,select_core)) o=loption(order) p4=loption(limit)
91 { let (s1,p1,tbls) = $1 in
92 let (s2,p2) = List.split (List.map (fun (s,p,_) -> s,p) $2) in (* ignore tables in compound statements - they cannot be used in ORDER BY *)
93 let p3 = Syntax.get_params_l tbls o in
94 List.fold_left RA.Scheme.compound s1 s2,(p1@(List.flatten p2)@p3@p4) }
96 select_core: SELECT select_type? r=separated_nonempty_list(COMMA,column1)
101 let p1 = Syntax.params_of_columns tbls r in
102 let p3 = Syntax.get_params_opt tbls w in
103 (Syntax.get_scheme r tbls, p1 @ p2 @ p3, tbls)
106 table_list: source join_source*
108 let (s,p) = List.split $2 in
109 (fst $1::s, List.flatten (snd $1::p))
111 join_source: join_op s=source p=loption(join_args)
113 (* FIXME more tables in scope *)
114 (fst s,snd s @ Syntax.get_params_l [fst s] p)
116 source1: IDENT { Tables.get $1,[] }
117 | LPAREN s=select_core RPAREN { let (s,p,_) = s in ("",s),p }
118 source: src=source1 alias=preceded(AS,IDENT)?
121 | Some name -> let ((n,s),p) = src in ((name,s),p)
124 join_op: COMMA | NATURAL? JOIN_TYPE1? JOIN_TYPE2? JOIN { } ;
125 join_args: ON e=expr { [e] }
126 | USING LPAREN l=separated_nonempty_list(COMMA,IDENT) RPAREN { List.map (fun name -> `Column (name,None)) l }
128 insert_cmd: INSERT OR CONFLICT_ALGO INTO | INSERT INTO | REPLACE INTO { }
130 update_cmd: UPDATE {}
131 | UPDATE OR CONFLICT_ALGO {} ;
133 select_type: DISTINCT | ALL { }
135 int_or_param: INTEGER { [] }
136 | PARAM { [($1,Some Sql.Type.Int)] }
138 limit: LIMIT p=int_or_param { p }
139 | LIMIT p1=int_or_param COMMA p2=int_or_param { p1 @ p2 }
140 | LIMIT p1=int_or_param OFFSET p2=int_or_param { p1 @ p2 }
142 order: ORDER BY l=separated_nonempty_list(COMMA,terminated(expr,order_type?)) { l }
143 order_type: DESC | ASC { }
145 where: WHERE e=expr { e }
148 | IDENT DOT ASTERISK { Syntax.AllOf $1 }
149 | ASTERISK { Syntax.All }
150 | expr maybe_as { let e = $1 in Syntax.Expr (e,$2) }
152 maybe_as: AS? name=IDENT { Some name }
155 column_defs: separated_nonempty_list(COMMA,column_def1) { $1 }
156 column_def1: IDENT sql_type column_def_extra* { RA.attr $1 $2 } ;
157 column_def_extra: PRIMARY KEY { Some Constraint.PrimaryKey }
158 | NOT NULL { Some Constraint.NotNull }
159 | UNIQUE { Some Constraint.Unique }
160 | AUTOINCREMENT { Some Constraint.Autoincrement }
161 | ON CONFLICT CONFLICT_ALGO { None } ;
162 | DEFAULT INTEGER { None }
164 set_column: name=IDENT EQUAL e=expr { name,e }
166 (* expr: expr1 { $1 >> Syntax.expr_to_string >> prerr_endline; $1 } *)
169 expr numeric_bin_op expr %prec PLUS { `Func ((Some Int),[$1;$3]) }
170 | expr boolean_bin_op expr %prec AND { `Func ((Some Int),[$1;$3]) }
171 | expr CONCAT_OP expr { `Func ((Some Text),[$1;$3]) }
172 (* | expr NOT? LIKE_OP expr (*escape?*) { Sub [$1;$4] } *)
173 (* | unary_op expr { $2 } *)
174 | LPAREN expr RPAREN { $2 }
175 | IDENT { `Column ($1,None) }
176 | t=IDENT DOT c=IDENT
177 | IDENT DOT t=IDENT DOT c=IDENT { `Column (c,Some t) }
178 | INTEGER { `Value Int }
179 (* | FLOAT { `Value Float } *)
180 | TEXT { `Value Text }
181 | BLOB { `Value Blob }
182 | PARAM { `Param ($1,None) }
183 | FUNCTION LPAREN func_params RPAREN { `Func ($1,$3) }
184 | expr TEST_NULL { $1 }
185 | expr BETWEEN expr AND expr { `Func ((Some Int),[$1;$3;$5]) }
187 expr_list: separated_nonempty_list(COMMA,expr) { $1 }
188 func_params: expr_list { $1 }
190 escape: ESCAPE expr { $2 }
191 numeric_bin_op: EQUAL | PLUS | MINUS | ASTERISK | NUM_BINARY_OP { }
192 boolean_bin_op: AND | OR { }
200 sql_type: T_INTEGER { Type.Int }
201 | T_BLOB { Type.Blob }
202 | T_TEXT { Type.Text } ;