lmdb 1.0 · OCaml Package

Key-value maps.

type ('key, 'value, -'dup) t constraint 'perm = [< `Read | `Write ] constraint 'dup = [< `Dup | `Uni ]

A handle for a map from keys of type 'key to values of type 'value. The map may support only a single value per key ([ `Dup ]) or multiple values per key ([ `Dup | `Uni ]).

type 'a card =

| Nodup : [ `Uni ] card
| Dup : [ `Dup | `Uni ] card

val create : 
  [< `Dup | `Uni ] as 'dup card ->
  key:'key Conv.t ->
  value:'value Conv.t ->
  ?txn:[> `Read | `Write ] Txn.t ->
  ?name:string ->
  Env.t ->
  ('key, 'value, 'dup) t

create dup ~key ~value env open (and possibly create) a map in the environment env.

dup may be Dup or Nodup, specifying whether the map supports multiple values per key.

Only a single transaction may call this function at a time. This transaction needs to finish before any other transaction may call this function.

parameter name
if omitted the unnamed map will be opened. Otherwise make sure that Env.create was called with a large enough ~max_maps.

parameter key
Converter for keys

parameter value
Converter for values

raises Invalid_argument
if an existing map doesn't support duplicates, but duplicates where requested.

val open_existing : 
  [< `Dup | `Uni ] as 'dup card ->
  key:'key Conv.t ->
  value:'value Conv.t ->
  ?txn:[> `Read ] Txn.t ->
  ?name:string ->
  Env.t ->
  ('key, 'value, 'dup) t

open_existing env is like create, but only opens already existing maps.

raises Not_found
if the map doesn't exist.

val env : (_, _, _) t -> Env.t

env map returns the environment of map.

val get : ('key, 'value, _) t -> ?txn:[> `Read ] Txn.t -> 'key -> 'value

get map key returns the first value associated to key.

raises Not_found
if the key is not in the map.

module Flags : sig ... end

val add : 
  ('key, 'value, _) t ->
  ?txn:[> `Write ] Txn.t ->
  ?flags:Flags.t ->
  'key ->
  'value ->
  unit

add map key value adds value to key.

For a map not supporting duplicates an existing value is overwritten. For a map supporting duplicates the value is added to the key. This is the same as overwrite for duplicate maps, but overwrite ~flags:Flags.no_overwrite for non-duplicate maps.

parameter flags
Flags

raises Exists
on maps not supporting duplicates if the key already exists.

raises Exists
if key is already bound to value and Map.Flags.no_dup_data was passed.

val set : 
  ('key, 'value, _) t ->
  ?txn:[> `Write ] Txn.t ->
  ?flags:Flags.t ->
  'key ->
  'value ->
  unit

set map key value sets binding of key to value.

Values of an already existing key are silently overwritten.

parameter flags
Flags

val remove : 
  ('key, 'value, _) t ->
  ?txn:[> `Write ] Txn.t ->
  ?value:'value ->
  'key ->
  unit

remove map key removes key from map.

parameter value
Only the specified value is removed. If not provided, all the values of key and key itself are removed.

raises Not_found
if the key is not in the map.

Misc

val stat : ?txn:[> `Read ] Txn.t -> ('key, 'value, _) t -> Mdb.stat

val drop : 
  ?txn:[> `Write ] Txn.t ->
  ?delete:bool ->
  ('key, 'value, _) t ->
  unit

drop ?delete map Empties map.

parameter delete
If true map is also deleted from the environment and the handle map invalidated.

val compare_key : 
  ('key, 'value, _) t ->
  ?txn:[> `Read ] Txn.t ->
  'key ->
  'key ->
  int

compare_key map ?txn a b Compares a and b as if they were keys in map.

val compare : 
  ('key, 'value, _) t ->
  ?txn:[> `Read ] Txn.t ->
  'key ->
  'key ->
  int

compare map ?txn a b Same as compare_key.

val compare_val : 
  ('key, 'value, [> `Dup ]) t ->
  ?txn:[> `Read ] Txn.t ->
  'value ->
  'value ->
  int

compare_val map ?txn a b Compares a and b as if they were values in a dup_sort map.

package lmdb

Misc