Merge pull request #6 from bglid/feature/min-execution

Feature/min execution

Author: bglid

docs/roadmap.md

@@ -0,0 +1,18 @@
+# Roadmap
+
+ - A more detailed set of things to get done. Mainly for personal use/reference:
+    - *Note, this was created mid-way through so the first parts have been summarized to point 1 & 2*
+
+ |  #  | Step                                                    | Status |
+| :-: | ------------------------------------------------------- | :----: |
+|  1  | Basic REPL and interpreter setup                        |   Done   |
+|  2  | Disk-writing API                                        |   Done   |
+|  3  | Basic Top-level SQL Parsing                             |*in progress* |
+|  4  | Improve interpreter tests (meta prepare exec.)                                                    | *in progress* |
+|  5  | Minimal row format and execution                  | |
+|  6  | B+ leaf insertion, search and splitting           | |
+|  7  | B+ Tree sorted scan                               | |
+|  8  | B+ tree delete                                    |      |
+
+
+- - - 

lib/ast.ml lib/ast/ast.mllib/ast.ml renamed to lib/ast/ast.ml

@@ -12,12 +12,12 @@ type binop_t =
   | Comp
 [@@deriving show]
 
-type column_types =
-  | Int_col
-  | Float_col
-  | String_col
-  | Bool_col
-[@@deriving show]
+(* type column_types = *)
+(*   | Int_col *)
+(*   | Float_col *)
+(*   | String_col *)
+(*   | Bool_col *)
+(* [@@deriving show] *)
 
 (** Our Abstract Syntax Tree for interpreter, hooray! *)
 type expr =
@@ -28,26 +28,19 @@ type expr =
   | Binop of binop_t * expr * expr
 [@@deriving show]
 
+(*NOTE: MOVE TO OWN MODULE*)
 type create_t = {
   table_name : string;
-  columns : (string * column_types) list;
+  columns : string list;
 }
 [@@deriving show]
 (** Handles creating new tables *)
 
-type insert_t = {
-  table_name : string;
-  columns : string list option;
-  values : expr list;
-}
-[@@deriving show]
-(** Handles inserting into existing tables *)
-
 (** Statments like INSERT *)
 type statement =
   | Create of create_t
-  | Insert of insert_t
-  | Select of expr
+  | Insert of Insert.t
+  | Select of Select.t
   | Expr of expr
   | Unk_stmt of string
 [@@deriving show]

lib/ast/insert.ml

@@ -0,0 +1,29 @@
+(* abstraction to make a module for preparing and executing insert statement*)
+
+type t = {
+  table : Table.t;
+  fields : string list;
+  values : Constant.t list;
+}
+[@@deriving show]
+
+(* HACKY for now, new table each time *)
+let make (tablename : string) (fields : string list) (values : Constant.t list)
+    : t =
+  { table = Table.create_table ~id:777 ~table_name:tablename; fields; values }
+
+let execute_insert (preped_insert : t) : string =
+  (* let new_table = Table.add_row ~table:temp_table ~row:new_row in *)
+  let new_fields =
+    List.fold_left
+      (fun acc l ->
+        match l with
+        | Constant.ConstStr s -> acc ^ " " ^ s
+        | Constant.ConstInt d -> acc ^ " " ^ Int.to_string (Int32.to_int d))
+      "" preped_insert.values
+  in
+  (* new_fields *)
+  "Inserted" ^ new_fields ^ " into " ^ preped_insert.table.table_name
+
+(* Printf.printf "Inserted %d %s %s into Table %d" id stop_name rail_name *)
+(*   preped_insert.table.table_name *)

lib/ast/select.ml

@@ -0,0 +1,24 @@
+(* abstraction to make a module for preparing and executing select statement*)
+
+type t = {
+  fields : string list;
+  table : Table.t;
+}
+[@@deriving show]
+
+(* HACKY for now, new table each time *)
+let make (fields : string list) (tablename : string) : t =
+  { table = Table.create_table ~id:777 ~table_name:tablename; fields }
+
+let execute_select (preped_select : t) : string =
+  let selected_fields =
+    List.fold_left
+      (fun acc l ->
+        match l with
+        | "id" -> acc ^ " 1"
+        | "stop_name" -> acc ^ "englewood"
+        | "rail_line" -> acc ^ " G"
+        | _ -> "not a valid field in the table")
+      "" preped_select.fields
+  in
+  selected_fields

lib/ast/table.ml

@@ -0,0 +1,55 @@
+(* Starting with a minimal row struct *)
+type row_t = {
+  id : int;
+  stop_name : string;
+  rail_line : string;
+}
+[@@deriving show]
+
+(* probably need to adjust this*)
+type t = {
+  table_id : int;
+  table_name : string;
+  table_fields : string list;
+  rows : row_t list;
+}
+[@@deriving show]
+
+let make_row ~id ~stop_name ~rail_line : row_t = { id; stop_name; rail_line }
+
+let create_table ~(id : int) ~(table_name : string) : t =
+  { table_id = id; table_name; table_fields = []; rows = [] }
+
+(* let open_table ~(table_name : string) : t = *)
+(*   match table_name with *)
+(*     |  *)
+
+let already_in_table ~(table : t) ~(row : row_t) : bool =
+  (* List.mem row table.rows *)
+  let rec search (table_rows : row_t list) (id : int) : bool =
+    match table_rows with
+    | [] -> false
+    | h :: tail ->
+        if h.id = id then
+          true
+        else
+          search tail id
+  in
+  search table.rows row.id
+
+(* currently this is a bit functional in it's nature
+   always returning a new table rather than adjusting the existing one.
+   May want to consider changing rows to be mutable, or need to consider disk 
+   writes here - TBD *)
+let add_row ~(table : t) ~(row : row_t) : t =
+  if already_in_table ~table ~row then
+    table
+  else
+    (* let new_row_list = List.fold_left (fun acc l -> acc :: l) table.rows [row] in *)
+    let new_row_list = table.rows @ [ row ] in
+    {
+      table_id = table.table_id;
+      table_name = table.table_name;
+      table_fields = table.table_fields;
+      rows = new_row_list;
+    }

lib/constant.ml

@@ -0,0 +1,10 @@
+(** Used to represent non AST plain values in SQL queries. More of help than
+    anything*)
+
+type t =
+  | ConstInt of Int32.t
+  | ConstStr of string
+[@@deriving show]
+
+let make_int (i32 : Int32.t) : t = ConstInt i32
+let make_string (str : string) : t = ConstStr str

lib/interpreter.ml

@@ -124,10 +124,10 @@ let execute_statement stmt : execution_t =
   (* Need to improve this once the B+ is implemented *)
   match stmt with
   | Ast.Create _ -> Ok
-  | Ast.Insert _ -> Ok
-  | Ast.Select e -> Message (e |> eval |> string_of_val)
+  | Ast.Insert i -> Message (Insert.execute_insert i)
+  | Ast.Select s -> Message (Select.execute_select s)
   | Ast.Expr e -> Message (e |> eval |> string_of_val)
-  | Ast.Unk_stmt _ -> Message "unk statment: Failure"
+  | Ast.Unk_stmt u -> Message u
 
 (** [interpret input] interprets [input] by lexing + parsing it into a toplevel,
     evaluating it, and converting it to a string*)

lib/lexer.mll

@@ -1,5 +1,6 @@
 {
   open Parser
+  exception Lexing_error of string
   let meta_cmds = Hashtbl.create 20
   let () = 
     List.iter (fun (strcmd, mcmd) -> Hashtbl.add meta_cmds strcmd mcmd)
@@ -14,6 +15,9 @@
       [
       "INSERT", INSERT;
       "SELECT", SELECT;
+      "INTO", INTO;
+      "VALUES", VALUES;
+      "FROM", FROM;
     ]
 }
 
@@ -23,7 +27,8 @@ let frac = '.'digit*
 let float = digit* frac?
 let white = [' ' '\t']+
 let meta_command = ['.']['a'-'z' 'A'-'Z' '_']+
-let statement = ['a'-'z' 'A'-'Z' '_']+
+let statement = ['A'-'Z' '_']['A'-'Z' '_']+
+let id = ['A'-'Z' 'a'-'z'  '_' ]['a'-'z'  '_' '0'-'9']*
 let newline = '\r' | '\n' | "\r\n"
 
 
@@ -42,25 +47,31 @@ rule read =
     | "FALSE" { FALSE }
     | "=="    { STRUCT_COMP }
     | "<>"    { NEQ }
-    | "<"     { LT }
-    | ">"     { GT }
     | "<="    { LEQ }
     | ">="    { GEQ }
-    | ";;"    { ENTER }
+    | "<"     { LT }
+    | ">"     { GT }
+    | ","     { COMMA }
     | white   { read lexbuf}
     | int     { INT (int_of_string(Lexing.lexeme lexbuf))}
     | float   { FLOAT (float_of_string(Lexing.lexeme lexbuf))}
     | meta_command as md
         {try Hashtbl.find meta_cmds md 
-          with Not_found -> IDENTIFIER md}
+          with Not_found -> UNK_COM md}
     | statement as s
-        {try Hashtbl.find stmts (String.uppercase_ascii s)
-          with Not_found -> IDENTIFIER s}
+        {try Hashtbl.find stmts s
+    with Not_found -> UNK_COM s}
+    | id as s { IDENTIFIER s }
     | newline { Lexing.new_line lexbuf; read lexbuf }
+    | "'"     { read_string (Buffer.create 16) lexbuf}
     | eof     { EOF }
-    (* | _ { raise (Failure ("Char not allowed in text: " ^Lexing.lexeme lexbuf^)} *)
+    | _       { raise (Lexing_error ("bad char, error"))}
 and comment = 
   parse
     | newline { Lexing.new_line lexbuf; read lexbuf}
     | eof { EOF }
     | _ { comment lexbuf }
+and read_string buff = parse
+  | "'"       { STRING (Buffer.contents buff)}
+  | _ as c    { Buffer.add_char buff c; read_string buff lexbuf }
+  | eof       { raise (Lexing_error ("String not finished, error"))}

lib/parser.mly

@@ -6,17 +6,18 @@
 %token EXIT HELP
 
 /* statements */
-%token INSERT SELECT
+%token INSERT SELECT INTO VALUES FROM
+%token <string> UNK_COM 
 
 /* Operators */
 %token LPAREN "("
 %token RPAREN ")"
+%token COMMA
 %token SUM
 %token MULT
 %token DIV
 %token SUBT
 %token EOF
-%token ENTER
 %token TRUE
 %token FALSE
 %token STRUCT_COMP
@@ -30,6 +31,7 @@
 %token <int> INT
 %token <float> FLOAT
 %token <string> IDENTIFIER
+%token <string> STRING
 
 %left LT
 %left GT
@@ -47,8 +49,6 @@
 %%
 
 prog: 
-  | meta ENTER { $1 }
-  | statement; ENTER { $1 }
   | meta EOF { $1 }
   | statement; EOF { $1 }
   | e = expr; EOF { Statement (Expr e ) }
@@ -58,26 +58,32 @@ meta:
   | EXIT              { Meta_command (Exit)}
   | HELP              { Meta_command (Help)}
 
-
-statement:
-  (* | create { $1 } *)
-  (* | query { $1 } *)
-  | SELECT; e = expr { Statement (Select e) }
-  | INSERT; e = expr { Statement (Expr e) }
-(*   | INSERT IDENTIFIER field_list {} *)
-
 field:
   | IDENTIFIER { $1 }
   ;
 
+constant:
+  | STRING            { Constant.make_string $1 }
+  | INT               { Constant.make_int (Int32.of_int $1) }
+
+
+constant_list:
+  | constant { [$1] }
+  | constant COMMA constant_list {$1 :: $3}
+
+
+statement:
+  (* | SELECT; e = expr { Statement (Select e) } *)
+  | SELECT field_list FROM IDENTIFIER {Statement (Select (Select.make $2 $4))}
+  | INSERT INTO IDENTIFIER LPAREN field_list RPAREN VALUES LPAREN constant_list RPAREN { Statement ( Insert (Insert.make $3 $5 $9))}
+  | unk = UNK_COM; {Statement (Unk_stmt ("error: " ^ unk ^ " is an unknown command") )}
+
+
 field_list:
   | field { [$1] }
-  | field field_list { $1 :: $2 }
+  | field COMMA field_list { $1 :: $3 }
   ;
 
-(* create: *)
-(*   | INSERT IDENTIFIER field_list {} *)
-  
 
 expr:
   | i = INT           { Int i }