db_open_env(
+EnvName,
-EnvRef)
db_open_env(
+EnvName,
+CacheSize,
-EnvRef)
Opens an environment with the name EnvName. A directory with this
name is created for the environment if necessary. EnvName is not
subject to absolute_file_name/3
conversion.
By using db_open_env/3
one can specify the size of the cache:
CacheSize is the (integer) size of the cache in kilobytes. The
size of the cache cannot be less than 20 kilobytes.
db_open_env/2
will create a cache of the system's default size.
The size of the cache is determined when the environment is created and cannot be changed by future openings.
A process cannot open the same environment more than once.
db_close_env(
+EnvRef)
Closes an environment. All databases opened in the environment
will be closed as well.
db_current_env(
?EnvName,
?EnvRef)
Unifies the arguments with the open environments. This
predicate can be used for enumerating all currently open
environments through backtracking.
db_open(
+DBName,
+Mode,
?SpecList,
-DBRef)
db_open(
+DBName,
+Mode,
?SpecList,
+Options,
-DBRef)
Opens a database with the name DBName. The database
physically consists of a directory with the same name, containing the
files that make up the database. If the directory does not exist,
it is created. In that case Mode must be update
and the
db-spec SpecList must be ground. If an existing
database is opened and Mode is read
or update
,
SpecList is unified with the db-spec given when the
database was created. If the unification fails an error is
raised. DBRef is unified with a reference to the opened
database. DBName is not subject to
absolute_file_name/3
conversion.
If Mode is enumerate
then the indexing specification is not
read, and SpecList is left unbound.
Options provides a way to specify an environment in which to open the database, or a cache size. Options should be a list of terms of the following form:
environment(
EnvRef)
cache_size(
CacheSize)
default
, a default cache size will be used. If
CacheSize is given as the atom off
or the atom
none
, all modified records will be flushed to disk after each
operation.
To avoid inconsistency, if multiple processes open the same
database, then all of them should do that with Mode set to
read
or enumerate
. (This is not enforced by the system.)
db_close(
+DBRef)
Closes the database referenced by DBRef. Any iterators
opened in the database will be deallocated.
db_current(
?DBName,
?Mode,
?SpecList,
?EnvRef,
?DBRef)
Unifies the arguments with the open databases. This
predicate can be used to enumerate all currently open
databases through backtracking. If the database was
opened without an environment, then EnvRef will be unified
with the atom none
.
db_store(
+DBRef,
+Term,
-TermRef)
Stores Term in the database DBRef. TermRef is
unified with a corresponding term reference. The
functor of Term must match the functor of a spec in
the db-spec associated with DBRef.
db_fetch(
+DBRef,
?Term,
?TermRef)
Unifies Term with a term from the database DBRef. At the same time, TermRef is unified with a corresponding term reference. Backtracking over the predicate unifies with all terms matching Term.
If TermRef is not instantiated then both the functor and the instantiatedness of Term must match a spec in the db-spec associated with DBRef.
If TermRef is instantiated, the referenced term is read and unified with Term.
If you simply want to find all matching terms, it is more
efficient to use db_findall/5
or db_enumerate/3
.
db_findall(
+DBRef,
+Template,
+Term,
:Goal,
?Bag)
Unifies Bag with the list of instances of
Template in all proofs of Goal found when Term is
unified with a matching term from the database
DBRef. Both the functor and the instantiatedness of
Term must match a spec in the db-spec associated with DBRef.
Conceptually, this predicate is equivalent to
findall(
Template, (db_fetch(
DBRef,
Term, _),
Goal),
Bag)
.
db_erase(
+DBRef,
+TermRef)
db_erase(
+DBRef,
+TermRef,
+Term)
Deletes the term from the database DBRef that is referenced by TermRef.
In the case of db_erase/2
the term associated with
TermRef has to be looked up. db_erase/3
assumes that the
term Term is identical with the term associated with
TermRef (modulo variable renaming). If this is not the
case, the behavior is undefined.
db_enumerate(
+DBRef,
?Term,
?TermRef)
Unifies Term with a term from the database DBRef. At the same time, TermRef is unified with a corresponding term reference. Backtracking over the predicate unifies with all terms matching Term.
Implemented by linear search--the db-spec associated with DBRef
is ignored. It is not useful to call this predicate with
TermRef instantiated.
db_sync(
+DBRef)
Flushes any cached information from the database referenced by
DBRef to stable storage.
db_compress(
+DBRef,
+DBName)
db_compress(
+DBRef,
+DBName,
+SpecList)
Copies the database given by DBRef to a new database named by DBName. The new database will be a compressed version of the first one in the sense that it will not have "holes" resulting from deletion of terms. Deleted term references will also be reused, which implies that references that refer to terms in the old database will be invalid in the new one.
db_compress/2
looks for a database with the db-spec of the
original one. db_compress/3
stores the terms found in the
original database with the indexing specification SpecList.
db_compress/2
cannot be used if the database DBRef
was opened in mode enumerate
.
If the database DBName already exists then the terms of DBRef will be appended to it. Of course DBName must have an indexing specification, which enables the terms in DBRef to be inserted into it.
In the case of db_compress/3
if the database DBName
does not exist, then SpecList must be a valid indexing
specification.
db_make_iterator(
+DBRef,
-Iterator)
db_make_iterator(
+DBRef,
+Term,
-Iterator)
Creates a new iterator and unifies it with Iterator.
Iterators created with db_make_iterator/2
iterate through the
whole database. Iterators created with db_make_iterator/3
iterate through the terms that would be found by
db_fetch(
DBRef,
Term, _)
.
Every iterator created by db_make_iterator/[2,3]
must be
destroyed with db_iterator_done/1
.
db_iterator_next(
+Iterator,
?Term,
?TermRef)
Iterator advances to the next term, Term and
TermRef is unified with the term and its reference
pointed to by Iterator. If there is no next term, the
predicate fails.
db_iterator_done(
+Iterator)
Deallocates Iterator, which must not be in use anymore.
db_current_iterator(
?DBRef,
?Term,
?Iterator)
Unifies the the variables with the respective properties of
the living iterators. This predicate can be used to enumerate all
currently alive iterators through backtracking. If Iterator
was made with db_make_iterator/2
then Term will be left
unbound.