|
|
(* Branch: the effectful session layer.
Owns the RNT branch handle and the in-memory mirror of every multigroup
bound to that branch. Each mutation names its target mg explicitly. *)
module Make (NT : Nt.S) = struct
module Error = struct
open Condition
(* TODO: more structure *)
let not_supported msg = condition "not-supported" msg empty
let handle_error msg = condition "handle-error" msg empty
end
let ( let* ) = Result.bind
type mode =
| Live (* tracking branch tip; mutations allowed *)
| Detached of string (* pinned to snapshot hash; read-only *)
class branch
~(init_bh : Nt.branch_handle)
~(init_name : string)
~(init_tip : string)
~(init_mgs : (string * Management.Multigroup.multigroup) list)
~(init_mode : mode) =
object (self)
val mutable bh : Nt.branch_handle = init_bh
val name : string = init_name
val mutable tip : string = init_tip
val mutable mode : mode = init_mode
val mgs : (string, Management.Multigroup.multigroup) Hashtbl.t =
let t = Hashtbl.create 8 in
List.iter (fun (n, mg) -> Hashtbl.replace t n mg) init_mgs;
t
method name = name
method tip = tip
method snapshot = tip
method mode = mode
method branch_handle = bh
method mg_of (n : string) : Management.Multigroup.multigroup option =
Hashtbl.find_opt mgs n
method multigroups : (string * Management.Multigroup.multigroup) list =
Hashtbl.to_seq mgs |> List.of_seq
(* Register a fresh mg under this branch. Idempotent. *)
method add_multigroup ~(name : string) : unit =
if not (Hashtbl.mem mgs name) then
Hashtbl.add mgs name (new Management.Multigroup.multigroup ~name)
(* Replace the cached mg value (e.g. after an NT mutation returned a
new mg). Idempotent insert if the mg was not present. *)
method set_mg ~(name : string) (mg : Management.Multigroup.multigroup) : unit =
Hashtbl.replace mgs name mg
(* Path for a relation in this branch (Live) or its pinned snapshot
(Detached). Pass [~branch] to reference a relation on a different
live branch (cross-multigroup reads). *)
method path ?(branch : string option) (fqn : Qualified_name.t) : string =
match branch with
| Some b ->
"/system/branches/" ^ b ^ "/multigroups/" ^ fqn.mg
^ "/relations/" ^ fqn.name
| None ->
match mode with
| Live ->
"/system/branches/" ^ name ^ "/multigroups/" ^ fqn.mg
^ "/relations/" ^ fqn.name
| Detached hash ->
"/system/snapshots/" ^ hash ^ "/relations/" ^ fqn.name
method private assert_live op =
match mode with
| Live -> Ok ()
| Detached _ ->
Error (Error.not_supported (op ^ ": detached snapshot is read-only"))
method private sync_tip () =
match mode with
| Detached _ -> ()
| Live ->
match NT.branch_target_of_handle bh with
| Error _ -> ()
| Ok h -> tip <- h
method private get_mg op (mg_name : string) :
(Management.Multigroup.multigroup, Condition.t) result =
match Hashtbl.find_opt mgs mg_name with
| Some mg -> Ok mg
| None -> Error (Error.handle_error
(op ^ ": multigroup not found: " ^ mg_name))
method create_relation ~(mg : string) ~(rel_name : string) ~schema =
let* () = self#assert_live "create_relation" in
let* mg_val = self#get_mg "create_relation" mg in
let* (bh', mg') =
NT.create_relation bh mg_val
~branch_name:name ~mg_name:mg ~name:rel_name ~schema
in
bh <- bh'; Hashtbl.replace mgs mg mg'; self#sync_tip (); Ok ()
method retract_relation ~(mg : string) ~(rel_name : string) =
let* () = self#assert_live "retract_relation" in
let* mg_val = self#get_mg "retract_relation" mg in
let* (bh', mg') = NT.retract_relation bh mg_val ~name:rel_name in
bh <- bh'; Hashtbl.replace mgs mg mg'; self#sync_tip (); Ok ()
method clear_relation ~(mg : string) ~(rel_name : string) =
let* () = self#assert_live "clear_relation" in
let* mg_val = self#get_mg "clear_relation" mg in
match mg_val#get_relation rel_name with
| None -> Error (Error.handle_error ("relation not found: " ^ rel_name))
| Some rel ->
let* (bh', mg') =
NT.clear_relation bh mg_val
~branch_name:name ~mg_name:mg rel
in
bh <- bh'; Hashtbl.replace mgs mg mg'; self#sync_tip (); Ok ()
method register_domain ~(mg : string) domain =
let* () = self#assert_live "register_domain" in
let* mg_val = self#get_mg "register_domain" mg in
let* (bh', mg') = NT.register_domain bh mg_val domain in
bh <- bh'; Hashtbl.replace mgs mg mg'; Ok ()
method create_immutable_relation ~(mg : string) ~name:rel_name ~schema
~generator ~membership_criteria ~cardinality ~producer =
let* () = self#assert_live "create_immutable_relation" in
let* mg_val = self#get_mg "create_immutable_relation" mg in
let* (bh', mg', rel) =
NT.create_immutable_relation bh mg_val ~name:rel_name ~schema ~generator
~membership_criteria ~cardinality ~producer
in
bh <- bh'; Hashtbl.replace mgs mg mg'; Ok rel
method register_constraint ~(mg : string) ~constraint_name ~relation_name
~body =
let* () = self#assert_live "register_constraint" in
let* mg_val = self#get_mg "register_constraint" mg in
let* (bh', mg') =
NT.register_constraint bh mg_val ~constraint_name ~relation_name ~body
in
bh <- bh'; Hashtbl.replace mgs mg mg'; Ok ()
method insert_tuple ~(mg : string) ~(rel_name : string) attrs =
let* () = self#assert_live "insert_tuple" in
let* hash =
NT.insert_tuple ~branch_name:name ~mg_name:mg ~rel_name attrs
in
self#sync_tip (); Ok hash
method create_tuple ~(mg : string) ~(rel_name : string) tuple =
let* () = self#assert_live "create_tuple" in
let* hash =
NT.create_tuple ~branch_name:name ~mg_name:mg ~rel_name tuple
in
self#sync_tip (); Ok hash
method create_tuples ~(mg : string) ~(rel_name : string) tuples =
let* () = self#assert_live "create_tuples" in
let* hash =
NT.create_tuples ~branch_name:name ~mg_name:mg ~rel_name tuples
in
self#sync_tip (); Ok hash
method retract_tuple ~(mg : string) ~(rel_name : string) ~tuple_hash =
let* () = self#assert_live "retract_tuple" in
let* () =
NT.retract_tuple ~branch_name:name ~mg_name:mg ~rel_name tuple_hash
in
self#sync_tip (); Ok ()
(* Applies a Transition delta from a sublanguage executor. Each entry
replaces the named mg in the cache, then the tip is re-read. *)
method apply_delta (delta : (string * Management.Multigroup.multigroup) list) =
List.iter
(fun (mg_name, mg_val) -> Hashtbl.replace mgs mg_name mg_val)
delta;
self#sync_tip ()
method close () = NT.close_branch bh
end
(* Default mg name seeded into an unborn branch so the session can write
into something. Real catalog seeding (under "sakura") is the prelude's
responsibility. *)
let default_mg_name = "public"
let open_branch claims branch_name =
let* (bh, _legacy_mg) = NT.open_branch claims branch_name in
let tip = match NT.branch_target_of_handle bh with
| Ok h -> h
| Error _ -> ""
in
let* mg_entries = NT.list_branch_multigroups branch_name in
let mgs =
List.map
(fun (mg_name, _mg_hash) ->
(* For each bound mg, enumerate its relations from the kernel and
rebuild the OCaml mirror. Schemas are not persisted in the
snapshot codec — they are repopulated by DDL replay / catalog
reads later. *)
let rels =
match NT.list_relations ~branch_name ~mg_name with
| Ok pairs -> pairs
| Error _ -> []
in
let mg =
List.fold_left
(fun mg (rel_name, root) ->
let rel =
(new Relation.stored
~name:rel_name
~schema:[]
~constraints:None
~cardinality:Conventions.Cardinality.AlephZero
~lineage:(Some (Relation.Lineage.Base rel_name))
~provenance:(Some (Relation.Provenance.base
~relation:rel_name ~attributes:[]))
~membership_criteria:(fun _ -> true))
#set_tree_pointer (Some root)
in
mg#add_relation (rel :> Relation.relation))
(new Management.Multigroup.multigroup ~name:mg_name)
rels
in
(mg_name, mg))
mg_entries
in
let mgs =
if mgs = [] then
[ (default_mg_name,
new Management.Multigroup.multigroup ~name:default_mg_name) ]
else mgs
in
Ok (new branch
~init_bh:bh ~init_name:branch_name ~init_tip:tip ~init_mgs:mgs
~init_mode:Live)
let open_snapshot claims ~branch_name ~snapshot_hash =
let* (bh, mg) = NT.open_snapshot claims branch_name snapshot_hash in
Ok (new branch
~init_bh:bh ~init_name:branch_name ~init_tip:snapshot_hash
~init_mgs:[ (mg#name, mg) ]
~init_mode:(Detached snapshot_hash))
end
|
