sql_parser.mly

   1 /*
   2   Simple SQL parser
   3 */
   4
   5
   6 %{
   7   open Printf
   8   open Sql
   9   open ListMore
  10   open Stmt
  11   open Syntax
  12   open Operators
  13
  14   let def_param_name name (id,t) =
  15     let name =
  16     match id with
  17     | Next | Numbered _ -> name
  18     | Named x -> x
  19     in
  20     (Named name,t)
  21
  22 %}
  23
  24 %token <int> INTEGER
  25 %token <string> IDENT TEXT BLOB
  26 %token <Stmt.param_id> PARAM
  27 %token LPAREN RPAREN COMMA EOF DOT NULL
  28 %token CONFLICT_ALGO
  29 %token SELECT INSERT OR INTO CREATE_TABLE UPDATE TABLE VALUES WHERE FROM ASTERISK DISTINCT ALL
  30        LIMIT ORDER BY DESC ASC EQUAL DELETE_FROM DEFAULT OFFSET SET JOIN LIKE_OP
  31        EXCL TILDE NOT FUNCTION TEST_NULL BETWEEN AND ESCAPE USING COMPOUND_OP AS
  32        CONCAT_OP JOIN_TYPE1 JOIN_TYPE2 NATURAL REPLACE
  33 %token UNIQUE PRIMARY KEY AUTOINCREMENT ON CONFLICT
  34 %token NUM_BINARY_OP PLUS MINUS
  35 %token T_INTEGER T_BLOB T_TEXT
  36
  37 %type <Syntax.expr> expr
  38 %type <RA.Scheme.t * Stmt.params> select_core
  39
  40 %start <RA.Scheme.t * Stmt.params * Stmt.kind> input
  41
  42 %%
  43
  44 input: statement EOF { $1 } ;
  45
  46 statement: CREATE_TABLE name=IDENT LPAREN scheme=column_defs RPAREN
  47               { let () = Tables.add (name,scheme) in ([],[],Create name) }
  48          | select_stmt
  49               { let (s,p) = $1 in s,p,Select }
  50          | insert_cmd t=IDENT LPAREN cols=separated_nonempty_list(COMMA,IDENT) RPAREN VALUES
  51               { let p = RA.Scheme.project cols (Tables.get_scheme t) >> Syntax.scheme_as_params in
  52                 [],p,Insert t }
  53          | insert_cmd t=IDENT VALUES
  54               { let p = Tables.get_scheme t >> Syntax.scheme_as_params in
  55                 [],p,Insert t }
  56          | UPDATE table=IDENT SET assignments=separated_nonempty_list(COMMA,set_column) w=option(where)
  57               {
  58                 let p2 = get_params_opt w in
  59                 let (cols,exprs) = List.split assignments in
  60                 let _ = RA.Scheme.project cols (Tables.get_scheme table) in (* validates columns *)
  61                 let p1 = Syntax.get_params_l exprs in
  62                 [], p1 @ p2, Update table
  63               }
  64          /*| DELETE_FROM IDENT maybe_where
  65               { Raw.Delete, $2, List.filter_valid [$3] }*/ ;
  66
  67 select_stmt: select_core list(preceded(COMPOUND_OP,select_core)) o=loption(order) p4=loption(limit)
  68               { let (s1,p1) = $1
  69                 and (s2,p2) = List.split $2
  70                 and p3 = Syntax.get_params_l o
  71                 in
  72                 List.fold_left RA.Scheme.compound s1 s2,(p1@(List.flatten p2)@p3@p4) }
  73
  74 select_core: SELECT select_type? r=separated_nonempty_list(COMMA,column1)
  75              FROM t=table_list
  76              w=option(where)
  77               {
  78                 let p1 = Syntax.params_of_columns r in
  79                 let p3 = Syntax.get_params_opt w in
  80                 let (tbls,p2) = t in
  81                 (Syntax.get_scheme r tbls, p1 @ p2 @ p3)
  82               }
  83
  84 table_list: source join_source* { let (s,p) = List.split $2 in (fst $1::s, List.flatten (snd $1::p)) }
  85 join_source: join_op s=source p=loption(join_args) { (fst s,snd s @ Syntax.get_params_l p) }
  86 source: IDENT { Tables.get $1,[] }
  87       | LPAREN s=select_core RPAREN { let (s,p) = s in ("",s),p }
  88 join_op: COMMA | NATURAL? JOIN_TYPE1? JOIN_TYPE2? JOIN { } ;
  89 join_args: ON e=expr { [e] }
  90          | USING LPAREN l=separated_nonempty_list(COMMA,IDENT) RPAREN { List.map (fun name -> Column (name,None)) l }
  91
  92 insert_cmd: INSERT OR CONFLICT_ALGO INTO | INSERT INTO | REPLACE INTO { }
  93
  94 update_cmd: UPDATE {}
  95           | UPDATE OR CONFLICT_ALGO {} ;
  96
  97 select_type: DISTINCT | ALL { }
  98
  99 int_or_param: INTEGER { [] }
 100             | PARAM { [($1,Some Sql.Type.Int)] }
 101
 102 limit: LIMIT p=int_or_param { p }
 103      | LIMIT p1=int_or_param COMMA p2=int_or_param { p1 @ p2 }
 104      | LIMIT p1=int_or_param OFFSET p2=int_or_param { p1 @ p2 }
 105
 106 order: ORDER BY l=separated_nonempty_list(COMMA,terminated(expr,order_type?)) { l }
 107 order_type: DESC | ASC { }
 108
 109 where: WHERE e=expr { e }
 110
 111 column1:
 112        | IDENT DOT ASTERISK { Syntax.AllOf $1 }
 113        | ASTERISK { Syntax.All }
 114        | expr maybe_as { let e = $1 in Syntax.Expr (e,$2) }
 115
 116 maybe_as: option(AS) name=IDENT { Some name }
 117         | { None }
 118
 119 column_defs: separated_nonempty_list(COMMA,column_def1) { $1 }
 120 column_def1: IDENT sql_type column_def_extra* { RA.attr $1 $2 } ;
 121 column_def_extra: PRIMARY KEY { Some Constraint.PrimaryKey }
 122                 | NOT NULL { Some Constraint.NotNull }
 123                 | UNIQUE { Some Constraint.Unique }
 124                 | AUTOINCREMENT { Some Constraint.Autoincrement }
 125                 | ON CONFLICT CONFLICT_ALGO { None } ;
 126                 | DEFAULT INTEGER { None }
 127
 128 set_column: name=IDENT EQUAL e=expr { name,e }
 129
 130 (* expr: expr1 { $1 >> Syntax.expr_to_string >> prerr_endline; $1 } *)
 131
 132 expr:
 133       expr binary_op expr { Sub [$1;$3] }
 134 (*     | expr NOT? LIKE_OP expr loption(escape) { $1 @ $3 @ $4 } *)
 135 (*     | unary_op expr { $2 } *)
 136     | LPAREN expr RPAREN { $2 }
 137     | IDENT { Column ($1,None) }
 138     | t=IDENT DOT c=IDENT
 139     | IDENT DOT t=IDENT DOT c=IDENT { Column (c,Some t) }
 140     | INTEGER { Value Sql.Type.Int }
 141     | TEXT { Value Sql.Type.Text }
 142     | BLOB { Value Sql.Type.Blob }
 143     | PARAM { Param ($1,None) }
 144     | FUNCTION LPAREN func_params RPAREN { Sub $3 }
 145 (*     | expr TEST_NULL { $1 } *)
 146 (*     | expr BETWEEN expr AND expr { $1 @ $3 @ $5 } *)
 147
 148 expr_list: separated_nonempty_list(COMMA,expr) { $1 }
 149 func_params: expr_list { $1 }
 150            | ASTERISK { [] } ;
 151 escape: ESCAPE expr { $2 }
 152 binary_op: EQUAL | PLUS | MINUS | ASTERISK | AND | OR | NUM_BINARY_OP | CONCAT_OP { }
 153
 154 unary_op: EXCL { }
 155         | PLUS { }
 156         | MINUS { }
 157         | TILDE { }
 158         | NOT { } ;
 159
 160 sql_type: T_INTEGER  { Type.Int }
 161         | T_BLOB { Type.Blob }
 162         | T_TEXT { Type.Text } ;
 163