Module db_toke

DB back-end using tokyo cabinet via toke.

Copyright © 2013-2014 Zuse Institute Berlin,

Version: $Id$

Behaviours: db_backend_beh.

Authors: Jan Fajerski (fajerski@zib.de).

Description

DB back-end using tokyo cabinet via toke. Two keys K and L are considered equal if they match, i.e. K =:= L

To use this backend you have to install Tokyo Cabinet http://fallabs.com/tokyocabinet and Toke http://hg.opensource.lshift.net/toke/ (a simple Erlang wrapper for Tokyo Cabinets hash API tchdb*). For development Tokyo Cabinet V1.4.48-1 and the at-the-time latest commit to the toke-repository (f178e55bb6b5) was used.

After building and installing Tokyo Cabinet and toke rerun configure with --enable-toke. configure assumes that you installed toke in your erlang's lib directory, i.e. <erlang_dir>/lib/toke or <erlang_dir>/lib/toke-<version>. If you used a different directory, e.g. /home/scalaris/apps/toke, you have to provide the path to configure:

./configure --enable-toke=/home/scalaris/apps/toke/

Rerun make and you can use db_toke.

Data Types

db()

db() = {DB :: pid(), DBName :: nonempty_string()}

entry()

entry() = db_backend_beh:entry()

key()

key() = db_backend_beh:key()

'$end_of_table' is not allowed as key() or else iterations won't work!

Function Index

close/1Closes the DB named DBName.
close_and_delete/1Closes and deletes the DB named DBName.
delete/2Deletes the tuple saved under Key and returns the new DB.
foldl/3Equivalent to toke_drv:fold(Fun, Acc0, DB).
foldl/4 Returns a potentially larger-than-memory dataset.
foldl/5foldl iterates over DB and applies Fun(Entry, AccIn) to every element encountered in Interval.
foldl_unordered/3Works similar to foldl/3 but uses toke_drv:fold instead of our own implementation.
foldr/3makes a foldr over the whole dataset.
foldr/4 Returns a potentially larger-than-memory dataset.
foldr/5foldr iterates over DB and applies Fun(Entry, AccIn) to every element encountered in Interval.
get/2Returns the entry that corresponds to Key or {} if no such tuple exists.
get_load/1Returns the current load (i.e.
get_name/1Returns the name of the DB specified in @see new/1.
get_persisted_tables/0Gets a list of persisted tables.
is_available/0Checks for modules required for this DB backend.
new/1Creates new DB handle named DBName.
open/1Open a previously existing database.
put/2Saves arbitrary tuple Entry in DB DBName and returns the new DB.
supports_feature/1Returns true if the DB support a specific feature (e.g.
tab2list/1Returns a list of all objects in the table Table_name.

Function Details

new/1

new(DBName :: nonempty_string()) -> db()

Creates new DB handle named DBName.

open/1

open(DBName :: nonempty_string()) -> db()

Open a previously existing database.

close/1

close(DB :: db()) -> true

Closes the DB named DBName

close_and_delete/1

close_and_delete(DB :: db()) -> true

Closes and deletes the DB named DBName

get_persisted_tables/0

get_persisted_tables() -> [nonempty_string()]

Gets a list of persisted tables.

put/2

put(DB :: db(), Entry :: entry()) -> db()

Saves arbitrary tuple Entry in DB DBName and returns the new DB. The key is expected to be the first element of Entry.

get/2

get(DB :: db(), Key :: key()) -> entry() | {}

Returns the entry that corresponds to Key or {} if no such tuple exists.

delete/2

delete(DB :: db(), Key :: key()) -> db()

Deletes the tuple saved under Key and returns the new DB. If such a tuple does not exists nothing is changed.

get_name/1

get_name(DB :: db()) -> nonempty_string()

Returns the name of the DB specified in @see new/1.

is_available/0

is_available() -> boolean() | [atom()]

Checks for modules required for this DB backend. Returns true if no modules are missing, or else a list of missing modules

supports_feature/1

supports_feature(Feature :: atom()) -> boolean()

Returns true if the DB support a specific feature (e.g. recovery), false otherwise.

get_load/1

get_load(DB :: db()) -> non_neg_integer()

Returns the current load (i.e. number of stored tuples) of the DB.

foldl/3

foldl(DB :: db(),
      Fun :: fun((Key :: key(), AccIn :: A) -> AccOut :: A),
      Acc0 :: A) ->
         Acc1 :: A

Equivalent to toke_drv:fold(Fun, Acc0, DB). Returns a potentially larger-than-memory dataset. Use with care.

foldl/4

foldl(DB :: db(),
      Fun :: fun((Key :: key(), AccIn :: A) -> AccOut :: A),
      Acc0 :: A,
      Interval :: db_backend_beh:interval()) ->
         Acc1 :: A

Equivalent to foldl(DB, Fun, Acc0, Interval, get_load(DB)).

Returns a potentially larger-than-memory dataset. Use with care.

foldl/5

foldl(DB :: db(),
      Fun :: fun((Key :: key(), AccIn :: A) -> AccOut :: A),
      Acc0 :: A,
      Intervall :: db_backend_beh:interval(),
      MaxNum :: non_neg_integer()) ->
         Acc1 :: A

foldl iterates over DB and applies Fun(Entry, AccIn) to every element encountered in Interval. On the first call AccIn == Acc0. The iteration stops as soon as MaxNum elements have been encountered. Returns a potentially larger-than-memory dataset. Use with care.

foldr/3

foldr(DB :: db(),
      Fun :: fun((Key :: key(), AccIn :: A) -> AccOut :: A),
      Acc0 :: A) ->
         Acc1 :: A

makes a foldr over the whole dataset. Returns a potentially larger-than-memory dataset. Use with care.

foldr/4

foldr(DB :: db(),
      Fun :: fun((Key :: key(), AccIn :: A) -> AccOut :: A),
      Acc0 :: A,
      Interval :: db_backend_beh:interval()) ->
         Acc1 :: A

Equivalent to foldr(DB, Fun, Acc0, Interval, get_load(DB)).

Returns a potentially larger-than-memory dataset. Use with care.

foldr/5

foldr(DB :: db(),
      Fun :: fun((Key :: key(), AccIn :: A) -> AccOut :: A),
      Acc0 :: A,
      Intervall :: db_backend_beh:interval(),
      MaxNum :: non_neg_integer()) ->
         Acc1 :: A

foldr iterates over DB and applies Fun(Entry, AccIn) to every element encountered in Interval. On the first call AccIn == Acc0. The iteration stops as soon as MaxNum elements have been encountered. Returns a potentially larger-than-memory dataset. Use with care.

foldl_unordered/3

foldl_unordered(DB :: db(),
                Fun ::
                    fun((Entry :: entry(), AccIn :: A) ->
                            AccOut :: A),
                Acc0 :: A) ->
                   Acc1 :: A

Works similar to foldl/3 but uses toke_drv:fold instead of our own implementation. The order in which will be iterated over is unspecified, but using this fuction might be faster than foldl/3 if it does not matter.

tab2list/1

tab2list(Table_name :: db()) -> [Entries :: entry()]

Returns a list of all objects in the table Table_name.


Generated by EDoc, Sep 11 2020, 15:26:05.