sql_parser.mly

   1 /*
   2   Simple SQL parser
   3 */
   4
   5
   6 %{
   7   open Printf
   8   open Sql
   9   open Sql.Type
  10   open ListMore
  11   open Stmt
  12   open Syntax
  13   open Operators
  14
  15   let def_param_name name (id,t) =
  16     let name =
  17     match id with
  18     | Next | Numbered _ -> name
  19     | Named x -> x
  20     in
  21     (Named name,t)
  22
  23   let select_value select =
  24     let (s,p) = select in
  25     if (List.length s <> 1) then
  26       raise (RA.Scheme.Error (s,"only one column allowed for SELECT operator in this expression"));
  27     List.map (fun x -> `Param x) p
  28
  29 %}
  30
  31 %token <int> INTEGER
  32 %token <string> IDENT TEXT BLOB
  33 %token <Stmt.param_id> PARAM
  34 %token <Sql.Type.t option> FUNCTION
  35 %token LPAREN RPAREN COMMA EOF DOT NULL
  36 %token CONFLICT_ALGO
  37 %token SELECT INSERT OR INTO CREATE UPDATE TABLE VALUES WHERE ASTERISK DISTINCT ALL
  38        LIMIT ORDER BY DESC ASC EQUAL DELETE FROM DEFAULT OFFSET SET JOIN LIKE_OP
  39        EXCL TILDE NOT TEST_NULL BETWEEN AND ESCAPE USING UNION EXCEPT INTERSECT AS
  40        CONCAT_OP JOIN_TYPE1 JOIN_TYPE2 NATURAL CROSS REPLACE IN GROUP HAVING
  41 %token UNIQUE PRIMARY KEY AUTOINCREMENT ON CONFLICT
  42 %token NUM_BINARY_OP PLUS MINUS
  43 %token T_INTEGER T_BLOB T_TEXT T_FLOAT T_BOOLEAN
  44
  45 (*
  46 %left COMMA_JOIN
  47 %left JOIN_JOIN
  48 *)
  49 (* FIXME precedence of COMMA and JOIN *)
  50
  51 %left TEST_NULL
  52 %left AND OR
  53 %nonassoc EQUAL
  54 %nonassoc NUM_BINARY_OP
  55 %left PLUS MINUS
  56 %left ASTERISK
  57
  58 %type <Syntax.expr> expr
  59
  60 %start <RA.Scheme.t * Stmt.params * Stmt.kind> input
  61
  62 %%
  63
  64 input: statement EOF { $1 } ;
  65
  66 statement: CREATE TABLE name=IDENT LPAREN scheme=column_defs RPAREN
  67               { let () = Tables.add (name,scheme) in ([],[],Create name) }
  68          | CREATE TABLE name=IDENT AS select=select_stmt
  69               {
  70                 let (s,p) = select in
  71                 Tables.add (name,s);
  72                 ([],p,Create name)
  73               }
  74          | select_stmt
  75               { let (s,p) = $1 in s,p,Select }
  76          | insert_cmd table=IDENT cols=columns_list? VALUES
  77               {
  78                 let s = Tables.get_scheme table in
  79                 let s = match cols with
  80                   | Some cols -> RA.Scheme.project cols s
  81                   | None -> s
  82                 in
  83                 let p = Syntax.scheme_as_params s in
  84                 [],p,Insert table
  85               }
  86          | update_cmd table=IDENT SET assignments=separated_nonempty_list(COMMA,set_column) w=where?
  87               {
  88                 let t = Tables.get table in
  89                 let p2 = get_params_opt [t] (snd t) w in
  90                 let (cols,exprs) = List.split assignments in
  91                 let _ = RA.Scheme.project cols (snd t) in (* validates columns *)
  92                 let p1 = Syntax.get_params_l [t] (snd t) exprs in
  93                 [], p1 @ p2, Update table
  94               }
  95          | DELETE FROM table=IDENT w=where?
  96               {
  97                 let t = Tables.get table in
  98                 let p = get_params_opt [t] (snd t) w in
  99                 [], p, Delete table
 100               }
 101
 102 columns_list: LPAREN cols=separated_nonempty_list(COMMA,IDENT) RPAREN { cols }
 103
 104 select_stmt: select_core list(preceded(compound_op,select_core)) o=loption(order) p4=loption(limit)
 105               {
 106                 let (s1,p1,tbls) = $1 in
 107                 let (s2l,p2l) = List.split (List.map (fun (s,p,_) -> s,p) $2) in
 108                 (* ignoring tables in compound statements - they cannot be used in ORDER BY *)
 109                 let scheme = List.fold_left RA.Scheme.compound s1 s2l in
 110                 let p3 = Syntax.get_params_l tbls scheme o in
 111 (*                 RA.Scheme.check_unique scheme; *)
 112                 scheme,(p1@(List.flatten p2l)@p3@p4)
 113               }
 114
 115 select_core: SELECT select_type? r=separated_nonempty_list(COMMA,column1)
 116              FROM t=table_list
 117              w=where?
 118              g=loption(group)
 119              h=having?
 120               {
 121                 let (tbls,p2,joined_scheme) = Syntax.join t in
 122                 let p1 = Syntax.params_of_columns tbls joined_scheme r in
 123                 let p3 = Syntax.get_params_opt tbls joined_scheme w in
 124                 let p4 = Syntax.get_params_l tbls joined_scheme g in
 125                 let p5 = Syntax.get_params_opt tbls joined_scheme h in
 126                 (Syntax.infer_scheme r tbls joined_scheme, p1 @ p2 @ p3 @ p4 @ p5, tbls)
 127               }
 128
 129 table_list: src=source joins=join_source* { (src,joins) }
 130
 131 join_source: NATURAL maybe_join_type JOIN src=source { src,`Natural }
 132            | CROSS JOIN src=source { src,`Cross }
 133            | qualified_join src=source cond=join_cond { src,cond }
 134
 135 qualified_join: COMMA | maybe_join_type JOIN { }
 136
 137 join_cond: ON e=expr { `Search e }
 138          | USING LPAREN l=separated_nonempty_list(COMMA,IDENT) RPAREN { `Using l }
 139          | (* *) { `Default }
 140
 141 source1: IDENT { Tables.get $1,[] }
 142        | LPAREN s=select_core RPAREN { let (s,p,_) = s in ("",s),p }
 143
 144 source: src=source1 alias=preceded(AS,IDENT)?
 145     {
 146       match alias with
 147       | Some name -> let ((n,s),p) = src in ((name,s),p)
 148       | None -> src
 149     }
 150
 151 insert_cmd: INSERT OR CONFLICT_ALGO INTO | INSERT INTO | REPLACE INTO { }
 152
 153 update_cmd: UPDATE {}
 154           | UPDATE OR CONFLICT_ALGO {} ;
 155
 156 select_type: DISTINCT | ALL { }
 157
 158 int_or_param: INTEGER { [] }
 159             | PARAM { [($1,Some Sql.Type.Int)] }
 160
 161 limit: LIMIT p=int_or_param { p }
 162      | LIMIT p1=int_or_param COMMA p2=int_or_param { p1 @ p2 }
 163      | LIMIT p1=int_or_param OFFSET p2=int_or_param { p1 @ p2 }
 164
 165 order: ORDER BY l=separated_nonempty_list(COMMA,terminated(expr,order_type?)) { l }
 166 order_type: DESC | ASC { }
 167
 168 where: WHERE e=expr { e }
 169 group: GROUP BY l=separated_nonempty_list(COMMA,expr) { l }
 170 having: HAVING e=expr { e }
 171
 172 column1:
 173        | IDENT DOT ASTERISK { Syntax.AllOf $1 }
 174        | ASTERISK { Syntax.All }
 175        | expr maybe_as { let e = $1 in Syntax.Expr (e,$2) }
 176
 177 maybe_as: AS? name=IDENT { Some name }
 178         | { None }
 179
 180 column_defs: separated_nonempty_list(COMMA,column_def1) { $1 }
 181 column_def1: name=IDENT t=sql_type? column_def_extra* { RA.attr name (match t with Some t -> t | None -> Type.Int) }
 182 column_def_extra: PRIMARY KEY { Some Constraint.PrimaryKey }
 183                 | NOT NULL { Some Constraint.NotNull }
 184                 | UNIQUE { Some Constraint.Unique }
 185                 | AUTOINCREMENT { Some Constraint.Autoincrement }
 186                 | ON CONFLICT CONFLICT_ALGO { None }
 187                 | DEFAULT INTEGER { None }
 188
 189 set_column: name=IDENT EQUAL e=expr { name,e }
 190
 191 (* expr: expr1 { $1 >> Syntax.expr_to_string >> prerr_endline; $1 } *)
 192
 193 mnot(X): NOT x = X | x = X { x }
 194
 195 expr:
 196      expr numeric_bin_op expr %prec PLUS { `Func ((Some Int),[$1;$3]) }
 197     | expr boolean_bin_op expr %prec AND { `Func ((Some Int),[$1;$3]) }
 198     | expr CONCAT_OP expr { `Func ((Some Text),[$1;$3]) }
 199     | e1=expr mnot(LIKE_OP) e2=expr e3=escape?
 200       { `Func (None,(List.filter_valid [Some e1; Some e2; e3])) }
 201     | unary_op expr { $2 }
 202     | LPAREN expr RPAREN { $2 }
 203     | IDENT { `Column ($1,None) }
 204     | t=IDENT DOT c=IDENT
 205     | IDENT DOT t=IDENT DOT c=IDENT { `Column (c,Some t) }
 206     | INTEGER { `Value Int }
 207     | e1=expr mnot(IN) LPAREN l=separated_nonempty_list(COMMA,expr) RPAREN { `Func (None,e1::l) }
 208     | e1=expr mnot(IN) LPAREN select=select_stmt RPAREN
 209       {
 210         `Func (None,e1::select_value select)
 211       }
 212     | e1=expr IN table=IDENT { Tables.check(table); e1 }
 213     | LPAREN select=select_stmt RPAREN
 214       {
 215         `Func (None,select_value select)
 216       }
 217 (*     | FLOAT { `Value Float } *)
 218     | TEXT { `Value Text }
 219     | BLOB { `Value Blob }
 220     | PARAM { `Param ($1,None) }
 221     | FUNCTION LPAREN func_params RPAREN { `Func ($1,$3) }
 222     | expr TEST_NULL { $1 }
 223     | expr BETWEEN expr AND expr { `Func ((Some Int),[$1;$3;$5]) }
 224
 225 expr_list: separated_nonempty_list(COMMA,expr) { $1 }
 226 func_params: expr_list { $1 }
 227            | ASTERISK { [] } ;
 228 escape: ESCAPE expr { $2 }
 229 numeric_bin_op: EQUAL | PLUS | MINUS | ASTERISK | NUM_BINARY_OP { }
 230 boolean_bin_op: AND | OR { }
 231
 232 unary_op: EXCL { }
 233         | PLUS { }
 234         | MINUS { }
 235         | TILDE { }
 236         | NOT { }
 237
 238 sql_type_flavor: T_INTEGER  { Type.Int }
 239                | T_BLOB { Type.Blob }
 240                | T_TEXT { Type.Text }
 241                | T_FLOAT { Type.Float }
 242                | T_BOOLEAN { Type.Bool }
 243
 244 sql_type: t=sql_type_flavor
 245         | t=sql_type_flavor LPAREN INTEGER RPAREN
 246         | t=sql_type_flavor LPAREN INTEGER COMMA INTEGER RPAREN
 247         { t }
 248
 249 compound_op: UNION ALL? | EXCEPT | INTERSECT { }
 250
 251 maybe_join_type: JOIN_TYPE1? JOIN_TYPE2? { }