16 | x, `Param (None,pos) -> Some ((Some (match x with `Limit -> "limit" | `Offset -> "offset"),pos),Int)
17 | _, `Param p -> Some (p,Int)
19 List.filter_map param l, List.mem (`Limit,`Const 1) l
21 let poly ret args = Fun (F (Typ ret, List.map (fun _ -> Var 0) args), args)
25 %token <string> IDENT TEXT BLOB
27 %token <Sql.param_id> PARAM
28 %token LPAREN RPAREN COMMA EOF DOT NULL
30 %token SELECT INSERT OR INTO CREATE UPDATE VIEW TABLE VALUES WHERE ASTERISK DISTINCT ALL ANY SOME
31 LIMIT ORDER BY DESC ASC EQUAL DELETE FROM DEFAULT OFFSET SET JOIN LIKE_OP LIKE
32 EXCL TILDE NOT BETWEEN AND ESCAPE USING UNION EXCEPT INTERSECT AS
33 CONCAT_OP JOIN_TYPE1 JOIN_TYPE2 NATURAL CROSS REPLACE IN GROUP HAVING
34 UNIQUE PRIMARY KEY FOREIGN AUTOINCREMENT ON CONFLICT TEMPORARY IF EXISTS
35 PRECISION UNSIGNED ZEROFILL VARYING CHARSET NATIONAL ASCII UNICODE COLLATE BINARY CHARACTER
36 DATETIME_FUNC DATE TIME TIMESTAMP ALTER ADD COLUMN CASCADE RESTRICT DROP
37 GLOBAL LOCAL VALUE REFERENCES CHECK CONSTRAINT IGNORED AFTER INDEX FULLTEXT FIRST
38 CASE WHEN THEN ELSE END CHANGE MODIFY DELAYED ENUM FOR SHARE MODE LOCK
39 OF WITH NOWAIT ACTION NO IS INTERVAL
40 %token FUNCTION PROCEDURE LANGUAGE RETURNS OUT INOUT BEGIN COMMENT
41 %token MICROSECOND SECOND MINUTE HOUR DAY WEEK MONTH QUARTER YEAR
42 SECOND_MICROSECOND MINUTE_MICROSECOND MINUTE_SECOND
43 HOUR_MICROSECOND HOUR_SECOND HOUR_MINUTE
44 DAY_MICROSECOND DAY_SECOND DAY_MINUTE DAY_HOUR
45 YEAR_MONTH FALSE TRUE DUPLICATE
46 %token NUM_DIV_OP NUM_BIT_OP NUM_EQ_OP NUM_CMP_OP PLUS MINUS NOT_DISTINCT_OP
47 %token T_INTEGER T_BLOB T_TEXT T_FLOAT T_BOOLEAN T_DATETIME T_UUID
53 (* FIXME precedence of COMMA and JOIN *)
57 %nonassoc EQUAL NUM_EQ_OP NOT_DISTINCT_OP
61 %left ASTERISK NUM_DIV_OP
67 %start <Sql.stmt> input
71 input: statement EOF { $1 }
73 if_not_exists: IF NOT EXISTS { }
74 if_exists: IF EXISTS {}
75 temporary: either(GLOBAL,LOCAL)? TEMPORARY { }
77 statement: CREATE ioption(temporary) TABLE ioption(if_not_exists) name=IDENT schema=table_definition
79 Create (name,`Schema schema)
81 | CREATE either(TABLE,VIEW) name=IDENT AS select=maybe_parenth(select_stmt)
83 Create (name,`Select select)
85 | ALTER TABLE name=table_name actions=commas(alter_action)
89 | DROP TABLE if_exists? name=IDENT
93 | CREATE UNIQUE? INDEX if_not_exists? name=table_name ON table=table_name cols=sequence(index_column)
95 CreateIndex (name, table, cols)
97 | select_stmt { Select $1 }
98 | insert_cmd target=IDENT names=sequence(IDENT)? VALUES values=commas(sequence(expr))? ss=on_duplicate?
100 Insert { target; action=`Values (names, values); on_duplicate=ss; }
102 | insert_cmd target=IDENT names=sequence(IDENT)? select=maybe_parenth(select_stmt) ss=on_duplicate?
104 Insert { target; action=`Select (names, select); on_duplicate=ss; }
106 | insert_cmd target=IDENT SET set=commas(set_column)? ss=on_duplicate?
108 Insert { target; action=`Set set; on_duplicate=ss; }
110 | update_cmd table=IDENT SET ss=commas(set_column) w=where? o=loption(order) lim=loption(limit)
112 Update (table,ss,w,o,lim)
114 /* http://dev.mysql.com/doc/refman/5.1/en/update.html multi-table syntax */
115 | update_cmd tables=commas(source) SET ss=commas(set_column) w=where?
117 UpdateMulti (tables,ss,w)
119 | DELETE FROM table=IDENT w=where?
123 | SET name=IDENT EQUAL e=expr
127 | CREATE or_replace? FUNCTION name=IDENT params=sequence(func_parameter)
133 Function.add (List.length params) (Ret ret) name;
134 CreateRoutine (name, Some ret, params)
136 | CREATE or_replace? PROCEDURE name=IDENT params=sequence(proc_parameter)
141 Function.add (List.length params) (Ret Any) name; (* FIXME void *)
142 CreateRoutine (name, None, params)
145 parameter_default_: DEFAULT | EQUAL { }
146 parameter_default: parameter_default_ e=expr { e }
147 func_parameter: n=IDENT AS? t=sql_type e=parameter_default? { (n,t,e) }
148 parameter_mode: IN | OUT | INOUT { }
149 proc_parameter: parameter_mode? p=func_parameter { p }
151 or_replace: OR REPLACE { }
153 routine_body: TEXT | compound_stmt { }
154 compound_stmt: BEGIN statement+ END { } (* mysql *)
156 routine_extra: LANGUAGE IDENT { }
159 table_name: name=IDENT | IDENT DOT name=IDENT { name } (* FIXME db name *)
160 index_prefix: LPAREN n=INTEGER RPAREN { n }
161 index_column: name=IDENT index_prefix? collate? order_type? { name }
163 table_definition: t=sequence_(column_def1) table_def_done { List.filter_map (function `Attr a -> Some a | `Constraint _ | `Index _ -> None) t }
164 | LIKE name=maybe_parenth(IDENT) { Tables.get name |> snd } (* mysql *)
166 (* ugly, can you fixme? *)
167 (* ignoring everything after RPAREN (NB one look-ahead token) *)
168 table_def_done: table_def_done1 RPAREN IGNORED* { Parser_state.mode_normal () }
169 table_def_done1: { Parser_state.mode_ignore () }
171 select_stmt: select_core other=list(preceded(compound_op,select_core)) o=loption(order) lim=limit_t? select_row_locking?
173 { select = ($1, other); order=o; limit=lim; }
176 select_core: SELECT select_type? r=commas(column1) f=from? w=where? g=loption(group) h=having?
178 { columns=r; from=f; where=w; group=g; having=h; }
181 table_list: src=source joins=join_source* { (src,joins) }
183 join_source: NATURAL maybe_join_type JOIN src=source { src,`Natural }
184 | CROSS JOIN src=source { src,`Cross }
185 | qualified_join src=source cond=join_cond { src,cond }
187 qualified_join: COMMA | maybe_join_type JOIN { }
189 join_cond: ON e=expr { `Search e }
190 | USING l=sequence(IDENT) { `Using l }
193 source1: IDENT { `Table $1 }
194 | LPAREN s=select_core RPAREN { `Select s }
196 source: src=source1 alias=maybe_as { src, alias }
198 insert_cmd: INSERT DELAYED? OR? conflict_algo INTO | INSERT INTO | REPLACE INTO { }
199 update_cmd: UPDATE | UPDATE OR conflict_algo { }
200 conflict_algo: CONFLICT_ALGO | REPLACE { }
201 on_duplicate: ON DUPLICATE KEY UPDATE ss=commas(set_column) { ss }
203 select_type: DISTINCT | ALL { }
212 FOR either(UPDATE, SHARE) update_or_share_of? NOWAIT? with_lock? { }
214 update_or_share_of: OF commas(IDENT) { }
216 with_lock: WITH LOCK { }
218 int_or_param: i=INTEGER { `Const i }
219 | p=PARAM { `Param p }
221 limit_t: LIMIT lim=int_or_param { make_limit [`Limit,lim] }
222 | LIMIT ofs=int_or_param COMMA lim=int_or_param { make_limit [`Offset,ofs; `Limit,lim] }
223 | LIMIT lim=int_or_param OFFSET ofs=int_or_param { make_limit [`Limit,lim; `Offset,ofs] }
225 limit: limit_t { fst $1 }
227 order: ORDER BY l=commas(terminated(expr,order_type?)) { l }
228 order_type: DESC | ASC { }
230 from: FROM t=table_list { t }
231 where: WHERE e=expr { e }
232 group: GROUP BY l=expr_list { l }
233 having: HAVING e=expr { e }
236 | IDENT DOT ASTERISK { Sql.AllOf $1 }
237 | ASTERISK { Sql.All }
238 | e=expr m=maybe_as { Sql.Expr (e,m) }
240 maybe_as: AS? name=IDENT { Some name }
243 maybe_parenth(X): x=X | LPAREN x=X RPAREN { x }
245 alter_action: ADD COLUMN? col=maybe_parenth(column_def) pos=alter_pos { `Add (col,pos) }
246 | ADD index_type IDENT? sequence(IDENT) { `None }
247 | DROP INDEX IDENT { `None }
248 | DROP PRIMARY KEY { `None }
249 | DROP COLUMN? col=IDENT drop_behavior? { `Drop col } (* FIXME behavior? *)
250 | CHANGE COLUMN? old_name=IDENT column=column_def pos=alter_pos { `Change (old_name,column,pos) }
251 | MODIFY COLUMN? column=column_def pos=alter_pos { `Change (column.name,column,pos) }
252 | SET IDENT IDENT { `None }
253 index_type: INDEX | FULLTEXT | PRIMARY KEY { }
254 alter_pos: AFTER col=IDENT { `After col }
257 drop_behavior: CASCADE | RESTRICT { }
259 column_def: name=IDENT t=sql_type? column_def_extra*
260 { attr name (match t with Some x -> x | None -> Int) }
262 column_def1: c=column_def { `Attr c }
263 | pair(CONSTRAINT,IDENT)? c=table_constraint_1 { `Constraint c }
264 | INDEX cols=sequence(index_column) { `Index cols }
266 on_conflict: ON CONFLICT algo=conflict_algo { algo }
267 column_def_extra: PRIMARY KEY { Some PrimaryKey }
268 | NOT NULL { Some NotNull }
270 | UNIQUE { Some Unique }
271 | AUTOINCREMENT { Some Autoincrement }
272 | on_conflict { None }
273 | CHECK LPAREN expr RPAREN { None }
274 | DEFAULT default_value { None } (* FIXME check type with column *)
275 | COLLATE IDENT { None }
277 default_value: single_literal_value | datetime_value { } (* sub expr ? *)
279 (* FIXME check columns *)
281 | some_key IDENT? key_arg { [] }
282 | FOREIGN KEY IDENT? sequence(IDENT) REFERENCES IDENT sequence(IDENT)?
283 reference_action_clause*
285 | CHECK LPAREN expr RPAREN { [] }
287 reference_action_clause:
288 ON either(DELETE, UPDATE) reference_action { }
291 RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT { }
293 some_key: UNIQUE KEY? | PRIMARY? KEY | FULLTEXT KEY { }
294 key_arg: LPAREN VALUE RPAREN | sequence(IDENT) { }
296 set_column: name=attr_name EQUAL e=expr { name,e }
298 anyall: ANY | ALL | SOME { }
300 mnot(X): NOT x = X | x = X { x }
302 attr_name: cname=IDENT { { cname; tname=None} }
303 | table=IDENT DOT cname=IDENT
304 | IDENT DOT table=IDENT DOT cname=IDENT { {cname; tname=Some table} } (* FIXME database identifier *)
306 distinct_from: DISTINCT FROM { }
309 expr numeric_bin_op expr %prec PLUS { Fun ((Ret Any),[$1;$3]) } (* TODO default Int *)
310 | expr boolean_bin_op expr %prec AND { Fun ((fixed Bool [Bool;Bool]),[$1;$3]) }
311 | e1=expr comparison_op anyall? e2=expr %prec EQUAL { poly Bool [e1;e2] }
312 | expr CONCAT_OP expr { Fun ((fixed Text [Text;Text]),[$1;$3]) }
313 | e1=expr mnot(like) e2=expr e3=escape?
316 | None -> Fun ((fixed Bool [Text; Text]), [e1;e2])
317 | Some e3 -> Fun ((fixed Bool [Text; Text; Text]), [e1;e2;e3])
319 | unary_op expr { $2 }
320 | MINUS expr %prec UNARY_MINUS { $2 }
321 | INTERVAL expr interval_unit { Fun (fixed Datetime [Int], [$2]) }
322 | LPAREN expr RPAREN { $2 }
323 | attr_name { Column $1 }
324 | VALUES LPAREN n=IDENT RPAREN { Inserted n }
325 | v=literal_value | v=datetime_value { v }
326 | e1=expr mnot(IN) l=sequence(expr) { poly Bool (e1::l) }
327 | e1=expr mnot(IN) LPAREN select=select_stmt RPAREN { poly Bool [e1; Select (select, `AsValue)] }
328 | e1=expr IN table=IDENT { Tables.check table; e1 }
329 | LPAREN select=select_stmt RPAREN { Select (select, `AsValue) }
330 | PARAM { Param ($1,Any) }
331 | f=IDENT LPAREN p=func_params RPAREN { Fun (Function.lookup f (List.length p), p) }
332 | expr IS NOT? NULL { Fun (Ret Bool, [$1]) }
333 | e1=expr IS NOT? distinct_from? e2=expr { poly Bool [e1;e2] }
334 | expr mnot(BETWEEN) expr AND expr { poly Bool [$1;$3;$5] }
335 | mnot(EXISTS) LPAREN select=select_stmt RPAREN { Fun (F (Typ Bool, [Typ Any]),[Select (select,`Exists)]) }
336 | CASE e1=expr? branches=nonempty_list(case_branch) e2=preceded(ELSE,expr)? END (* FIXME typing *)
338 let maybe f = function None -> [] | Some x -> [f x] in
341 | None -> (List.flatten @@ List.map (fun _ -> [Typ Bool; Var 1]) branches)
342 | Some _ -> [Var 0] @ (List.flatten @@ List.map (fun _ -> [Var 0; Var 1]) branches)
344 let t_args = t_args @ maybe (fun _ -> Var 1) e2 in
345 let v_args = maybe Prelude.identity e1 @ List.flatten branches @ maybe Prelude.identity e2 in
346 Fun (F (Var 1, t_args), v_args)
348 | IF LPAREN e1=expr COMMA e2=expr COMMA e3=expr RPAREN { Fun (F (Var 0, [Typ Bool;Var 0;Var 0]), [e1;e2;e3]) }
350 case_branch: WHEN e1=expr THEN e2=expr { [e1;e2] }
351 like: LIKE | LIKE_OP { }
353 datetime_value: | DATETIME_FUNC | DATETIME_FUNC LPAREN INTEGER? RPAREN { Value Datetime }
356 | TEXT { Value Text }
357 | BLOB { Value Blob }
358 | INTEGER { Value Int }
359 | FLOAT { Value Float }
361 | FALSE { Value Bool }
364 | TIMESTAMP TEXT { Value Datetime }
365 | NULL { Value Any } (* he he *)
367 single_literal_value:
368 | literal_value { $1 }
369 | MINUS INTEGER { Value Int }
370 | MINUS FLOAT { Value Float }
372 expr_list: l=commas(expr) { l }
373 func_params: DISTINCT? l=expr_list { l }
376 escape: ESCAPE expr { $2 }
377 numeric_bin_op: PLUS | MINUS | ASTERISK | NUM_DIV_OP | NUM_BIT_OP { }
378 comparison_op: EQUAL | NUM_CMP_OP | NUM_EQ_OP | NOT_DISTINCT_OP { }
379 boolean_bin_op: AND | OR { }
385 interval_unit: MICROSECOND | SECOND | MINUTE | HOUR | DAY | WEEK | MONTH | QUARTER | YEAR
386 | SECOND_MICROSECOND | MINUTE_MICROSECOND | MINUTE_SECOND
387 | HOUR_MICROSECOND | HOUR_SECOND | HOUR_MINUTE
388 | DAY_MICROSECOND | DAY_SECOND | DAY_MINUTE | DAY_HOUR
391 sql_type_flavor: T_INTEGER UNSIGNED? ZEROFILL? { Int }
393 | NATIONAL? text VARYING? charset? collate? { Text }
394 | ENUM sequence(TEXT) charset? collate? { Text }
395 | T_FLOAT PRECISION? { Float }
397 | T_DATETIME | YEAR | DATE | TIME | TIMESTAMP { Datetime }
400 binary: T_BLOB | BINARY | BINARY VARYING { }
401 text: T_TEXT | T_TEXT LPAREN INTEGER RPAREN | CHARACTER { }
403 %inline either(X,Y): X | Y { }
404 %inline commas(X): l=separated_nonempty_list(COMMA,X) { l }
406 %inline sequence_(X): LPAREN l=commas(X) { l }
407 %inline sequence(X): l=sequence_(X) RPAREN { l }
409 charset: CHARSET either(IDENT,BINARY) | CHARACTER SET either(IDENT,BINARY) | ASCII | UNICODE { }
410 collate: COLLATE IDENT { }
412 sql_type: t=sql_type_flavor
413 | t=sql_type_flavor LPAREN INTEGER RPAREN UNSIGNED?
414 | t=sql_type_flavor LPAREN INTEGER COMMA INTEGER RPAREN
417 compound_op: UNION ALL? | EXCEPT | INTERSECT { }
419 maybe_join_type: JOIN_TYPE1? JOIN_TYPE2? { }