Merge pull request #5 from bglid/feature/b-plus-tree

Feature/min b plus tree

Author: bglid

lib/btree/btree.ml

@@ -0,0 +1,122 @@
+[@@@warning "-69"]
+
+(* minimal B+ tree struct *)
+type t = {
+  storage_m : Storage_manager.t; (* file used to store to disk *)
+  key : Keys.t;
+  mutable root : Nodes.t;
+  mutable root_num : int;
+}
+
+[@@@warning "+69"]
+
+let serialize (node : Nodes.t) (block_size : int) : Page.Page.t =
+  (* recursive iterative helpers*)
+  let rec layout_keys (nd : Nodes.t) (pg : Page.Page.t) pair_size i : unit =
+    if i >= nd.capacity then
+      ()
+    else
+      let key_offset = 12 + (i * pair_size) + 4 in
+      begin match nd.keys.(i) with
+      | Integer n -> Page.Page.set_int32 pg key_offset n
+      | Varchar s -> Page.Page.set_string_raw pg key_offset s
+      end;
+      layout_keys nd pg pair_size (i + 1)
+  in
+
+  let rec layout_pointers (nd : Nodes.t) (pg : Page.Page.t) pair_size i : unit =
+    if i > nd.capacity then
+      ()
+    else
+      let pointer_offset = 12 + (i * pair_size) in
+      Page.Page.set_int32 pg pointer_offset (Int32.of_int nd.pointers.(i));
+      layout_pointers nd pg pair_size (i + 1)
+  in
+
+  (* Acutal serialization below*)
+  let page = Page.Page.make ~block_size in
+  (* set node type at first 4 bytes *)
+  Page.Page.set_int32 page 0 (Nodes.serialize_node node.node_t);
+  (* Set parent offset at 4 *)
+  Page.Page.set_int32 page 4 (Int32.of_int node.parent);
+  (* set curr size at 8 *)
+  Page.Page.set_int32 page 8 (Int32.of_int node.cur_size);
+  (* get the pointer -> key size, 4 bytes pointer + M bytes key*)
+  let pair_size = 4 + Keys.size_of_key node.key_type in
+  layout_keys node page pair_size 0;
+  layout_pointers node page pair_size 0;
+
+  let final_pointer_offset = 12 + (node.capacity * pair_size) in
+  (* ensuring serializing the sibling pointer *)
+  if node.node_t = Leaf then
+    Page.Page.set_int32 page final_pointer_offset
+      (Int32.of_int node.pointers.(node.capacity));
+  page
+
+let get_num_keys (block_size : int) (key_type : Keys.t) : int =
+  (* 12 bytes needed for metadata + 4 bytes for final sib pointer*)
+  (block_size - 16) / (4 + Keys.size_of_key key_type)
+
+let unused_pointer_serial = 3722304989 (*0xDDDDDDDD *)
+
+let deserialize (page : Page.Page.t) (key_type : Keys.t) (block_size : int) :
+    Nodes.t =
+  (* read node type *)
+  let node_type = Nodes.int32_to_node_t (Page.Page.get_int32 page 0) in
+  (* Read parent*)
+  let parent = Int32.to_int (Page.Page.get_int32 page 4) in
+  (* Read N the cur num of keys *)
+  let cur_size = Int32.to_int (Page.Page.get_int32 page 8) in
+  (* Get the capacity using block size and k type *)
+  let capacity = get_num_keys block_size key_type in
+  let keys = Array.init capacity (fun _ -> Keys.empty_key key_type) in
+  let pointers = Array.init (capacity + 1) (fun _ -> unused_pointer_serial) in
+  let pair_size = 4 + Keys.size_of_key key_type in
+
+  (* reading keys and pointers - not doing this one recursively*)
+  for i = 0 to cur_size - 1 do
+    let pointer_offset = 12 + (i * pair_size) in
+    let key_offset = 12 + (i * pair_size) + 4 in
+    (* reading in the pointers from bytes *)
+    pointers.(i) <- Int32.to_int (Page.Page.get_int32 page pointer_offset);
+    (* reading the keys from bytes *)
+    match key_type with
+    | Keys.TVarchar n ->
+        let str = Page.Page.get_string_raw page key_offset n in
+        keys.(i) <- Keys.Varchar str
+    | Keys.TInteger ->
+        let num = Page.Page.get_int32 page key_offset in
+        keys.(i) <- Keys.Integer num
+  done;
+
+  (* again final pointer read *)
+  let last_pointer_offset = 12 + (cur_size * pair_size) in
+  pointers.(cur_size) <-
+    Int32.to_int (Page.Page.get_int32 page last_pointer_offset);
+  (* sibling pointer is last pointer in array at index capacity *)
+  let sib_pointer_offset = 12 + (capacity * pair_size) in
+  if node_type = Leaf then
+    pointers.(capacity) <-
+      Int32.to_int (Page.Page.get_int32 page sib_pointer_offset);
+
+  { node_t = node_type; parent; cur_size; keys; pointers; capacity; key_type }
+
+(* writing nodes to disk *)
+let write_node (btree : t) (node : Nodes.t) (n : int) : unit =
+  let block_size = File_manager.get_blocksize btree.storage_m.file_manager in
+  let page = serialize node block_size in
+  Storage_manager.update_block_num ~storage_m:btree.storage_m ~block_num:n ~page
+
+let write_node_append (btree : t) (node : Nodes.t) : int =
+  let block_size = File_manager.get_blocksize btree.storage_m.file_manager in
+  let page = serialize node block_size in
+  let block = Storage_manager.append ~storage_m:btree.storage_m ~page in
+  Page.Block.block_num block
+
+(* getting a block from the btree and deserialize it into a node *)
+let get_node (btree : t) (p : int) : Nodes.t =
+  let block_size = File_manager.get_blocksize btree.storage_m.file_manager in
+  let page =
+    Storage_manager.get_block ~storage_m:btree.storage_m ~block_num:p
+  in
+  deserialize page btree.key block_size

lib/btree/btree.mli

@@ -0,0 +1,24 @@
+type t
+(** Struct for the B+ Tree *)
+
+val serialize : Nodes.t -> int -> Page.Page.t
+(** Takes B+ tree node [t] and serializes it to a [Page.t], then writes to disk
+    using the [Storage_manager.t]*)
+
+val get_num_keys : int -> Keys.t -> int
+(** Get number of keys from block *)
+
+val deserialize : Page.Page.t -> Keys.t -> int -> Nodes.t
+(** Convert page into B+ tree node struct *)
+
+val write_node : t -> Nodes.t -> int -> unit
+(** Take B+ tree [t] [node] and offset n into the file. Updates block within
+    file via storage manager *)
+
+val write_node_append : t -> Nodes.t -> int
+(** Append a block in B+ tree and return offset to new blocks location. Used
+    when creating a new node *)
+
+val get_node : t -> int -> Nodes.t
+(** Get a block from the btree [t] and deserializeit using the pointer [p] into
+    a btree node *)

lib/btree/keys.ml

@@ -0,0 +1,47 @@
+type t =
+  | TVarchar of int
+  | TInteger
+[@@deriving show]
+
+type value =
+  | Varchar of string
+  | Integer of Int32.t
+[@@deriving show]
+
+let less_than (k1 : value) (k2 : value) : bool =
+  match (k1, k2) with
+  | Integer n1, Integer n2 -> n1 < n2
+  | Varchar v1, Varchar v2 -> v1 < v2
+  | _ -> failwith "Incompatible keys"
+
+let equals (k1 : value) (k2 : value) : bool =
+  match (k1, k2) with
+  | Integer n1, Integer n2 -> n1 = n2
+  | Varchar v1, Varchar v2 -> v1 = v2
+  | _ -> failwith "Incompatible keys"
+
+let greater_than (k1 : value) (k2 : value) : bool =
+  match (k1, k2) with
+  | Integer n1, Integer n2 -> n1 > n2
+  | Varchar v1, Varchar v2 -> v1 > v2
+  | _ -> failwith "Incompatible keys"
+
+let leq_than (k1 : value) (k2 : value) : bool = less_than k1 k2 || equals k1 k2
+
+let greq_than (k1 : value) (k2 : value) : bool =
+  greater_than k1 k2 || equals k1 k2
+
+let string_of_key (k : value) : string =
+  match k with
+  | Integer n -> Printf.sprintf "Integer: %d" (Int32.to_int n)
+  | Varchar v -> Printf.sprintf "Varchar: %s" v
+
+let size_of_key (key_type : t) : int =
+  match key_type with
+  | TVarchar s -> s
+  | TInteger -> 4
+
+let empty_key (key_type : t) : value =
+  match key_type with
+  | TVarchar n -> Varchar (String.make n '\"')
+  | TInteger -> Integer Int32.max_int

lib/btree/keys.mli

@@ -0,0 +1,18 @@
+type t =
+  | TVarchar of int
+  | TInteger
+[@@deriving show]
+
+type value =
+  | Varchar of string
+  | Integer of Int32.t
+[@@deriving show]
+
+val less_than : value -> value -> bool
+val equals : value -> value -> bool
+val leq_than : value -> value -> bool
+val greater_than : value -> value -> bool
+val greq_than : value -> value -> bool
+val string_of_key : value -> string
+val size_of_key : t -> int
+val empty_key : t -> value

lib/btree/nodes.ml

@@ -0,0 +1,39 @@
+type node_type =
+  | Leaf
+  | Internal
+[@@deriving show]
+
+[@@@warning "-69"]
+
+type t = {
+  (* There are 2 node types, leaf or internal *)
+  mutable node_t : node_type;
+  mutable parent : int;
+  mutable cur_size : int;
+  keys : Keys.value array;
+  pointers : int array;
+  (* max num of keys *)
+  capacity : int;
+  key_type : Keys.t;
+}
+[@@deriving show]
+
+[@@@warning "+69"]
+
+(* Constants for serialization*)
+let leaf_serial = Int32.of_int 2863311530 (* 0xAAAAAAAA *)
+let internal_serial = Int32.of_int 3149642683
+(* 0xBBBBBBBB *)
+
+let serialize_node (node_t : node_type) : Int32.t =
+  match node_t with
+  | Leaf -> leaf_serial
+  | Internal -> internal_serial
+
+let int32_to_node_t (i32 : Int32.t) : node_type =
+  if i32 = leaf_serial then
+    Leaf
+  else if i32 = internal_serial then
+    Internal
+  else
+    failwith "WRONG i32!"

lib/btree/nodes.mli

@@ -0,0 +1,21 @@
+(** Holds variants for different types of nodes *)
+type node_type =
+  | Leaf
+  | Internal
+[@@deriving show]
+
+type t = {
+  mutable node_t : node_type;
+  mutable parent : int;
+  mutable cur_size : int;
+  keys : Keys.value array;
+  pointers : int array;
+  (* max num of keys *)
+  capacity : int;
+  key_type : Keys.t;
+}
+[@@deriving show]
+(** Data structure for nodes *)
+
+val serialize_node : node_type -> Int32.t
+val int32_to_node_t : Int32.t -> node_type

lib/file_manager/page.ml

@@ -1,5 +1,5 @@
 module Block = struct
-  type t = string * int
+  type t = string * int [@@deriving show]
 
   let file_name (filename, _) = filename
   let block_num (_, blocknum) = blocknum
@@ -9,7 +9,7 @@ module Block = struct
 end
 
 module Page = struct
-  type t = bytes
+  type t = bytes [@@deriving show]
 
   let make ~block_size = Bytes.make block_size '\000'
   let from_bytes b = b

lib/file_manager/page.mli

@@ -1,6 +1,6 @@
 (** Blocks are representative of the Blocks on the Disk *)
 module Block : sig
-  type t
+  type t [@@deriving show]
 
   val file_name : t -> string
   (** Return the file name upon giving the block*)
@@ -23,7 +23,7 @@ end
 (** Page is a module that allows us to buffer bytes in memory. It allows us to
     do work on the blocks before writing them back to disk*)
 module Page : sig
-  type t
+  type t [@@deriving show]
 
   val make : block_size:int -> t
   (** Calls Bytes.make to init a block of size ~block_size and returns an init

lib/storage_manager/storage_manager.ml

@@ -1,5 +1,3 @@
-(* open File_manager *)
-
 (* Block 0 is for the freelist. If it's not in the freelist it's being used *)
 (* NOTE: The 'head_page', is top of the freelist *)
 

lib/storage_manager/storage_manager.mli

@@ -1,7 +1,11 @@
 (** This is what our B+ tree will interact with to interact with the file
     manager *)
 
-type t
+type t = {
+  file_manager : File_manager.t;
+  storage_file : string;
+  mutable head_page : Page.Page.t (* First page contains metadata *);
+}
 
 val make : file_manager:File_manager.t -> storage_file:string -> t
 (** Takes a file manager and a string to create a new storage manager *)