Module `Lmdb.Map`Source

Key-value maps.

Sourcetype ('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 ([ `Uni ]) or multiple values per key ([ `Dup | `Uni ]).

Sourcetype 'a card =

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

Source

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.

Source

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.

Sourceval close : (_, _, _) t -> unit

close map closes and invalidates the map handle. Normalle unnecessary. Use with care. See the lmdb manual.

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

env map returns the environment of map.

Accessors

Sourceval 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.

Sourcemodule Flags : sig ... end

Source

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

add map key value adds value to key.

Existing values are neither removed nor overwritten.

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.

Source

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

Source

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.

Iterators

Dispensers / Generators are iterators meant to be used via Stdlib.Seq.of_dispenser or the Gen module

They create a read-only (child) transaction and cursor which are automatically closed when the Dispenser is exhausted. Therefore be sure to completely exhaust a dispenser in a timely fashion.

Source

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

to_dispenser map returns key-value pairs in order.

Source

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

to_dispenser_rev map returns key-value pairs in reverse order.

Source

val to_dispenser_all : 
  ?txn:[> `Read ] Txn.t ->
  ('key, 'value, [> `Dup ]) t ->
  unit ->
  ('key * 'value array) option

to_dispenser_all map returns keys with their associated values in order.

Source

val to_dispenser_rev_all : 
  ?txn:[> `Read ] Txn.t ->
  ('key, 'value, [> `Dup ]) t ->
  unit ->
  ('key * 'value array) option

to_dispenser_all map returns keys with their associated values in reverse order.

Misc

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

Source

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.

Source

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.

Source

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

compare map ?txn a b Same as compare_key.

Source

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

Module Lmdb.MapSource

Accessors

Iterators

Misc

Module `Lmdb.Map`Source