<?xml version="1.0"?>
<doc>
<assembly>
<name>libdb_dotnet48</name>
</assembly>
<members>
<member name="T:BerkeleyDB.LSN">
<summary>
A log sequence number, which specifies a unique location in a log file.
</summary>
</member>
<member name="F:BerkeleyDB.LSN.LogFileNumber">
<summary>
The log file number.
</summary>
</member>
<member name="F:BerkeleyDB.LSN.Offset">
<summary>
The offset in the log file.
</summary>
</member>
<member name="M:BerkeleyDB.LSN.#ctor(System.UInt32,System.UInt32)">
<summary>
Instantiate a new LSN object
</summary>
<param name="file">The log file number.</param>
<param name="off">The offset in the log file.</param>
</member>
<member name="M:BerkeleyDB.LSN.Compare(BerkeleyDB.LSN,BerkeleyDB.LSN)">
<summary>
Compare two LSNs.
</summary>
<param name="lsn1">The first LSN to compare</param>
<param name="lsn2">The second LSN to compare</param>
<returns>
0 if they are equal, 1 if lsn1 is greater than lsn2, and -1 if lsn1
is less than lsn2.
</returns>
</member>
<member name="T:BerkeleyDB.HashDatabase">
<summary>
A class representing a HashDatabase. The Hash format is an extensible,
dynamic hashing scheme.
</summary>
</member>
<member name="T:BerkeleyDB.Database">
<summary>
A class representing a Berkeley DB database, a base class for access
method specific classes.
</summary>
</member>
<member name="T:BerkeleyDB.BaseDatabase">
<summary>
The base class from which all database classes inherit
</summary>
</member>
<member name="M:BerkeleyDB.BaseDatabase.#ctor(BerkeleyDB.DatabaseEnvironment,System.UInt32)">
<summary>
Protected constructor
</summary>
<param name="envp">
The environment in which to create this database
</param>
<param name="flags">Flags to pass to the DB->create() method</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.#ctor(BerkeleyDB.BaseDatabase)">
<summary>
Create a new database object with the same underlying DB handle as
<paramref name="clone"/>. Used during Database.Open to get an
object of the correct DBTYPE.
</summary>
<param name="clone">Database to clone</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Open(System.String,System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Transaction)">
<summary>
Protected factory method to create and open a new database object.
</summary>
<param name="Filename">The database's filename</param>
<param name="DatabaseName">The subdatabase's name</param>
<param name="cfg">The database's configuration</param>
<param name="txn">
The transaction in which to open the database
</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Close">
<summary>
Flush any cached database information to disk, close any open
<see cref="M:BerkeleyDB.BaseDatabase.Cursor"/> objects, free any
allocated resources, and close any underlying files.
</summary>
<overloads>
<para>
Although closing a database will close any open cursors, it is
recommended that applications explicitly close all their Cursor
objects before closing the database. The reason why is that when the
cursor is explicitly closed, the memory allocated for it is
reclaimed; however, this will not happen if you close a database
while cursors are still opened.
</para>
<para>
The same rule, for the same reasons, hold true for
<see cref="T:BerkeleyDB.Transaction"/> objects. Simply make sure you resolve
all your transaction objects before closing your database handle.
</para>
<para>
Because key/data pairs are cached in memory, applications should
make a point to always either close database handles or sync their
data to disk (using <see cref="M:BerkeleyDB.BaseDatabase.Sync"/> before exiting, to
ensure that any data cached in main memory are reflected in the
underlying file system.
</para>
<para>
When called on a database that is the primary database for a
secondary index, the primary database should be closed only after
all secondary indices referencing it have been closed.
</para>
<para>
When multiple threads are using the object concurrently, only a
single thread may call the Close method.
</para>
<para>
The object may not be accessed again after Close is called,
regardless of its outcome.
</para>
</overloads>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Close(System.Boolean)">
<summary>
Optionally flush any cached database information to disk, close any
open <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/> objects, free
any allocated resources, and close any underlying files.
</summary>
<param name="sync">
If false, do not flush cached information to disk.
</param>
<remarks>
<para>
The sync parameter is a dangerous option. It should be set to false
only if the application is doing logging (with transactions) so that
the database is recoverable after a system or application crash, or
if the database is always generated from scratch after any system or
application crash.
</para>
<para>
It is important to understand that flushing cached information to
disk only minimizes the window of opportunity for corrupted data.
Although unlikely, it is possible for database corruption to happen
if a system or application crash occurs while writing data to the
database. To ensure that database corruption never occurs,
applications must either use transactions and logging with automatic
recovery or edit a copy of the database, and once all applications
using the database have successfully called Close, atomically
replace the original database with the updated copy.
</para>
<para>
Note that this parameter only works when the database has been
opened using an environment.
</para>
</remarks>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Cursor">
<summary>
Create a database cursor.
</summary>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Cursor(BerkeleyDB.CursorConfig)">
<summary>
Create a database cursor with the given configuration.
</summary>
<param name="cfg">
The configuration properties for the cursor.
</param>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Cursor(BerkeleyDB.Transaction)">
<summary>
Create a transactionally protected database cursor.
</summary>
<param name="txn">
The transaction context in which the cursor may be used.
</param>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Cursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
<summary>
Create a transactionally protected database cursor with the given
configuration.
</summary>
<param name="cfg">
The configuration properties for the cursor.
</param>
<param name="txn">
The transaction context in which the cursor may be used.
</param>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Delete(BerkeleyDB.DatabaseEntry)">
<summary>
Remove key/data pairs from the database. The key/data pair
associated with <paramref name="key"/> is discarded from the
database. In the presence of duplicate key values, all records
associated with the designated key will be discarded.
</summary>
<remarks>
<para>
When called on a secondary database, remove the key/data pair from
the primary database and all secondary indices.
</para>
<para>
If the operation occurs in a transactional database, the operation
will be implicitly transaction protected.
</para>
</remarks>
<param name="key">
Discard the key/data pair associated with <paramref name="key"/>.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Delete(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
<summary>
Remove key/data pairs from the database. The key/data pair
associated with <paramref name="key"/> is discarded from the
database. In the presence of duplicate key values, all records
associated with the designated key will be discarded.
</summary>
<remarks>
<para>
When called on a secondary database, remove the key/data pair from
the primary database and all secondary indices.
</para>
<para>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</para>
</remarks>
<param name="key">
Discard the key/data pair associated with <paramref name="key"/>.
</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Exists(BerkeleyDB.DatabaseEntry)">
<summary>
Check whether <paramref name="key"/> appears in the database.
</summary>
<remarks>
If the operation occurs in a transactional database, the operation
will be implicitly transaction protected.
</remarks>
<param name="key">The key to search for.</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
True if <paramref name="key"/> appears in the database, false
otherwise.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Exists(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
<summary>
Check whether <paramref name="key"/> appears in the database.
</summary>
<remarks>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</remarks>
<param name="key">The key to search for.</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
True if <paramref name="key"/> appears in the database, false
otherwise.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Exists(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
<summary>
Check whether <paramref name="key"/> appears in the database.
</summary>
<remarks>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</remarks>
<param name="key">The key to search for.</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<param name="info">The locking behavior to use.</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
True if <paramref name="key"/> appears in the database, false
otherwise.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry)">
<summary>
Retrieve a key/data pair from the database. In the presence of
duplicate key values, Get will return the first data item for
<paramref name="key"/>.
</summary>
<remarks>
If the operation occurs in a transactional database, the operation
will be implicitly transaction protected.
</remarks>
<param name="key">The key to search for</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
parameter is <paramref name="key"/> and whose Value parameter is the
retrieved data.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
<summary>
Retrieve a key/data pair from the database. In the presence of
duplicate key values, Get will return the first data item for
<paramref name="key"/>.
</summary>
<remarks>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</remarks>
<param name="key">The key to search for</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
parameter is <paramref name="key"/> and whose Value parameter is the
retrieved data.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
<summary>
Retrieve a key/data pair from the database. In the presence of
duplicate key values, Get will return the first data item for
<paramref name="key"/>.
</summary>
<remarks>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</remarks>
<param name="key">The key to search for</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<param name="info">The locking behavior to use.</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
parameter is <paramref name="key"/> and whose Value parameter is the
retrieved data.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo,System.UInt32)">
<summary>
Protected method to retrieve data from the underlying DB handle.
</summary>
<param name="key">
The key to search for. If null a new DatabaseEntry is created.
</param>
<param name="data">
The data to search for. If null a new DatabaseEntry is created.
</param>
<param name="txn">The txn for this operation.</param>
<param name="info">Locking info for this operation.</param>
<param name="flags">
Flags value specifying which type of get to perform. Passed
directly to DB->get().
</param>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
parameter is <paramref name="key"/> and whose Value parameter is the
retrieved data.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.GetBoth(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
<summary>
Retrieve a key/data pair from the database which matches
<paramref name="key"/> and <paramref name="data"/>.
</summary>
<remarks>
If the operation occurs in a transactional database, the operation
will be implicitly transaction protected.
</remarks>
<param name="key">The key to search for</param>
<param name="data">The data to search for</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> and
<paramref name="data"/> are not in the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
parameter is <paramref name="key"/> and whose Value parameter is
<paramref name="data"/>.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.GetBoth(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
<summary>
Retrieve a key/data pair from the database which matches
<paramref name="key"/> and <paramref name="data"/>.
</summary>
<remarks>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</remarks>
<param name="key">The key to search for</param>
<param name="data">The data to search for</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> and
<paramref name="data"/> are not in the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
parameter is <paramref name="key"/> and whose Value parameter is
<paramref name="data"/>.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.GetBoth(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
<summary>
Retrieve a key/data pair from the database which matches
<paramref name="key"/> and <paramref name="data"/>.
</summary>
<remarks>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</remarks>
<param name="key">The key to search for</param>
<param name="data">The data to search for</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<param name="info">The locking behavior to use.</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> and
<paramref name="data"/> are not in the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
parameter is <paramref name="key"/> and whose Value parameter is
<paramref name="data"/>.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.PrintFastStats">
<summary>
Display the database statistical information which does not require
traversal of the database.
</summary>
<remarks>
Among other things, this method makes it possible for applications
to request key and record counts without incurring the performance
penalty of traversing the entire database.
</remarks>
<overloads>
The statistical information is described by the
<see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
<see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes.
</overloads>
</member>
<member name="M:BerkeleyDB.BaseDatabase.PrintFastStats(System.Boolean)">
<summary>
Display the database statistical information which does not require
traversal of the database.
</summary>
<remarks>
Among other things, this method makes it possible for applications
to request key and record counts without incurring the performance
penalty of traversing the entire database.
</remarks>
<param name="PrintAll">
If true, display all available information.
</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.PrintStats">
<summary>
Display the database statistical information.
</summary>
<overloads>
The statistical information is described by the
<see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
<see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes.
</overloads>
</member>
<member name="M:BerkeleyDB.BaseDatabase.PrintStats(System.Boolean)">
<summary>
Display the database statistical information.
</summary>
<param name="PrintAll">
If true, display all available information.
</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Remove(System.String)">
<summary>
Remove the underlying file represented by
<paramref name="Filename"/>, incidentally removing all of the
databases it contained.
</summary>
<param name="Filename">The file to remove</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Remove(System.String,BerkeleyDB.DatabaseEnvironment)">
<summary>
Remove the underlying file represented by
<paramref name="Filename"/>, incidentally removing all of the
databases it contained.
</summary>
<param name="Filename">The file to remove</param>
<param name="DbEnv">
The DatabaseEnvironment the database belongs to
</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Remove(System.String,System.String)">
<summary>
Remove the database specified by <paramref name="Filename"/> and
<paramref name="DatabaseName"/>.
</summary>
<param name="Filename">The file to remove</param>
<param name="DatabaseName">The database to remove</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Remove(System.String,System.String,BerkeleyDB.DatabaseEnvironment)">
<summary>
Remove the database specified by <paramref name="Filename"/> and
<paramref name="DatabaseName"/>.
</summary>
<overloads>
<para>
Applications should never remove databases with open DB handles, or
in the case of removing a file, when any database in the file has an
open handle. For example, some architectures do not permit the
removal of files with open system handles. On these architectures,
attempts to remove databases currently in use by any thread of
control in the system may fail.
</para>
<para>
Remove should not be called if the remove is intended to be
transactionally safe;
<see cref="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.Boolean)"/> should be
used instead.
</para>
</overloads>
<param name="Filename">The file to remove</param>
<param name="DatabaseName">The database to remove</param>
<param name="DbEnv">
The DatabaseEnvironment the database belongs to
</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String)">
<summary>
Rename the underlying file represented by
<paramref name="Filename"/>, incidentally renaming all of the
databases it contained.
</summary>
<param name="Filename">The file to rename</param>
<param name="NewName">The new filename</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String,BerkeleyDB.DatabaseEnvironment)">
<summary>
Rename the underlying file represented by
<paramref name="Filename"/>, incidentally renaming all of the
databases it contained.
</summary>
<param name="Filename">The file to rename</param>
<param name="NewName">The new filename</param>
<param name="DbEnv">
The DatabaseEnvironment the database belongs to
</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String,System.String)">
<summary>
Rename the database specified by <paramref name="Filename"/> and
<paramref name="DatabaseName"/>.
</summary>
<param name="Filename">The file to rename</param>
<param name="DatabaseName">The database to rename</param>
<param name="NewName">The new database name</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Rename(System.String,System.String,System.String,BerkeleyDB.DatabaseEnvironment)">
<summary>
Rename the database specified by <paramref name="Filename"/> and
<paramref name="DatabaseName"/>.
</summary>
<overloads>
<para>
Applications should not rename databases that are currently in use.
If an underlying file is being renamed and logging is currently
enabled in the database environment, no database in the file may be
open when Rename is called. In particular, some architectures do not
permit renaming files with open handles. On these architectures,
attempts to rename databases that are currently in use by any thread
of control in the system may fail.
</para>
<para>
Rename should not be called if the rename is intended to be
transactionally safe;
<see cref="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.Boolean)"/> should be
used instead.
</para>
</overloads>
<param name="Filename">The file to rename</param>
<param name="DatabaseName">The database to rename</param>
<param name="NewName">The new database name</param>
<param name="DbEnv">
The DatabaseEnvironment the database belongs to
</param>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Sync">
<summary>
Flush any cached information to disk.
</summary>
<remarks>
<para>
If the database is in memory only, Sync has no effect and will
always succeed.
</para>
<para>
It is important to understand that flushing cached information to
disk only minimizes the window of opportunity for corrupted data.
Although unlikely, it is possible for database corruption to happen
if a system or application crash occurs while writing data to the
database. To ensure that database corruption never occurs,
applications must either: use transactions and logging with
automatic recovery or edit a copy of the database, and once all
applications using the database have successfully called
<see cref="M:BerkeleyDB.BaseDatabase.Close"/>, atomically replace
the original database with the updated copy.
</para>
</remarks>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Truncate">
<summary>
Empty the database, discarding all records it contains.
</summary>
<remarks>
If the operation occurs in a transactional database, the operation
will be implicitly transaction protected.
</remarks>
<overloads>
When called on a database configured with secondary indices,
Truncate will truncate the primary database and all secondary
indices. A count of the records discarded from the primary database
is returned.
</overloads>
<returns>
The number of records discarded from the database.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Truncate(BerkeleyDB.Transaction)">
<summary>
Empty the database, discarding all records it contains.
</summary>
<remarks>
If <paramref name="txn"/> is null and the operation occurs in a
transactional database, the operation will be implicitly transaction
protected.
</remarks>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>
The number of records discarded from the database.
</returns>
</member>
<member name="M:BerkeleyDB.BaseDatabase.Dispose">
<summary>
Release the resources held by this object, and close the database if
it's still open.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.AutoCommit">
<summary>
If true, all database modification operations based on this object
will be transactionally protected.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.CacheSize">
<summary>
The size of the shared memory buffer pool -- that is, the cache.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Creation">
<summary>
The CreatePolicy with which this database was opened.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.DatabaseName">
<summary>
The name of this database, if it has one.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.DoChecksum">
<summary>
If true, do checksum verification of pages read into the cache from
the backing filestore.
</summary>
<remarks>
Berkeley DB uses the SHA1 Secure Hash Algorithm if encryption is
configured and a general hash algorithm if it is not.
</remarks>
</member>
<member name="P:BerkeleyDB.BaseDatabase.EncryptAlgorithm">
<summary>
The algorithm used by the Berkeley DB library to perform encryption
and decryption.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Encrypted">
<summary>
If true, encrypt all data stored in the database.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Endianness">
<summary>
The database byte order.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.ErrorFeedback">
<summary>
The mechanism for reporting detailed error messages to the
application.
</summary>
<remarks>
<para>
When an error occurs in the Berkeley DB library, a
<see cref="T:BerkeleyDB.DatabaseException"/>, or subclass of DatabaseException,
is thrown. In some cases, however, the exception may be insufficient
to completely describe the cause of the error, especially during
initial application debugging.
</para>
<para>
In some cases, when an error occurs, Berkeley DB will call the given
delegate with additional error information. It is up to the delegate
to display the error message in an appropriate manner.
</para>
<para>
Setting ErrorFeedback to NULL unconfigures the callback interface.
</para>
<para>
This error-logging enhancement does not slow performance or
significantly increase application size, and may be run during
normal operation as well as during application debugging.
</para>
<para>
For databases opened inside of a DatabaseEnvironment, setting
ErrorFeedback affects the entire environment and is equivalent to
setting DatabaseEnvironment.ErrorFeedback.
</para>
<para>
For databases not opened in an environment, setting ErrorFeedback
configures operations performed using the specified object, not all
operations performed on the underlying database.
</para>
</remarks>
</member>
<member name="P:BerkeleyDB.BaseDatabase.ErrorPrefix">
<summary>
The prefix string that appears before error messages issued by
Berkeley DB.
</summary>
<remarks>
<para>
For databases opened inside of a DatabaseEnvironment, setting
ErrorPrefix affects the entire environment and is equivalent to
setting <see cref="P:BerkeleyDB.DatabaseEnvironment.ErrorPrefix"/>.
</para>
<para>
Setting ErrorPrefix configures operations performed using the
specified object, not all operations performed on the underlying
database.
</para>
</remarks>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Feedback">
<summary>
Monitor progress within long running operations.
</summary>
<remarks>
<para>
Some operations performed by the Berkeley DB library can take
non-trivial amounts of time. The Feedback delegate can be used by
applications to monitor progress within these operations. When an
operation is likely to take a long time, Berkeley DB will call the
specified delegate with progress information.
</para>
<para>
It is up to the delegate to display this information in an
appropriate manner.
</para>
</remarks>
</member>
<member name="P:BerkeleyDB.BaseDatabase.FileName">
<summary>
The filename of this database, if it has one.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.FreeThreaded">
<summary>
If true, the object is free-threaded; that is, concurrently usable
by multiple threads in the address space.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.HasMultiple">
<summary>
If true, the object references a physical file supporting multiple
databases.
</summary>
<remarks>
If true, the object is a handle on a database whose key values are
the names of the databases stored in the physical file and whose
data values are opaque objects. No keys or data values may be
modified or stored using the database handle.
</remarks>
</member>
<member name="P:BerkeleyDB.BaseDatabase.InHostOrder">
<summary>
If true, the underlying database files were created on an
architecture of the same byte order as the current one. This
information may be used to determine whether application data needs
to be adjusted for this architecture or not.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.NoMMap">
<summary>
<para>
If true, this database is not mapped into process memory.
</para>
<para>
See <see cref="P:BerkeleyDB.DatabaseEnvironment.MMapSize"/> for further
information.
</para>
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.NonDurableTxns">
<summary>
If true, Berkeley DB will not write log records for this database.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Pagesize">
<summary>
The database's current page size.
</summary>
<remarks> If <see cref="P:BerkeleyDB.DatabaseConfig.PageSize"/> was not set by
your application, then the default pagesize is selected based on the
underlying filesystem I/O block size.
</remarks>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Priority">
<summary>
The cache priority for pages referenced by this object.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.ReadOnly">
<summary>
If true, this database has been opened for reading only. Any attempt
to modify items in the database will fail, regardless of the actual
permissions of any underlying files.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.ReadUncommitted">
<summary>
If true, this database supports transactional read operations with
degree 1 isolation. Read operations on the database may request the
return of modified but not yet committed data.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Transactional">
<summary>
If true, this database has been opened in a transactional mode.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Truncated">
<summary>
If true, the underlying file was physically truncated upon open,
discarding all previous databases it might have held.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.Type">
<summary>
The type of the underlying access method (and file format). This
value may be used to determine the type of the database after an
<see cref="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)"/>.
</summary>
</member>
<member name="P:BerkeleyDB.BaseDatabase.UseMVCC">
<summary>
If true, the database was opened with support for multiversion
concurrency control.
</summary>
</member>
<member name="M:BerkeleyDB.Database.#ctor(BerkeleyDB.DatabaseEnvironment,System.UInt32)">
<summary>
Protected constructor
</summary>
<param name="env">
The environment in which to create this database
</param>
<param name="flags">Flags to pass to the DB->create() method</param>
</member>
<member name="M:BerkeleyDB.Database.#ctor(BerkeleyDB.BaseDatabase)">
<summary>
Create a new database object with the same underlying DB handle as
<paramref name="clone"/>. Used during Database.Open to get an
object of the correct DBTYPE.
</summary>
<param name="clone">Database to clone</param>
</member>
<member name="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)">
<summary>
Instantiate a new Database object and open the database represented
by <paramref name="Filename"/>. The file specified by
<paramref name="Filename"/> must exist.
</summary>
<remarks>
<para>
If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
will be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database.
</param>
<param name="cfg">The database's configuration</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.Database.Open(System.String,System.String,BerkeleyDB.DatabaseConfig)">
<summary>
Instantiate a new Database object and open the database represented
by <paramref name="Filename"/> and <paramref name="DatabaseName"/>.
The file specified by <paramref name="Filename"/> must exist.
</summary>
<remarks>
<para>
If <paramref name="Filename"/> is null and
<paramref name="DatabaseName"/> is non-null, the database can be
opened by other threads of control and will be replicated to client
sites in any replication group.
</para>
<para>
If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
will be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database. In-memory databases never intended to be preserved on disk
may be created by setting this parameter to null.</param>
<param name="DatabaseName">
This parameter allows applications to have multiple databases in a
single file. Although no DatabaseName needs to be specified, it is
an error to attempt to open a second database in a file that was not
initially created using a database name.
</param>
<param name="cfg">The database's configuration</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Transaction)">
<summary>
Instantiate a new Database object and open the database represented
by <paramref name="Filename"/>. The file specified by
<paramref name="Filename"/> must exist.
</summary>
<remarks>
<para>
If <paramref name="Filename"/> is null, the database is strictly
temporary and cannot be opened by any other thread of control, thus
the database can only be accessed by sharing the single database
object that created it, in circumstances where doing so is safe.
</para>
<para>
If <paramref name="txn"/> is null, but
<see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open. Also note that the
transaction must be committed before the object is closed.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database. In-memory databases never intended to be preserved on disk
may be created by setting this parameter to null.
</param>
<param name="cfg">The database's configuration</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.Database.Open(System.String,System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Transaction)">
<summary>
Instantiate a new Database object and open the database represented
by <paramref name="Filename"/> and <paramref name="DatabaseName"/>.
The file specified by <paramref name="Filename"/> must exist.
</summary>
<remarks>
<para>
If both <paramref name="Filename"/> and
<paramref name="DatabaseName"/> are null, the database is strictly
temporary and cannot be opened by any other thread of control, thus
the database can only be accessed by sharing the single database
object that created it, in circumstances where doing so is safe. If
<paramref name="Filename"/> is null and
<paramref name="DatabaseName"/> is non-null, the database can be
opened by other threads of control and will be replicated to client
sites in any replication group.
</para>
<para>
If <paramref name="txn"/> is null, but
<see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open. Also note that the
transaction must be committed before the object is closed.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database. In-memory databases never intended to be preserved on disk
may be created by setting this parameter to null.
</param>
<param name="DatabaseName">
This parameter allows applications to have multiple databases in a
single file. Although no DatabaseName needs to be specified, it is
an error to attempt to open a second database in a file that was not
initially created using a database name.
</param>
<param name="cfg">The database's configuration</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
<summary>
If a key/data pair in the database matches <paramref name="key"/>
and <paramref name="data"/>, return the key and all duplicate data
items.
</summary>
<param name="key">The key to search for</param>
<param name="data">The data to search for</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> and
<paramref name="data"/> are not in the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)">
<summary>
If a key/data pair in the database matches <paramref name="key"/>
and <paramref name="data"/>, return the key and all duplicate data
items.
</summary>
<param name="key">The key to search for</param>
<param name="data">The data to search for</param>
<param name="BufferSize">
The initial size of the buffer to fill with duplicate data items. If
the buffer is not large enough, it will be automatically resized.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> and
<paramref name="data"/> are not in the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction)">
<summary>
If a key/data pair in the database matches <paramref name="key"/>
and <paramref name="data"/>, return the key and all duplicate data
items.
</summary>
<param name="key">The key to search for</param>
<param name="data">The data to search for</param>
<param name="BufferSize">
The initial size of the buffer to fill with duplicate data items. If
the buffer is not large enough, it will be automatically resized.
</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> and
<paramref name="data"/> are not in the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.GetBothMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
<summary>
If a key/data pair in the database matches <paramref name="key"/>
and <paramref name="data"/>, return the key and all duplicate data
items.
</summary>
<param name="key">The key to search for</param>
<param name="data">The data to search for</param>
<param name="BufferSize">
The initial size of the buffer to fill with duplicate data items. If
the buffer is not large enough, it will be automatically resized.
</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<param name="info">The locking behavior to use.</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> and
<paramref name="data"/> are not in the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry)">
<summary>
Retrieve a key and all duplicate data items from the database.
</summary>
<param name="key">The key to search for</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry,System.Int32)">
<summary>
Retrieve a key and all duplicate data items from the database.
</summary>
<param name="key">The key to search for</param>
<param name="BufferSize">
The initial size of the buffer to fill with duplicate data items. If
the buffer is not large enough, it will be automatically resized.
</param>
<exception cref="T:BerkeleyDB.NotFoundException">
A NotFoundException is thrown if <paramref name="key"/> is not in
the database.
</exception>
<exception cref="T:BerkeleyDB.KeyEmptyException">
A KeyEmptyException is thrown if the database is a
<see cref="T:BerkeleyDB.QueueDatabase"/> or <see cref="T:BerkeleyDB.RecnoDatabase"/>
database and <paramref name="key"/> exists, but was never explicitly
created by the application or was later deleted.
</exception>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction)">
<summary>
Retrieve a key and all duplicate data items from the database.
</summary>
<param name="key">The key to search for</param>
<param name="BufferSize">
The initial size of the buffer to fill with duplicate data items. If
the buffer is not large enough, it will be automatically resized.
</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.GetMultiple(BerkeleyDB.DatabaseEntry,System.Int32,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
<summary>
Retrieve a key and all duplicate data items from the database.
</summary>
<param name="key">The key to search for</param>
<param name="BufferSize">
The initial size of the buffer to fill with duplicate data items. If
the buffer is not large enough, it will be automatically resized.
</param>
<param name="txn">
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<param name="info">The locking behavior to use.</param>
<returns>
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/>
whose Key parameter is <paramref name="key"/> and whose Value
parameter is the retrieved data items.
</returns>
</member>
<member name="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)">
<summary>
Create a specialized join cursor for use in performing equality or
natural joins on secondary indices.
</summary>
<remarks>
<para>
Once the cursors have been passed as part of <paramref name="lst"/>,
they should not be accessed or modified until the newly created
<see cref="T:BerkeleyDB.JoinCursor"/>has been closed, or else inconsistent
results may be returned.
</para>
<para>
Joined values are retrieved by doing a sequential iteration over the
first cursor in <paramref name="lst"/>, and a nested iteration over
each secondary cursor in the order they are specified in the
curslist parameter. This requires database traversals to search for
the current datum in all the cursors after the first. For this
reason, the best join performance normally results from sorting the
cursors from the one that refers to the least number of data items
to the one that refers to the most.
</para>
</remarks>
<param name="lst">
An array of SecondaryCursors. Each cursor must have been initialized
to refer to the key on which the underlying database should be
joined.
</param>
<param name="sortCursors">
If true, sort the cursors from the one that refers to the least
number of data items to the one that refers to the most. If the
data are structured so that cursors with many data items also share
many common elements, higher performance will result from listing
those cursors before cursors with fewer data items; that is, a sort
order other than the default. A setting of false permits
applications to perform join optimization prior to calling Join.
</param>
<returns>
A specialized join cursor for use in performing equality or natural
joins on secondary indices.
</returns>
</member>
<member name="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
<summary>
Store the key/data pair in the database, replacing any previously
existing key if duplicates are disallowed, or adding a duplicate
data item if duplicates are allowed.
</summary>
<overloads>
<para>
If the database supports duplicates, add the new data value at the
end of the duplicate set. If the database supports sorted
duplicates, the new data value is inserted at the correct sorted
location.
</para>
</overloads>
<param name="key">The key to store in the database</param>
<param name="data">The data item to store in the database</param>
</member>
<member name="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
<summary>
Store the key/data pair in the database, replacing any previously
existing key if duplicates are disallowed, or adding a duplicate
data item if duplicates are allowed.
</summary>
<param name="key">The key to store in the database</param>
<param name="data">The data item to store in the database</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
</member>
<member name="M:BerkeleyDB.Database.PutNoOverwrite(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
<summary>
Store the key/data pair in the database, only if the key does not
already appear in the database.
</summary>
<remarks>
This enforcement of uniqueness of keys applies only to the primary
key, the behavior of insertions into secondary databases is not
affected. In particular, the insertion of a record that would result
in the creation of a duplicate key in a secondary database that
allows duplicates would not be prevented by the use of this flag.
</remarks>
<param name="key">The key to store in the database</param>
<param name="data">The data item to store in the database</param>
</member>
<member name="M:BerkeleyDB.Database.PutNoOverwrite(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
<summary>
Store the key/data pair in the database, only if the key does not
already appear in the database.
</summary>
<remarks>
This enforcement of uniqueness of keys applies only to the primary
key, the behavior of insertions into secondary databases is not
affected. In particular, the insertion of a record that would result
in the creation of a duplicate key in a secondary database that
allows duplicates would not be prevented by the use of this flag.
</remarks>
<param name="key">The key to store in the database</param>
<param name="data">The data item to store in the database</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
</member>
<member name="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction,System.UInt32)">
<summary>
Protected wrapper for DB->put. Used by subclasses for access method
specific operations.
</summary>
<param name="key">The key to store in the database</param>
<param name="data">The data item to store in the database</param>
<param name="txn">Transaction with which to protect the put</param>
<param name="flags">Flags to pass to DB->put</param>
</member>
<member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig)">
<summary>
Write the key/data pairs from all databases in the file to
<see cref="P:System.Console.Out"/>. Key values are written for Btree, Hash
and Queue databases, but not for Recno databases.
</summary>
<param name="file">
The physical file in which the databases to be salvaged are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be salvaged.
</param>
</member>
<member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean)">
<summary>
Write the key/data pairs from all databases in the file to
<see cref="P:System.Console.Out"/>. Key values are written for Btree, Hash
and Queue databases, but not for Recno databases.
</summary>
<param name="file">
The physical file in which the databases to be salvaged are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be salvaged.
</param>
<param name="Printable">
If true and characters in either the key or data items are printing
characters (as defined by isprint(3)), use printing characters to
represent them. This setting permits users to use standard text
editors and tools to modify the contents of databases or selectively
remove data from salvager output.
</param>
</member>
<member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.IO.TextWriter)">
<summary>
Write the key/data pairs from all databases in the file to
<paramref name="OutputStream"/>. Key values are written for Btree,
Hash and Queue databases, but not for Recno databases.
</summary>
<param name="file">
The physical file in which the databases to be salvaged are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be salvaged.
</param>
<param name="OutputStream">
The TextWriter to which the databases' key/data pairs are written.
If null, <see cref="P:System.Console.Out"/> will be used.
</param>
</member>
<member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean,System.IO.TextWriter)">
<summary>
Write the key/data pairs from all databases in the file to
<paramref name="OutputStream"/>. Key values are written for Btree,
Hash and Queue databases, but not for Recno databases.
</summary>
<param name="file">
The physical file in which the databases to be salvaged are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be salvaged.
</param>
<param name="Printable">
If true and characters in either the key or data items are printing
characters (as defined by isprint(3)), use printing characters to
represent them. This setting permits users to use standard text
editors and tools to modify the contents of databases or selectively
remove data from salvager output.
</param>
<param name="OutputStream">
The TextWriter to which the databases' key/data pairs are written.
If null, <see cref="P:System.Console.Out"/> will be used.
</param>
</member>
<member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean,System.Boolean)">
<summary>
Write the key/data pairs from all databases in the file to
<see cref="P:System.Console.Out"/>. Key values are written for Btree, Hash
and Queue databases, but not for Recno databases.
</summary>
<param name="file">
The physical file in which the databases to be salvaged are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be salvaged.
</param>
<param name="Printable">
If true and characters in either the key or data items are printing
characters (as defined by isprint(3)), use printing characters to
represent them. This setting permits users to use standard text
editors and tools to modify the contents of databases or selectively
remove data from salvager output.
</param>
<param name="Aggressive">
If true, output all the key/data pairs in the file that can be
found. Corruption will be assumed and key/data pairs that are
corrupted or have been deleted may appear in the output (even if the
file being salvaged is in no way corrupt), and the output will
almost certainly require editing before being loaded into a
database.
</param>
</member>
<member name="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig,System.Boolean,System.Boolean,System.IO.TextWriter)">
<summary>
Write the key/data pairs from all databases in the file to
<paramref name="OutputStream"/>. Key values are written for Btree,
Hash and Queue databases, but not for Recno databases.
</summary>
<param name="file">
The physical file in which the databases to be salvaged are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be salvaged.
</param>
<param name="Printable">
If true and characters in either the key or data items are printing
characters (as defined by isprint(3)), use printing characters to
represent them. This setting permits users to use standard text
editors and tools to modify the contents of databases or selectively
remove data from salvager output.
</param>
<param name="Aggressive">
If true, output all the key/data pairs in the file that can be
found. Corruption will be assumed and key/data pairs that are
corrupted or have been deleted may appear in the output (even if the
file being salvaged is in no way corrupt), and the output will
almost certainly require editing before being loaded into a
database.
</param>
<param name="OutputStream">
The TextWriter to which the databases' key/data pairs are written.
If null, <see cref="P:System.Console.Out"/> will be used.
</param>
</member>
<member name="M:BerkeleyDB.Database.Upgrade(System.String,BerkeleyDB.DatabaseConfig)">
<summary>
Upgrade all of the databases included in the file
<paramref name="file"/>, if necessary. If no upgrade is necessary,
Upgrade always returns successfully.
</summary>
<param name="file">
The physical file containing the databases to be upgraded.
</param>
<param name="cfg">
Configuration parameters for the databases to be upgraded.
</param>
</member>
<member name="M:BerkeleyDB.Database.Upgrade(System.String,BerkeleyDB.DatabaseConfig,System.Boolean)">
<summary>
Upgrade all of the databases included in the file
<paramref name="file"/>, if necessary. If no upgrade is necessary,
Upgrade always returns successfully.
</summary>
<overloads>
Database upgrades are done in place and are destructive. For
example, if pages need to be allocated and no disk space is
available, the database may be left corrupted. Backups should be
made before databases are upgraded. See Upgrading databases in the
Programmer's Reference Guide for more information.
</overloads>
<remarks>
<para>
As part of the upgrade from the Berkeley DB 3.0 release to the 3.1
release, the on-disk format of duplicate data items changed. To
correctly upgrade the format requires applications to specify
whether duplicate data items in the database are sorted or not.
Specifying <paramref name="dupSortUpgraded"/> informs Upgrade that
the duplicates are sorted; otherwise they are assumed to be
unsorted. Incorrectly specifying the value of this flag may lead to
database corruption.
</para>
<para>
Further, because this method upgrades a physical file (including all
the databases it contains), it is not possible to use Upgrade to
upgrade files in which some of the databases it includes have sorted
duplicate data items, and some of the databases it includes have
unsorted duplicate data items. If the file does not have more than a
single database, if the databases do not support duplicate data
items, or if all of the databases that support duplicate data items
support the same style of duplicates (either sorted or unsorted),
Upgrade will work correctly as long as
<paramref name="dupSortUpgraded"/> is correctly specified.
Otherwise, the file cannot be upgraded using Upgrade it must be
upgraded manually by dumping and reloading the databases.
</para>
</remarks>
<param name="file">
The physical file containing the databases to be upgraded.
</param>
<param name="cfg">
Configuration parameters for the databases to be upgraded.
</param>
<param name="dupSortUpgraded">
If true, the duplicates in the upgraded database are sorted;
otherwise they are assumed to be unsorted. This setting is only
meaningful when upgrading databases from releases before the
Berkeley DB 3.1 release.
</param>
</member>
<member name="M:BerkeleyDB.Database.Verify(System.String,BerkeleyDB.DatabaseConfig)">
<summary>
Verify the integrity of all databases in the file specified by
<paramref name="file"/>.
</summary>
<overloads>
Verify does not perform any locking, even in Berkeley DB
environments that are configured with a locking subsystem. As such,
it should only be used on files that are not being modified by
another thread of control.
</overloads>
<param name="file">
The physical file in which the databases to be verified are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be verified.
</param>
</member>
<member name="M:BerkeleyDB.Database.Verify(System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Database.VerifyOperation)">
<summary>
Verify the integrity of all databases in the file specified by
<paramref name="file"/>.
</summary>
<remarks>
<para>
Berkeley DB normally verifies that btree keys and duplicate items
are correctly sorted, and hash keys are correctly hashed. If the
file being verified contains multiple databases using differing
sorting or hashing algorithms, some of them must necessarily fail
database verification because only one sort order or hash function
can be specified in <paramref name="cfg"/>. To verify files with
multiple databases having differing sorting orders or hashing
functions, first perform verification of the file as a whole by
using <see cref="F:BerkeleyDB.Database.VerifyOperation.NO_ORDER_CHECK"/>, and then
individually verify the sort order and hashing function for each
database in the file using
<see cref="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY"/>.
</para>
</remarks>
<param name="file">
The physical file in which the databases to be verified are found.
</param>
<param name="cfg">
Configuration parameters for the databases to be verified.
</param>
<param name="op">The extent of verification</param>
</member>
<member name="M:BerkeleyDB.Database.Verify(System.String,System.String,BerkeleyDB.DatabaseConfig,BerkeleyDB.Database.VerifyOperation)">
<summary>
Verify the integrity of the database specified by
<paramref name="file"/> and <paramref name="database"/>.
</summary>
<remarks>
<para>
Berkeley DB normally verifies that btree keys and duplicate items
are correctly sorted, and hash keys are correctly hashed. If the
file being verified contains multiple databases using differing
sorting or hashing algorithms, some of them must necessarily fail
database verification because only one sort order or hash function
can be specified in <paramref name="cfg"/>. To verify files with
multiple databases having differing sorting orders or hashing
functions, first perform verification of the file as a whole by
using <see cref="F:BerkeleyDB.Database.VerifyOperation.NO_ORDER_CHECK"/>, and then
individually verify the sort order and hashing function for each
database in the file using
<see cref="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY"/>.
</para>
</remarks>
<param name="file">
The physical file in which the databases to be verified are found.
</param>
<param name="database">
The database in <paramref name="file"/> on which the database checks
for btree and duplicate sort order and for hashing are to be
performed. A non-null value for database is only allowed with
<see cref="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY"/>.
</param>
<param name="cfg">
Configuration parameters for the databases to be verified.
</param>
<param name="op">The extent of verification</param>
</member>
<member name="T:BerkeleyDB.Database.VerifyOperation">
<summary>
Specifies the type of verification to perform
</summary>
</member>
<member name="F:BerkeleyDB.Database.VerifyOperation.DEFAULT">
<summary>
Perform database checks and check sort order
</summary>
</member>
<member name="F:BerkeleyDB.Database.VerifyOperation.ORDER_CHECK_ONLY">
<summary>
Perform the database checks for btree and duplicate sort order
and for hashing
</summary>
</member>
<member name="F:BerkeleyDB.Database.VerifyOperation.NO_ORDER_CHECK">
<summary>
Skip the database checks for btree and duplicate sort order and
for hashing.
</summary>
</member>
<member name="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)">
<summary>
Instantiate a new HashDatabase object and open the database
represented by <paramref name="Filename"/>.
</summary>
<remarks>
<para>
If <paramref name="Filename"/> is null, the database is strictly
temporary and cannot be opened by any other thread of control, thus
the database can only be accessed by sharing the single database
object that created it, in circumstances where doing so is safe.
</para>
<para>
If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
will be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database. In-memory databases never intended to be preserved on disk
may be created by setting this parameter to null.
</param>
<param name="cfg">The database's configuration</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Open(System.String,System.String,BerkeleyDB.HashDatabaseConfig)">
<summary>
Instantiate a new HashDatabase object and open the database
represented by <paramref name="Filename"/> and
<paramref name="DatabaseName"/>.
</summary>
<remarks>
<para>
If both <paramref name="Filename"/> and
<paramref name="DatabaseName"/> are null, the database is strictly
temporary and cannot be opened by any other thread of control, thus
the database can only be accessed by sharing the single database
object that created it, in circumstances where doing so is safe. If
<paramref name="Filename"/> is null and
<paramref name="DatabaseName"/> is non-null, the database can be
opened by other threads of control and will be replicated to client
sites in any replication group.
</para>
<para>
If <see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation
will be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database. In-memory databases never intended to be preserved on disk
may be created by setting this parameter to null.
</param>
<param name="DatabaseName">
This parameter allows applications to have multiple databases in a
single file. Although no DatabaseName needs to be specified, it is
an error to attempt to open a second database in a file that was not
initially created using a database name.
</param>
<param name="cfg">The database's configuration</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig,BerkeleyDB.Transaction)">
<summary>
Instantiate a new HashDatabase object and open the database
represented by <paramref name="Filename"/>.
</summary>
<remarks>
<para>
If <paramref name="Filename"/> is null, the database is strictly
temporary and cannot be opened by any other thread of control, thus
the database can only be accessed by sharing the single database
object that created it, in circumstances where doing so is safe.
</para>
<para>
If <paramref name="txn"/> is null, but
<see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open. Also note that the
transaction must be committed before the object is closed.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database. In-memory databases never intended to be preserved on disk
may be created by setting this parameter to null.
</param>
<param name="cfg">The database's configuration</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Open(System.String,System.String,BerkeleyDB.HashDatabaseConfig,BerkeleyDB.Transaction)">
<summary>
Instantiate a new HashDatabase object and open the database
represented by <paramref name="Filename"/> and
<paramref name="DatabaseName"/>.
</summary>
<remarks>
<para>
If both <paramref name="Filename"/> and
<paramref name="DatabaseName"/> are null, the database is strictly
temporary and cannot be opened by any other thread of control, thus
the database can only be accessed by sharing the single database
object that created it, in circumstances where doing so is safe. If
<paramref name="Filename"/> is null and
<paramref name="DatabaseName"/> is non-null, the database can be
opened by other threads of control and will be replicated to client
sites in any replication group.
</para>
<para>
If <paramref name="txn"/> is null, but
<see cref="F:BerkeleyDB.DatabaseConfig.AutoCommit"/> is set, the operation will
be implicitly transaction protected. Note that transactionally
protected operations on a datbase object requires the object itself
be transactionally protected during its open. Also note that the
transaction must be committed before the object is closed.
</para>
</remarks>
<param name="Filename">
The name of an underlying file that will be used to back the
database. In-memory databases never intended to be preserved on disk
may be created by setting this parameter to null.
</param>
<param name="DatabaseName">
This parameter allows applications to have multiple databases in a
single file. Although no DatabaseName needs to be specified, it is
an error to attempt to open a second database in a file that was not
initially created using a database name.
</param>
<param name="cfg">The database's configuration</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>A new, open database object</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Cursor">
<summary>
Create a database cursor.
</summary>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Cursor(BerkeleyDB.CursorConfig)">
<summary>
Create a database cursor with the given configuration.
</summary>
<param name="cfg">
The configuration properties for the cursor.
</param>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Cursor(BerkeleyDB.Transaction)">
<summary>
Create a transactionally protected database cursor.
</summary>
<param name="txn">
The transaction context in which the cursor may be used.
</param>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Cursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
<summary>
Create a transactionally protected database cursor with the given
configuration.
</summary>
<param name="cfg">
The configuration properties for the cursor.
</param>
<param name="txn">
The transaction context in which the cursor may be used.
</param>
<returns>A newly created cursor</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.FastStats">
<summary>
Return the database statistical information which does not require
traversal of the database.
</summary>
<returns>
The database statistical information which does not require
traversal of the database.
</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.FastStats(BerkeleyDB.Transaction)">
<summary>
Return the database statistical information which does not require
traversal of the database.
</summary>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>
The database statistical information which does not require
traversal of the database.
</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.FastStats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
<summary>
Return the database statistical information which does not require
traversal of the database.
</summary>
<overloads>
<para>
Among other things, this method makes it possible for applications
to request key and record counts without incurring the performance
penalty of traversing the entire database.
</para>
<para>
The statistical information is described by the
<see cref="T:BerkeleyDB.BTreeStats"/>, <see cref="T:BerkeleyDB.HashStats"/>,
<see cref="T:BerkeleyDB.QueueStats"/>, and <see cref="T:BerkeleyDB.RecnoStats"/> classes.
</para>
</overloads>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<param name="isoDegree">
The level of isolation for database reads.
<see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for
databases which did not specify
<see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
</param>
<returns>
The database statistical information which does not require
traversal of the database.
</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.TruncateUnusedPages">
<summary>
Return pages to the filesystem that are already free and at the end
of the file.
</summary>
<returns>
The number of database pages returned to the filesystem
</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.TruncateUnusedPages(BerkeleyDB.Transaction)">
<summary>
Return pages to the filesystem that are already free and at the end
of the file.
</summary>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>
The number of database pages returned to the filesystem
</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)">
<summary>
Store the key/data pair in the database only if it does not already
appear in the database.
</summary>
<param name="key">The key to store in the database</param>
<param name="data">The data item to store in the database</param>
</member>
<member name="M:BerkeleyDB.HashDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
<summary>
Store the key/data pair in the database only if it does not already
appear in the database.
</summary>
<param name="key">The key to store in the database</param>
<param name="data">The data item to store in the database</param>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
</member>
<member name="M:BerkeleyDB.HashDatabase.Stats">
<summary>
Return the database statistical information for this database.
</summary>
<returns>Database statistical information.</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Stats(BerkeleyDB.Transaction)">
<summary>
Return the database statistical information for this database.
</summary>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<returns>Database statistical information.</returns>
</member>
<member name="M:BerkeleyDB.HashDatabase.Stats(BerkeleyDB.Transaction,BerkeleyDB.Isolation)">
<summary>
Return the database statistical information for this database.
</summary>
<overloads>
The statistical information is described by
<see cref="T:BerkeleyDB.BTreeStats"/>.
</overloads>
<param name="txn">
If the operation is part of an application-specified transaction,
<paramref name="txn"/> is a Transaction object returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>; if
the operation is part of a Berkeley DB Concurrent Data Store group,
<paramref name="txn"/> is a handle returned from
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
</param>
<param name="isoDegree">
The level of isolation for database reads.
<see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> will be silently ignored for
databases which did not specify
<see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>.
</param>
<returns>Database statistical information.</returns>
</member>
<member name="P:BerkeleyDB.HashDatabase.Compare">
<summary>
The Hash key comparison function. The comparison function is called
whenever it is necessary to compare a key specified by the
application with a key currently stored in the tree.
</summary>
</member>
<member name="P:BerkeleyDB.HashDatabase.DupCompare">
<summary>
The duplicate data item comparison function.
</summary>
</member>
<member name="P:BerkeleyDB.HashDatabase.Duplicates">
<summary>
Whether the insertion of duplicate data items in the database is
permitted, and whether duplicates items are sorted.
</summary>
</member>
<member name="P:BerkeleyDB.HashDatabase.FillFactor">
<summary>
The desired density within the hash table.
</summary>
</member>
<member name="P:BerkeleyDB.HashDatabase.HashFunction">
<summary>
A user-defined hash function; if no hash function is specified, a
default hash function is used.
</summary>
</member>
<member name="P:BerkeleyDB.HashDatabase.TableSize">
<summary>
An estimate of the final size of the hash table.
</summary>
</member>
<member name="T:BerkeleyDB.DatabaseEnvironment">
<summary>
A class representing a Berkeley DB database environment - a collection
including support for some or all of caching, locking, logging and
transaction subsystems, as well as databases and log files.
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepSetClockskew(System.UInt32,System.UInt32)">
<summary>
Set the clock skew ratio among replication group members based on
the fastest and slowest measurements among the group for use with
master leases.
</summary>
<remarks>
<para>
Calling this method is optional, the default values for clock skew
assume no skew. The user must also configure leases via
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepUseMasterLeases"/>. Additionally, the user must also
set the master lease timeout via <see cref="P:BerkeleyDB.DatabaseEnvironment.RepLeaseTimeout"/> and
the number of sites in the replication group via
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/>. These settings may be configured in any
order. For a description of the clock skew values, see Clock skew
in the Berkeley DB Programmer's Reference Guide. For a description
of master leases, see Master leases in the Berkeley DB Programmer's
Reference Guide.
</para>
<para>
These arguments can be used to express either raw measurements of a
clock timing experiment or a percentage across machines. For
instance a group of sites have a 2% variance, then
<paramref name="fast"/> should be set to 102, and
<paramref name="slow"/> should be set to 100. Or, for a 0.03%
difference, you can use 10003 and 10000 respectively.
</para>
</remarks>
<param name="fast">
The value, relative to <paramref name="slow"/>, of the fastest clock
in the group of sites.
</param>
<param name="slow">
The value of the slowest clock in the group of sites.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepSetRetransmissionRequest(System.UInt32,System.UInt32)">
<summary>
Set a threshold for the minimum and maximum time that a client waits
before requesting retransmission of a missing message.
</summary>
<remarks>
<para>
If the client detects a gap in the sequence of incoming log records
or database pages, Berkeley DB will wait for at least
<paramref name="min"/> microseconds before requesting retransmission
of the missing record. Berkeley DB will double that amount before
requesting the same missing record again, and so on, up to a
maximum threshold of <paramref name="max"/> microseconds.
</para>
<para>
These values are thresholds only. Since Berkeley DB has no thread
available in the library as a timer, the threshold is only checked
when a thread enters the Berkeley DB library to process an incoming
replication message. Any amount of time may have passed since the
last message arrived and Berkeley DB only checks whether the amount
of time since a request was made is beyond the threshold value or
not.
</para>
<para>
By default the minimum is 40000 and the maximum is 1280000 (1.28
seconds). These defaults are fairly arbitrary and the application
likely needs to adjust these. The values should be based on expected
load and performance characteristics of the master and client host
platforms and transport infrastructure as well as round-trip message
time.
</para></remarks>
<param name="min">
The minimum number of microseconds a client waits before requesting
retransmission.
</param>
<param name="max">
The maximum number of microseconds a client waits before requesting
retransmission.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepSetTransmitLimit(System.UInt32,System.UInt32)">
<summary>
Set a byte-count limit on the amount of data that will be
transmitted from a site in response to a single message processed by
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>. The limit is not a hard limit, and
the record that exceeds the limit is the last record to be sent.
</summary>
<remarks>
<para>
Record transmission throttling is turned on by default with a limit
of 10MB.
</para>
<para>
If both <paramref name="GBytes"/> and <paramref name="Bytes"/> are
zero, then the transmission limit is turned off.
</para>
</remarks>
<param name="GBytes">
The number of gigabytes which, when added to
<paramref name="Bytes"/>, specifies the maximum number of bytes that
will be sent in a single call to <see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
</param>
<param name="Bytes">
The number of bytes which, when added to
<paramref name="GBytes"/>, specifies the maximum number of bytes
that will be sent in a single call to
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepSetTransport(System.Int32,BerkeleyDB.ReplicationTransportDelegate)">
<summary>
Initialize the communication infrastructure for a database
environment participating in a replicated application.
</summary>
<remarks>
RepSetTransport is not called by most replication applications. It
should only be called by applications implementing their own network
transport layer, explicitly holding replication group elections and
handling replication messages outside of the replication manager
framework.
</remarks>
<param name="envid">
The local environment's ID. It must be a non-negative integer and
uniquely identify this Berkeley DB database environment (see
Replication environment IDs in the Programmer's Reference Guide for
more information).
</param>
<param name="transport">
The delegate used to transmit data using the replication
application's communication infrastructure.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)">
<summary>
Instantiate a new DatabaseEnvironment object and open the Berkeley
DB environment represented by <paramref name="home"/>.
</summary>
<param name="home">
The database environment's home directory. For more information on
home, and filename resolution in general, see Berkeley DB File
Naming in the Programmer's Reference Guide.
</param>
<param name="cfg">The environment's configuration</param>
<returns>A new, open DatabaseEnvironment object</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Remove(System.String)">
<summary>
Destroy a Berkeley DB environment if it is not currently in use.
</summary>
<overloads>
<para>
The environment regions, including any backing files, are removed.
Any log or database files and the environment directory are not
removed.
</para>
<para>
If there are processes that have called <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> without
calling <see cref="M:BerkeleyDB.DatabaseEnvironment.Close"/> (that is, there are processes currently
using the environment), Remove will fail without further action.
</para>
<para>
Calling Remove should not be necessary for most applications because
the Berkeley DB environment is cleaned up as part of normal database
recovery procedures. However, applications may want to call Remove
as part of application shut down to free up system resources. For
example, if <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.SystemMemory"/> was
specified to <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/>, it may be useful to call Remove in
order to release system shared memory segments that have been
allocated. Or, on architectures in which mutexes require allocation
of underlying system resources, it may be useful to call Remove in
order to release those resources. Alternatively, if recovery is not
required because no database state is maintained across failures,
and no system resources need to be released, it is possible to clean
up an environment by simply removing all the Berkeley DB files in
the database environment's directories.
</para>
<para>
In multithreaded applications, only a single thread may call Remove.
</para>
</overloads>
<param name="db_home">
The database environment to be removed.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Remove(System.String,System.Boolean)">
<summary>
Destroy a Berkeley DB environment if it is not currently in use.
</summary>
<remarks>
<para>
Generally, <paramref name="force"/> is specified only when
applications were unable to shut down cleanly, and there is a risk
that an application may have died holding a Berkeley DB lock.)
</para>
<para>
The result of attempting to forcibly destroy the environment when it
is in use is unspecified. Processes using an environment often
maintain open file descriptors for shared regions within it. On UNIX
systems, the environment removal will usually succeed, and processes
that have already joined the region will continue to run in that
region without change. However, processes attempting to join the
environment will either fail or create new regions. On other systems
in which the unlink(2) system call will fail if any process has an
open file descriptor for the file (for example Windows/NT), the
region removal will fail.
</para>
</remarks>
<param name="db_home">
The database environment to be removed.
</param>
<param name="force">
If true, the environment is removed, regardless of any processes
that may still using it, and no locks are acquired during this
process.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection">
<summary>
Hold an election for the master of a replication group.
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection(System.UInt32)">
<summary>
Hold an election for the master of a replication group.
</summary>
<param name="nsites">
The number of replication sites expected to participate in the
election. Once the current site has election information from that
many sites, it will short-circuit the election and immediately cast
its vote for a new master. This parameter must be no less than
<paramref name="nvotes"/>, or 0 if the election should use
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/>. If an application is using master leases,
then the value must be 0 and <see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/> must be used.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection(System.UInt32,System.UInt32)">
<summary>
Hold an election for the master of a replication group.
</summary>
<overloads>
<para>
RepHoldElection is not called by most replication applications. It
should only be called by applications implementing their own network
transport layer, explicitly holding replication group elections and
handling replication messages outside of the replication manager
framework.
</para>
<para>
If the election is successful, Berkeley DB will notify the
application of the results of the election by means of either the
<see cref="F:BerkeleyDB.NotificationEvent.REP_ELECTED"/> or
<see cref="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER"/> events (see
<see cref="P:BerkeleyDB.DatabaseEnvironment.EventNotify"/>for more information). The application is
responsible for adjusting its relationship to the other database
environments in the replication group, including directing all
database updates to the newly selected master, in accordance with
the results of the election.
</para>
<para>
The thread of control that calls RepHoldElection must not be the
thread of control that processes incoming messages; processing the
incoming messages is necessary to successfully complete an election.
</para>
<para>
Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate
must already have been configured to send replication messages.
</para>
</overloads>
<param name="nsites">
The number of replication sites expected to participate in the
election. Once the current site has election information from that
many sites, it will short-circuit the election and immediately cast
its vote for a new master. This parameter must be no less than
<paramref name="nvotes"/>, or 0 if the election should use
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/>. If an application is using master leases,
then the value must be 0 and <see cref="P:BerkeleyDB.DatabaseEnvironment.RepNSites"/> must be used.
</param>
<param name="nvotes">
The minimum number of replication sites from which the current site
must have election information, before the current site will cast a
vote for a new master. This parameter must be no greater than
<paramref name="nsites"/>, or 0 if the election should use the value
((<paramref name="nsites"/> / 2) + 1).
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress)">
<summary>
Add a new replication site to the replication manager's list of
known sites. It is not necessary for all sites in a replication
group to know about all other sites in the group.
</summary>
<param name="Host">The remote site's address</param>
<returns>The environment ID assigned to the remote site</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress,System.Boolean)">
<summary>
Add a new replication site to the replication manager's list of
known sites. It is not necessary for all sites in a replication
group to know about all other sites in the group.
</summary>
<remarks>
Currently, the replication manager framework only supports a single
client peer, and the last specified peer is used.
</remarks>
<param name="Host">The remote site's address</param>
<param name="isPeer">
If true, configure client-to-client synchronization with the
specified remote site.
</param>
<returns>The environment ID assigned to the remote site</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)">
<summary>
Start the replication manager as a client site, and do not call for
an election.
</summary>
<overloads>
<para>
There are two ways to build Berkeley DB replication applications:
the most common approach is to use the Berkeley DB library
"replication manager" support, where the Berkeley DB library manages
the replication group, including network transport, all replication
message processing and acknowledgment, and group elections.
Applications using the replication manager support generally make
the following calls:
</para>
<list type="number">
<item>
Configure the local site in the replication group,
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrLocalSite"/>.
</item>
<item>
Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress)"/> to configure the remote
site(s) in the replication group.
</item>
<item>Configure the message acknowledgment policy
(<see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrAckPolicy"/>) which provides the replication group's
transactional needs.
</item>
<item>
Configure the local site's election priority,
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepPriority"/>.
</item>
<item>
Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/> or
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/> to start the replication
application.
</item>
</list>
<para>
For more information on building replication manager applications,
please see the Replication Getting Started Guide included in the
Berkeley DB documentation.
</para>
<para>
Applications with special needs (for example, applications using
network protocols not supported by the Berkeley DB replication
manager), must perform additional configuration and call other
Berkeley DB replication methods. For more information on building
advanced replication applications, please see the Base Replication
API section in the Berkeley DB Programmer's Reference Guide for more
information.
</para>
<para>
Starting the replication manager consists of opening the TCP/IP
listening socket to accept incoming connections, and starting all
necessary background threads. When multiple processes share a
database environment, only one process can open the listening
socket; <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/> (and
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/>) automatically open the socket in
the first process to call it, and skips this step in the later calls
from other processes.
</para>
</overloads>
<param name="nthreads">
Specify the number of threads of control created and dedicated to
processing replication messages. In addition to these message
processing threads, the replication manager creates and manages a
few of its own threads of control.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32,System.Boolean)">
<summary>
Start the replication manager as a client site, and optionally call
for an election.
</summary>
<param name="nthreads">
Specify the number of threads of control created and dedicated to
processing replication messages. In addition to these message
processing threads, the replication manager creates and manages a
few of its own threads of control.
</param>
<param name="holdElection">
If true, start as a client, and call for an election if no master is
found.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)">
<summary>
Start the replication manager as a master site, and do not call for
an election.
</summary>
<remarks>
<para>
There are two ways to build Berkeley DB replication applications:
the most common approach is to use the Berkeley DB library
"replication manager" support, where the Berkeley DB library manages
the replication group, including network transport, all replication
message processing and acknowledgment, and group elections.
Applications using the replication manager support generally make
the following calls:
</para>
<list type="number">
<item>
Configure the local site in the replication group,
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrLocalSite"/>.
</item>
<item>
Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrAddRemoteSite(BerkeleyDB.ReplicationHostAddress)"/> to configure the remote
site(s) in the replication group.
</item>
<item>Configure the message acknowledgment policy
(<see cref="P:BerkeleyDB.DatabaseEnvironment.RepMgrAckPolicy"/>) which provides the replication group's
transactional needs.
</item>
<item>
Configure the local site's election priority,
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepPriority"/>.
</item>
<item>
Call <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/> or
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/> to start the replication
application.
</item>
</list>
<para>
For more information on building replication manager applications,
please see the Replication Getting Started Guide included in the
Berkeley DB documentation.
</para>
<para>
Applications with special needs (for example, applications using
network protocols not supported by the Berkeley DB replication
manager), must perform additional configuration and call other
Berkeley DB replication methods. For more information on building
advanced replication applications, please see the Base Replication
API section in the Berkeley DB Programmer's Reference Guide for more
information.
</para>
<para>
Starting the replication manager consists of opening the TCP/IP
listening socket to accept incoming connections, and starting all
necessary background threads. When multiple processes share a
database environment, only one process can open the listening
socket; <see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartMaster(System.Int32)"/> (and
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepMgrStartClient(System.Int32)"/>) automatically open the socket in
the first process to call it, and skips this step in the later calls
from other processes.
</para>
</remarks>
<param name="nthreads">
Specify the number of threads of control created and dedicated to
processing replication messages. In addition to these message
processing threads, the replication manager creates and manages a
few of its own threads of control.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)">
<summary>
Process an incoming replication message sent by a member of the
replication group to the local database environment.
</summary>
<remarks>
<para>
RepProcessMessage is not called by most replication applications. It
should only be called by applications implementing their own network
transport layer, explicitly holding replication group elections and
handling replication messages outside of the replication manager
framework.
</para>
<para>
For implementation reasons, all incoming replication messages must
be processed using the same <see cref="T:BerkeleyDB.DatabaseEnvironment"/>
object. It is not required that a single thread of control process
all messages, only that all threads of control processing messages
use the same object.
</para>
<para>
Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate
must already have been configured to send replication messages.
</para>
</remarks>
<param name="control">
A copy of the control parameter specified by Berkeley DB on the
sending environment.
</param>
<param name="rec">
A copy of the rec parameter specified by Berkeley DB on the sending
environment.
</param>
<param name="envid">
The local identifier that corresponds to the environment that sent
the message to be processed (see Replication environment IDs in the
Programmer's Reference Guide for more information)..
</param>
<returns>The result of processing a message</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepStartClient">
<summary>
Configure the database environment as a client in a group of
replicated database environments.
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepStartClient(BerkeleyDB.DatabaseEntry)">
<summary>
Configure the database environment as a client in a group of
replicated database environments.
</summary>
<overloads>
<para>
RepStartClient is not called by most replication applications. It
should only be called by applications implementing their own network
transport layer, explicitly holding replication group elections and
handling replication messages outside of the replication manager
framework.
</para>
<para>
Replication master environments are the only database environments
where replicated databases may be modified. Replication client
environments are read-only as long as they are clients. Replication
client environments may be upgraded to be replication master
environments in the case that the current master fails or there is
no master present. If master leases are in use, this method cannot
be used to appoint a master, and should only be used to configure a
database environment as a master as the result of an election.
</para>
<para>
Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate
must already have been configured to send replication messages.
</para>
</overloads>
<param name="cdata">
An opaque data item that is sent over the communication
infrastructure when the client comes online (see Connecting to a new
site in the Programmer's Reference Guide for more information). If
no such information is useful, cdata should be null.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster">
<summary>
Configure the database environment as a master in a group of
replicated database environments.
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster(BerkeleyDB.DatabaseEntry)">
<summary>
Configure the database environment as a master in a group of
replicated database environments.
</summary>
<overloads>
<para>
RepStartMaster is not called by most replication applications. It
should only be called by applications implementing their own network
transport layer, explicitly holding replication group elections and
handling replication messages outside of the replication manager
framework.
</para>
<para>
Replication master environments are the only database environments
where replicated databases may be modified. Replication client
environments are read-only as long as they are clients. Replication
client environments may be upgraded to be replication master
environments in the case that the current master fails or there is
no master present. If master leases are in use, this method cannot
be used to appoint a master, and should only be used to configure a
database environment as a master as the result of an election.
</para>
<para>
Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate
must already have been configured to send replication messages.
</para>
</overloads>
<param name="cdata">
An opaque data item that is sent over the communication
infrastructure when the client comes online (see Connecting to a new
site in the Programmer's Reference Guide for more information). If
no such information is useful, cdata should be null.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RepSync">
<summary>
Force master synchronization to begin for this client.
</summary>
<remarks>
<para>
This method is the other half of setting
<see cref="P:BerkeleyDB.DatabaseEnvironment.RepDelayClientSync"/>.
</para>
<para>
If an application has configured delayed master synchronization, the
application must synchronize explicitly (otherwise the client will
remain out-of-date and will ignore all database changes forwarded
from the replication group master). RepSync may be called any time
after the client application learns that the new master has been
established (by receiving
<see cref="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER"/>).
</para>
<para>
Before calling this method, the <see cref="P:BerkeleyDB.DatabaseEnvironment.RepTransport"/> delegate
must already have been configured to send replication messages.
</para>
</remarks>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.ArchivableLogFiles(System.Boolean)">
<summary>
The names of all of the log files that are no longer in use (for
example, that are no longer involved in active transactions), and
that may safely be archived for catastrophic recovery and then
removed from the system.
</summary>
<remarks>
<para>
The Berkeley DB interfaces to the database environment logging
subsystem (for example, <see cref="M:BerkeleyDB.Transaction.Abort"/>) may
allocate log cursors and have open file descriptors for log files
as well. On operating systems where filesystem related system calls
(for example, rename and unlink on Windows/NT) can fail if a process
has an open file descriptor for the affected file, attempting to
move or remove the log files listed by ArchivableLogFiles may fail.
All Berkeley DB internal use of log cursors operates on active log
files only and furthermore, is short-lived in nature. So, an
application seeing such a failure should be restructured to retry
the operation until it succeeds. (Although this is not likely to be
necessary; it is hard to imagine a reason to move or rename a log
file in which transactions are being logged or aborted.)
</para>
<para>
See the db_archive utility for more information on database archival
procedures.
</para>
</remarks>
<param name="AbsolutePaths">
If true, all pathnames are returned as absolute pathnames, instead
of relative to the database home directory.
</param>
<returns>
The names of all of the log files that are no longer in use
</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.ArchivableDatabaseFiles(System.Boolean)">
<summary>
The database files that need to be archived in order to recover the
database from catastrophic failure. If any of the database files
have not been accessed during the lifetime of the current log files,
they will not included in this list. It is also possible that some
of the files referred to by the log have since been deleted from the
system.
</summary>
<remarks>
<para>
See the db_archive utility for more information on database archival
procedures.
</para>
</remarks>
<param name="AbsolutePaths">
If true, all pathnames are returned as absolute pathnames, instead
of relative to the database home directory.
</param>
<returns>
The database files that need to be archived in order to recover the
database from catastrophic failure.
</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.LogFiles(System.Boolean)">
<summary>
The names of all of the log files
</summary>
<remarks>
<para>
The Berkeley DB interfaces to the database environment logging
subsystem (for example, <see cref="M:BerkeleyDB.Transaction.Abort"/>) may
allocate log cursors and have open file descriptors for log files
as well. On operating systems where filesystem related system calls
(for example, rename and unlink on Windows/NT) can fail if a process
has an open file descriptor for the affected file, attempting to
move or remove the log files listed by LogFiles may fail. All
Berkeley DB internal use of log cursors operates on active log files
only and furthermore, is short-lived in nature. So, an application
seeing such a failure should be restructured to retry the operation
until it succeeds. (Although this is not likely to be necessary; it
is hard to imagine a reason to move or rename a log file in which
transactions are being logged or aborted.)
</para>
<para>
See the db_archive utility for more information on database archival
procedures.
</para>
</remarks>
<param name="AbsolutePaths">
If true, all pathnames are returned as absolute pathnames, instead
of relative to the database home directory.
</param>
<returns>
All the log filenames, regardless of whether or not they are in use.
</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.RemoveUnusedLogFiles">
<summary>
Remove log files that are no longer needed. Automatic log file
removal is likely to make catastrophic recovery impossible.
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.BeginCDSGroup">
<summary>
Allocate a locker ID in an environment configured for Berkeley DB
Concurrent Data Store applications.
</summary>
<remarks>
<para>
Calling <see cref="M:BerkeleyDB.Transaction.Commit"/> will discard the allocated
locker ID.
</para>
<para>
See Berkeley DB Concurrent Data Store applications in the
Programmer's Reference Guide for more information about when this is
required.
</para>
</remarks>
<returns>
A Transaction object that uniquely identifies the locker ID
</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction">
<summary>
Create a new transaction in the environment, with the default
configuration.
</summary>
<returns>A new transaction object</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction(BerkeleyDB.TransactionConfig)">
<summary>
Create a new transaction in the environment.
</summary>
<param name="cfg">
The configuration properties for the transaction
</param>
<returns>A new transaction object</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction(BerkeleyDB.TransactionConfig,BerkeleyDB.Transaction)">
<summary>
Create a new transaction in the environment.
</summary>
<remarks>
In the presence of distributed transactions and two-phase commit,
only the parental transaction, that is a transaction without a
parent specified, should be passed as an parameter to
<see cref="M:BerkeleyDB.Transaction.Prepare(System.Byte[])"/>.
</remarks>
<param name="cfg">
The configuration properties for the transaction
</param>
<param name="parent">
If the non-null, the new transaction will be a nested transaction,
with <paramref name="parent"/> as the new transaction's parent.
Transactions may be nested to any level.
</param>
<returns>A new transaction object</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Checkpoint">
<summary>
Flush the underlying memory pool, write a checkpoint record to the
log, and then flush the log, even if there has been no activity
since the last checkpoint.
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Checkpoint(System.UInt32,System.UInt32)">
<summary>
If there has been any logging activity in the database environment
since the last checkpoint, flush the underlying memory pool, write a
checkpoint record to the log, and then flush the log.
</summary>
<param name="kbytesWritten">
A checkpoint will be done if more than kbytesWritten kilobytes of
log data have been written since the last checkpoint.
</param>
<param name="minutesElapsed">
A checkpoint will be done if more than minutesElapsed minutes have
passed since the last checkpoint.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Close">
<summary>
Close the Berkeley DB environment, freeing any allocated resources
and closing any underlying subsystems.
</summary>
<remarks>
<para>
The object should not be closed while any other handle that refers
to it is not yet closed; for example, database environment handles
must not be closed while database objects remain open, or
transactions in the environment have not yet been committed or
aborted.
</para>
<para>
Where the environment was configured with
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/>, calling Close
aborts any unresolved transactions. Applications should not depend
on this behavior for transactions involving Berkeley DB databases;
all such transactions should be explicitly resolved. The problem
with depending on this semantic is that aborting an unresolved
transaction involving database operations requires a database
handle. Because the database handles should have been closed before
calling Close, it will not be possible to abort the transaction, and
recovery will have to be run on the Berkeley DB environment before
further operations are done.
</para>
<para>
In multithreaded applications, only a single thread may call Close.
</para>
</remarks>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.DetectDeadlocks(BerkeleyDB.DeadlockPolicy)">
<summary>
Run one iteration of the deadlock detector. The deadlock detector
traverses the lock table and marks one of the participating lock
requesters for rejection in each deadlock it finds.
</summary>
<param name="atype">Specify which lock request(s) to reject</param>
<returns>The number of lock requests that were rejected.</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.FailCheck">
<summary>
Check for threads of control (either a true thread or a process)
that have exited while manipulating Berkeley DB library data
structures, while holding a logical database lock, or with an
unresolved transaction (that is, a transaction that was never
aborted or committed).
</summary>
<remarks>
<para>
For more information, see Architecting Data Store and Concurrent
Data Store applications, and Architecting Transactional Data Store
applications, both in the Berkeley DB Programmer's Reference Guide.
</para>
<para>
FailCheck is based on the <see cref="P:BerkeleyDB.DatabaseEnvironment.SetThreadID"/> and
<see cref="P:BerkeleyDB.DatabaseEnvironment.ThreadIsAlive"/> delegates. Applications calling
FailCheck must have already set <see cref="P:BerkeleyDB.DatabaseEnvironment.ThreadIsAlive"/>, and
must have configured <see cref="P:BerkeleyDB.DatabaseEnvironment.ThreadCount"/>.
</para>
<para>
If FailCheck determines a thread of control exited while holding
database read locks, it will release those locks. If FailCheck
determines a thread of control exited with an unresolved
transaction, the transaction will be aborted. In either of these
cases, FailCheck will return successfully and the application may
continue to use the database environment.
</para>
<para>
In either of these cases, FailCheck will also report the process and
thread IDs associated with any released locks or aborted
transactions. The information is printed to a specified output
channel (see <see cref="!:MessageFile"/> for more information), or
passed to an application delegate (see <see cref="!:MessageCall"/> for
more information).
</para>
<para>
If FailCheck determines a thread of control has exited such that
database environment recovery is required, it will throw
<see cref="T:BerkeleyDB.RunRecoveryException"/>. In this case, the application
should not continue to use the database environment. For a further
description as to the actions the application should take when this
failure occurs, see Handling failure in Data Store and Concurrent
Data Store applications, and Handling failure in Transactional Data
Store applications, both in the Berkeley DB Programmer's Reference
Guide.
</para>
</remarks>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.LogFile(BerkeleyDB.LSN)">
<summary>
Map an LSN object to a log filename
</summary>
<param name="logSeqNum">
The DB_LSN structure for which a filename is wanted.
</param>
<returns>
The name of the file containing the record named by
<paramref name="logSeqNum"/>.
</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.LogFlush">
<summary>
Write all log records to disk.
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.LogFlush(BerkeleyDB.LSN)">
<summary>
Write log records to disk.
</summary>
<param name="logSeqNum">
All log records with LSN values less than or equal to
<paramref name="logSeqNum"/> are written to disk. If null, all
records in the log are flushed.
</param>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.LogWrite(BerkeleyDB.DatabaseEntry,System.Boolean)">
<summary>
Append a record to the log
</summary>
<param name="dbt">The record to write to the log.</param>
<param name="flush">
If true, the log is forced to disk after this record is written,
guaranteeing that all records with LSN values less than or equal to
the one being "put" are on disk before LogWrite returns.
</param>
<returns>The LSN of the written record</returns>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Panic">
<summary>
Set the panic state for the database environment. (Database
environments in a panic state normally refuse all attempts to call
Berkeley DB functions, throwing <see cref="T:BerkeleyDB.RunRecoveryException"/>.)
</summary>
</member>
<member name="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)">
<summary>
Restore transactions that were prepared, but not yet resol
| 