mirror of
https://github.com/yasuhirokimura/db18
synced 2026-06-08 18:29:23 +00:00
Yasuhiro KIMURA
16749 lines
814 KiB
XML
16749 lines
814 KiB
XML
<?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.MessagePrefix">
|
|
<summary>
|
|
The prefix string that appears before informational messages issued
|
|
by Berkeley DB.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
For databases opened inside of a DatabaseEnvironment, setting
|
|
MessagePrefix affects the entire environment and is equivalent to
|
|
setting <see cref="P:BerkeleyDB.DatabaseEnvironment.MessagePrefix"/>.
|
|
</para>
|
|
</remarks>
|
|
</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 resolved at the
|
|
time of the system shut down or crash, to their state prior to the
|
|
shut down or crash, including any locks previously held.
|
|
</summary>
|
|
<remarks>
|
|
Calls to Recover from different threads of control should not be
|
|
intermixed in the same environment.
|
|
</remarks>
|
|
<param name="count">
|
|
The maximum number of <see cref="T:BerkeleyDB.PreparedTransaction"/> objects
|
|
to return.
|
|
</param>
|
|
<param name="resume">
|
|
If true, continue returning a list of prepared, but not yet resolved
|
|
transactions, starting where the last call to Recover left off. If
|
|
false, begins a new pass over all prepared, but not yet completed
|
|
transactions, regardless of whether they have already been returned
|
|
in previous calls to Recover.
|
|
</param>
|
|
<returns>A list of the prepared transactions</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.Boolean)">
|
|
<summary>
|
|
Remove the underlying file represented by <paramref name="file"/>,
|
|
incidentally removing all of the databases it contained.
|
|
</summary>
|
|
<param name="file">The physical file to be removed.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RemoveDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.String,System.Boolean)">
|
|
<summary>
|
|
Remove the database specified by <paramref name="file"/> and
|
|
<paramref name="database"/>. If no database is specified, the
|
|
underlying file represented by <paramref name="file"/> is removed,
|
|
incidentally removing all of the databases it contained.
|
|
</summary>
|
|
<param name="file">
|
|
The physical file which contains the database(s) to be removed.
|
|
</param>
|
|
<param name="database">The database to be removed.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RemoveDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.Boolean,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Remove the underlying file represented by <paramref name="file"/>,
|
|
incidentally removing all of the databases it contained.
|
|
</summary>
|
|
<param name="file">The physical file to be removed.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RemoveDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</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. If
|
|
null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
|
|
is true, the operation will be implicitly transaction protected.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RemoveDB(System.String,System.String,System.Boolean,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Remove the database specified by <paramref name="file"/> and
|
|
<paramref name="database"/>. If no database is specified, the
|
|
underlying file represented by <paramref name="file"/> is removed,
|
|
incidentally removing all of the databases it contained.
|
|
</summary>
|
|
<param name="file">
|
|
The physical file which contains the database(s) to be removed.
|
|
</param>
|
|
<param name="database">The database to be removed.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RemoveDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</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. If
|
|
null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
|
|
is true, the operation will be implicitly transaction protected.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.Boolean)">
|
|
<summary>
|
|
Rename the underlying file represented by <paramref name="file"/>
|
|
using the value supplied to <paramref name="newname"/>, incidentally
|
|
renaming all of the databases it contained.
|
|
</summary>
|
|
<param name="file">The physical file to be renamed.</param>
|
|
<param name="newname">The new name of the database or file.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RenameDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.String,System.Boolean)">
|
|
<summary>
|
|
Rename the database specified by <paramref name="file"/> and
|
|
<paramref name="database"/> to <paramref name="newname"/>. If no
|
|
database is specified, the underlying file represented by
|
|
<paramref name="file"/> is renamed using the value supplied to
|
|
<paramref name="newname"/>, incidentally renaming all of the
|
|
databases it contained.
|
|
</summary>
|
|
<param name="file">
|
|
The physical file which contains the database(s) to be renamed.
|
|
</param>
|
|
<param name="database">The database to be renamed.</param>
|
|
<param name="newname">The new name of the database or file.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RenameDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.Boolean,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Rename the underlying file represented by <paramref name="file"/>
|
|
using the value supplied to <paramref name="newname"/>, incidentally
|
|
renaming all of the databases it contained.
|
|
</summary>
|
|
<param name="file">The physical file to be renamed.</param>
|
|
<param name="newname">The new name of the database or file.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RenameDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</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. If
|
|
null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
|
|
is true, the operation will be implicitly transaction protected.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RenameDB(System.String,System.String,System.String,System.Boolean,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Rename the database specified by <paramref name="file"/> and
|
|
<paramref name="database"/> to <paramref name="newname"/>. If no
|
|
database is specified, the underlying file represented by
|
|
<paramref name="file"/> is renamed using the value supplied to
|
|
<paramref name="newname"/>, incidentally renaming all of the
|
|
databases it contained.
|
|
</summary>
|
|
<param name="file">
|
|
The physical file which contains the database(s) to be renamed.
|
|
</param>
|
|
<param name="database">The database to be renamed.</param>
|
|
<param name="newname">The new name of the database or file.</param>
|
|
<param name="autoCommit">
|
|
If true, enclose RenameDB within a transaction. If the call
|
|
succeeds, changes made by the operation will be recoverable. If the
|
|
call fails, the operation will have made no changes.
|
|
</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. If
|
|
null, but <paramref name="autoCommit"/> or <see cref="P:BerkeleyDB.DatabaseEnvironment.AutoCommit"/>
|
|
is true, the operation will be implicitly transaction protected.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.ResetFileID(System.String,System.Boolean)">
|
|
<summary>
|
|
Allow database files to be copied, and then the copy used in the
|
|
same database environment as the original.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
All databases contain an ID string used to identify the database in
|
|
the database environment cache. If a physical database file is
|
|
copied, and used in the same environment as another file with the
|
|
same ID strings, corruption can occur. ResetFileID creates new ID
|
|
strings for all of the databases in the physical file.
|
|
</para>
|
|
<para>
|
|
ResetFileID modifies the physical file, in-place. Applications
|
|
should not reset IDs in files that are currently in use.
|
|
</para>
|
|
</remarks>
|
|
<param name="file">
|
|
The name of the physical file in which new file IDs are to be created.
|
|
</param>
|
|
<param name="encrypted">
|
|
If true, he file contains encrypted databases.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.ResetLSN(System.String,System.Boolean)">
|
|
<summary>
|
|
Allow database files to be moved from one transactional database
|
|
environment to another.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Database pages in transactional database environments contain
|
|
references to the environment's log files (that is, log sequence
|
|
numbers, or <see cref="T:BerkeleyDB.LSN"/>s). Copying or moving a database file
|
|
from one database environment to another, and then modifying it, can
|
|
result in data corruption if the LSNs are not first cleared.
|
|
</para>
|
|
<para>
|
|
Note that LSNs should be reset before moving or copying the database
|
|
file into a new database environment, rather than moving or copying
|
|
the database file and then resetting the LSNs. Berkeley DB has
|
|
consistency checks that may be triggered if an application calls
|
|
ResetLSN on a database in a new environment when the database LSNs
|
|
still reflect the old environment.
|
|
</para>
|
|
<para>
|
|
The ResetLSN method modifies the physical file, in-place.
|
|
Applications should not reset LSNs in files that are currently in
|
|
use.
|
|
</para>
|
|
</remarks>
|
|
<param name="file"></param>
|
|
<param name="encrypted"></param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.SetMaxSequentialWrites(System.Int32,System.UInt32)">
|
|
<summary>
|
|
Limit the number of sequential write operations scheduled by the
|
|
library when flushing dirty pages from the cache.
|
|
</summary>
|
|
<param name="maxWrites">
|
|
The maximum number of sequential write operations scheduled by the
|
|
library when flushing dirty pages from the cache, or 0 if there is
|
|
no limitation on the number of sequential write operations.
|
|
</param>
|
|
<param name="pause">
|
|
The number of microseconds the thread of control should pause before
|
|
scheduling further write operations. It must be specified as an
|
|
unsigned 32-bit number of microseconds, limiting the maximum pause
|
|
to roughly 71 minutes.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.SyncMemPool">
|
|
<summary>
|
|
Flush all modified pages in the cache to their backing files.
|
|
</summary>
|
|
<remarks>
|
|
Pages in the cache that cannot be immediately written back to disk
|
|
(for example, pages that are currently in use by another thread of
|
|
control) are waited for and written to disk as soon as it is
|
|
possible to do so.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.SyncMemPool(BerkeleyDB.LSN)">
|
|
<summary>
|
|
Flush modified pages in the cache with log sequence numbers less
|
|
than <paramref name="minLSN"/> to their backing files.
|
|
</summary>
|
|
<remarks>
|
|
Pages in the cache that cannot be immediately written back to disk
|
|
(for example, pages that are currently in use by another thread of
|
|
control) are waited for and written to disk as soon as it is
|
|
possible to do so.
|
|
</remarks>
|
|
<param name="minLSN">
|
|
All modified pages with a log sequence number less than the minLSN
|
|
parameter are written to disk. If null, all modified pages in the
|
|
cache are written to disk.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.TrickleCleanMemPool(System.Int32)">
|
|
<summary>
|
|
Ensure that a specified percent of the pages in the cache are clean,
|
|
by writing dirty pages to their backing files.
|
|
</summary>
|
|
<param name="pctClean">
|
|
The percent of the pages in the cache that should be clean.
|
|
</param>
|
|
<returns>
|
|
The number of pages written to reach the specified percentage is
|
|
copied.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.WriteToLog(System.String)">
|
|
<summary>
|
|
Append an informational message to the Berkeley DB database
|
|
environment log files.
|
|
</summary>
|
|
<overloads>
|
|
WriteToLog allows applications to include information in the
|
|
database environment log files, for later review using the
|
|
db_printlog utility. This method is intended for debugging and
|
|
performance tuning.
|
|
</overloads>
|
|
<param name="str">The message to append to the log files</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.WriteToLog(System.String,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Append an informational message to the Berkeley DB database
|
|
environment log files.
|
|
</summary>
|
|
<overloads>
|
|
WriteToLog allows applications to include information in the
|
|
database environment log files, for later review using the
|
|
db_printlog utility. This method is intended for debugging and
|
|
performance tuning.
|
|
</overloads>
|
|
<param name="str">The message to append to the log files</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"/>;
|
|
otherwise null.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.LockingSystemStats">
|
|
<summary>
|
|
The locking subsystem statistics
|
|
</summary>
|
|
<returns>The locking subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.LockingSystemStats(System.Boolean)">
|
|
<summary>
|
|
The locking subsystem statistics
|
|
</summary>
|
|
<param name="clearStats">
|
|
If true, reset statistics after returning their values.
|
|
</param>
|
|
<returns>The locking subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.LoggingSystemStats">
|
|
<summary>
|
|
The logging subsystem statistics
|
|
</summary>
|
|
<returns>The logging subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.LoggingSystemStats(System.Boolean)">
|
|
<summary>
|
|
The logging subsystem statistics
|
|
</summary>
|
|
<param name="clearStats">
|
|
If true, reset statistics after returning their values.
|
|
</param>
|
|
<returns>The logging subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.MPoolSystemStats">
|
|
<summary>
|
|
The memory pool (that is, the buffer cache) subsystem statistics
|
|
</summary>
|
|
<returns>The memory pool subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.MPoolSystemStats(System.Boolean)">
|
|
<summary>
|
|
The memory pool (that is, the buffer cache) subsystem statistics
|
|
</summary>
|
|
<param name="clearStats">
|
|
If true, reset statistics after returning their values.
|
|
</param>
|
|
<returns>The memory pool subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.MutexSystemStats">
|
|
<summary>
|
|
The mutex subsystem statistics
|
|
</summary>
|
|
<returns>The mutex subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.MutexSystemStats(System.Boolean)">
|
|
<summary>
|
|
The mutex subsystem statistics
|
|
</summary>
|
|
<param name="clearStats">
|
|
If true, reset statistics after returning their values.
|
|
</param>
|
|
<returns>The mutex subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrSystemStats">
|
|
<summary>
|
|
The replication manager statistics
|
|
</summary>
|
|
<returns>The replication manager statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.RepMgrSystemStats(System.Boolean)">
|
|
<summary>
|
|
The replication manager statistics
|
|
</summary>
|
|
<param name="clearStats">
|
|
If true, reset statistics after returning their values.
|
|
</param>
|
|
<returns>The replication manager statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.ReplicationSystemStats">
|
|
<summary>
|
|
The replication subsystem statistics
|
|
</summary>
|
|
<returns>The replication subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.ReplicationSystemStats(System.Boolean)">
|
|
<summary>
|
|
The replication subsystem statistics
|
|
</summary>
|
|
<param name="clearStats">
|
|
If true, reset statistics after returning their values.
|
|
</param>
|
|
<returns>The replication subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats">
|
|
<summary>
|
|
The transaction subsystem statistics
|
|
</summary>
|
|
<returns>The transaction subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats(System.Boolean)">
|
|
<summary>
|
|
The transaction subsystem statistics
|
|
</summary>
|
|
<param name="clearStats">
|
|
If true, reset statistics after returning their values.
|
|
</param>
|
|
<returns>The transaction subsystem statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintLockingSystemStats">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintLockingSystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintLockingSystemStats(System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
<param name="ConflictMatrix">
|
|
If true, display the lock conflict matrix.
|
|
</param>
|
|
<param name="Lockers">
|
|
If true, Display the lockers within hash chains.
|
|
</param>
|
|
<param name="Objects">
|
|
If true, display the lock objects within hash chains.
|
|
</param>
|
|
<param name="Parameters">
|
|
If true, display the locking subsystem parameters.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintLoggingSystemStats">
|
|
<summary>
|
|
Display the logging subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LogStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintLoggingSystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the logging subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LogStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintMPoolSystemStats">
|
|
<summary>
|
|
Display the memory pool (that is, buffer cache) subsystem
|
|
statistical information, as described by <see cref="T:BerkeleyDB.MPoolStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintMPoolSystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the memory pool (that is, buffer cache) subsystem
|
|
statistical information, as described by <see cref="T:BerkeleyDB.MPoolStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintMPoolSystemStats(System.Boolean,System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the memory pool (that is, buffer cache) subsystem
|
|
statistical information, as described by <see cref="T:BerkeleyDB.MPoolStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
<param name="HashChains">
|
|
If true, display the buffers with hash chains.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintMutexSystemStats">
|
|
<summary>
|
|
Display the mutex subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.MutexStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintMutexSystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the mutex subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.MutexStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintRepMgrSystemStats">
|
|
<summary>
|
|
Display the replication manager statistical information, as
|
|
described by <see cref="T:BerkeleyDB.RepMgrStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintRepMgrSystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the replication manager statistical information, as
|
|
described by <see cref="T:BerkeleyDB.RepMgrStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintReplicationSystemStats">
|
|
<summary>
|
|
Display the replication subsystem statistical information, as
|
|
described by <see cref="T:BerkeleyDB.ReplicationStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintReplicationSystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the replication subsystem statistical information, as
|
|
described by <see cref="T:BerkeleyDB.ReplicationStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintStats">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintSubsystemStats">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintSubsystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintStats(System.Boolean,System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the locking subsystem statistical information, as described
|
|
by <see cref="T:BerkeleyDB.LockStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats">
|
|
<summary>
|
|
Display the transaction subsystem statistical information, as
|
|
described by <see cref="T:BerkeleyDB.TransactionStats"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats(System.Boolean,System.Boolean)">
|
|
<summary>
|
|
Display the transaction subsystem statistical information, as
|
|
described by <see cref="T:BerkeleyDB.TransactionStats"/>.
|
|
</summary>
|
|
<param name="PrintAll">
|
|
If true, display all available information.
|
|
</param>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after displaying their values.
|
|
</param>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.AutoCommit">
|
|
<summary>
|
|
If true, database operations for which no explicit transaction
|
|
handle was specified, and which modify databases in the database
|
|
environment, will be automatically enclosed within a transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.CacheSize">
|
|
<summary>
|
|
The size of the shared memory buffer pool -- that is, the cache.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The cache should be the size of the normal working data set of the
|
|
application, with some small amount of additional memory for unusual
|
|
situations. (Note: the working set is not the same as the number of
|
|
pages accessed simultaneously, and is usually much larger.)
|
|
</para>
|
|
<para>
|
|
The default cache size is 256KB, and may not be specified as less
|
|
than 20KB. Any cache size less than 500MB is automatically increased
|
|
by 25% to account for buffer pool overhead; cache sizes larger than
|
|
500MB are used as specified. The maximum size of a single cache is
|
|
4GB on 32-bit systems and 10TB on 64-bit systems. (All sizes are in
|
|
powers-of-two, that is, 256KB is 2^18 not 256,000.) For information
|
|
on tuning the Berkeley DB cache size, see Selecting a cache size in
|
|
the Programmer's Reference Guide.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.CDB_ALLDB">
|
|
<summary>
|
|
If true, Berkeley DB Concurrent Data Store applications will perform
|
|
locking on an environment-wide basis rather than on a per-database
|
|
basis.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.Create">
|
|
<summary>
|
|
If true, Berkeley DB subsystems will create any underlying files, as
|
|
necessary.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.DataDirs">
|
|
<summary>
|
|
The array of directories where database files are stored.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.DeadlockResolution">
|
|
<summary>
|
|
The deadlock detector configuration, specifying what lock request(s)
|
|
should be rejected. As transactions acquire locks on behalf of a
|
|
single locker ID, rejecting a lock request associated with a
|
|
transaction normally requires the transaction be aborted.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.EncryptAlgorithm">
|
|
<summary>
|
|
The algorithm used by the Berkeley DB library to perform encryption
|
|
and decryption.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.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>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.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.DatabaseEnvironment.EventNotify">
|
|
<summary>
|
|
A delegate which is called to notify the process of specific
|
|
Berkeley DB events.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.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.DatabaseEnvironment.ForceFlush">
|
|
<summary>
|
|
If true, flush database writes to the backing disk before returning
|
|
from the write system call, rather than flushing database writes
|
|
explicitly in a separate system call, as necessary.
|
|
</summary>
|
|
<remarks>
|
|
This flag may result in inaccurate file modification times and other
|
|
file-level information for Berkeley DB database files. This flag
|
|
will almost certainly result in a performance decrease on most
|
|
systems.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.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.DatabaseEnvironment.Home">
|
|
<summary>
|
|
The database environment home directory.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.InitRegions">
|
|
<summary>
|
|
If true, Berkeley DB will page-fault shared regions into memory when
|
|
initially creating or joining a Berkeley DB environment.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
In some applications, the expense of page-faulting the underlying
|
|
shared memory regions can affect performance. (For example, if the
|
|
page-fault occurs while holding a lock, other lock requests can
|
|
convoy, and overall throughput may decrease.)
|
|
</para>
|
|
<para>
|
|
In addition to page-faulting, Berkeley DB will write the shared
|
|
regions when creating an environment, forcing the underlying virtual
|
|
memory and filesystems to instantiate both the necessary memory and
|
|
the necessary disk space. This can also avoid out-of-disk space
|
|
failures later on.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.IntermediateDirMode">
|
|
<summary>
|
|
The intermediate directory permissions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LockConflictMatrix">
|
|
<summary>
|
|
The current lock conflicts array.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.Lockdown">
|
|
<summary>
|
|
If true, lock shared Berkeley DB environment files and memory-mapped
|
|
databases into memory.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LockPartitions">
|
|
<summary>
|
|
The number of lock table partitions used in the Berkeley DB
|
|
environment.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LockTimeout">
|
|
<summary>
|
|
A value, in microseconds, representing lock timeouts.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
All timeouts are checked whenever a thread of control blocks on a
|
|
lock or when deadlock detection is performed. As timeouts are only
|
|
checked when the lock request first blocks or when deadlock
|
|
detection is performed, the accuracy of the timeout depends on how
|
|
often deadlock detection is performed.
|
|
</para>
|
|
<para>
|
|
Timeout values specified for the database environment may be
|
|
overridden on a per-transaction basis, see
|
|
<see cref="M:BerkeleyDB.Transaction.SetLockTimeout(System.UInt32)"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogBufferSize">
|
|
<summary>
|
|
The size of the in-memory log buffer, in bytes
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogDir">
|
|
<summary>
|
|
The path of a directory to be used as the location of logging files.
|
|
Log files created by the Log Manager subsystem will be created in
|
|
this directory.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogFileMode">
|
|
<summary>
|
|
The absolute file mode for created log files. This property is only
|
|
useful for the rare Berkeley DB application that does not control
|
|
its umask value.
|
|
</summary>
|
|
<remarks>
|
|
Normally, if Berkeley DB applications set their umask appropriately,
|
|
all processes in the application suite will have read permission on
|
|
the log files created by any process in the application suite.
|
|
However, if the Berkeley DB application is a library, a process
|
|
using the library might set its umask to a value preventing other
|
|
processes in the application suite from reading the log files it
|
|
creates. In this rare case, this property can be used to set the
|
|
mode of created log files to an absolute value.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogNoBuffer">
|
|
<summary>
|
|
If true, system buffering is turned off for Berkeley DB log files to
|
|
avoid double caching.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogForceSync">
|
|
<summary>
|
|
If true, Berkeley DB will flush log writes to the backing disk
|
|
before returning from the write system call, rather than flushing
|
|
log writes explicitly in a separate system call, as necessary.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogAutoRemove">
|
|
<summary>
|
|
If true, Berkeley DB will automatically remove log files that are no
|
|
longer needed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogInMemory">
|
|
<summary>
|
|
If true, transaction logs are maintained in memory rather than on
|
|
disk. This means that transactions exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability).
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogZeroOnCreate">
|
|
<summary>
|
|
If true, all pages of a log file are zeroed when that log file is
|
|
created.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.LogRegionSize">
|
|
<summary>
|
|
The size of the underlying logging area of the Berkeley DB
|
|
environment, in bytes.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxCacheSize">
|
|
<summary>
|
|
The maximum cache size
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxLogFileSize">
|
|
<summary>
|
|
The maximum size of a single file in the log, in bytes. Because
|
|
<see cref="F:BerkeleyDB.LSN.Offset">LSN Offsets</see> are unsigned four-byte
|
|
values, the size may not be larger than the maximum unsigned
|
|
four-byte value.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
When the logging subsystem is configured for on-disk logging, the
|
|
default size of a log file is 10MB.
|
|
</para>
|
|
<para>
|
|
When the logging subsystem is configured for in-memory logging, the
|
|
default size of a log file is 256KB. In addition, the configured log
|
|
buffer size must be larger than the log file size. (The logging
|
|
subsystem divides memory configured for in-memory log records into
|
|
"files", as database environments configured for in-memory log
|
|
records may exchange log records with other members of a replication
|
|
group, and those members may be configured to store log records
|
|
on-disk.) When choosing log buffer and file sizes for in-memory
|
|
logs, applications should ensure the in-memory log buffer size is
|
|
large enough that no transaction will ever span the entire buffer,
|
|
and avoid a state where the in-memory buffer is full and no space
|
|
can be freed because a transaction that started in the first log
|
|
"file" is still active.
|
|
</para>
|
|
<para>
|
|
See Log File Limits in the Programmer's Reference Guide for more
|
|
information.
|
|
</para>
|
|
<para>
|
|
If no size is specified by the application, the size last specified
|
|
for the database region will be used, or if no database region
|
|
previously existed, the default will be used.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxLockers">
|
|
<summary>
|
|
The maximum number of locking entities supported by the Berkeley DB
|
|
environment.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxLocks">
|
|
<summary>
|
|
The maximum number of locks supported by the Berkeley DB
|
|
environment.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxMutexes">
|
|
<summary>
|
|
The total number of mutexes allocated
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxObjects">
|
|
<summary>
|
|
The maximum number of locked objects
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxOpenFiles">
|
|
<summary>
|
|
The number of file descriptors the library will open concurrently
|
|
when flushing dirty pages from the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxSequentialWrites">
|
|
<summary>
|
|
The number of sequential write operations scheduled by the library
|
|
when flushing dirty pages from the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MaxTransactions">
|
|
<summary>
|
|
The number of active transactions supported by the environment. This
|
|
value bounds the size of the memory allocated for transactions.
|
|
Child transactions are counted as active until they either commit or
|
|
abort.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Transactions that update multiversion databases are not freed until
|
|
the last page version that the transaction created is flushed from
|
|
cache. This means that applications using multi-version concurrency
|
|
control may need a transaction for each page in cache, in the
|
|
extreme case.
|
|
</para>
|
|
<para>
|
|
When all of the memory available in the database environment for
|
|
transactions is in use, calls to <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/> will
|
|
fail (until some active transactions complete). If MaxTransactions
|
|
is never set, the database environment is configured to support at
|
|
least 100 active transactions.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MessagePrefix">
|
|
<summary>
|
|
The prefix string that appears before informational messages issued
|
|
by Berkeley DB.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
For databases opened inside of a DatabaseEnvironment, setting
|
|
MessagePrefix affects the entire environment and is equivalent to
|
|
setting <see cref="P:BerkeleyDB.DatabaseEnvironment.MessagePrefix"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MMapSize">
|
|
<summary>
|
|
The maximum file size, in bytes, for a file to be mapped into the
|
|
process address space. If no value is specified, it defaults to
|
|
10MB.
|
|
</summary>
|
|
<remarks>
|
|
Files that are opened read-only in the cache (and that satisfy a few
|
|
other criteria) are, by default, mapped into the process address
|
|
space instead of being copied into the local cache. This can result
|
|
in better-than-usual performance because available virtual memory is
|
|
normally much larger than the local cache, and page faults are
|
|
faster than page copying on many systems. However, it can cause
|
|
resource starvation in the presence of limited virtual memory, and
|
|
it can result in immense process sizes in the presence of large
|
|
databases.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MutexAlignment">
|
|
<summary>
|
|
The mutex alignment, in bytes.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.MutexIncrement">
|
|
<summary>
|
|
The number of additional mutexes allocated.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.NoBuffer">
|
|
<summary>
|
|
If true, turn off system buffering of Berkeley DB database files to
|
|
avoid double caching.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.NoLocking">
|
|
<summary>
|
|
If true, Berkeley DB will grant all requested mutual exclusion
|
|
mutexes and database locks without regard for their actual
|
|
availability. This functionality should never be used for purposes
|
|
other than debugging.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.NoMMap">
|
|
<summary>
|
|
If true, Berkeley DB will copy read-only database files into the
|
|
local cache instead of potentially mapping them into process memory.
|
|
</summary>
|
|
<seealso cref="P:BerkeleyDB.DatabaseEnvironment.MMapSize"/>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.NoPanic">
|
|
<summary>
|
|
If true, Berkeley DB will ignore any panic state in the database
|
|
environment. (Database environments in a panic state normally refuse
|
|
all attempts to call Berkeley DB functions, throwing
|
|
<see cref="T:BerkeleyDB.RunRecoveryException"/>.) This functionality should never
|
|
be used for purposes other than debugging.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.NumTestAndSetSpins">
|
|
<summary>
|
|
The number of times that test-and-set mutexes should spin without
|
|
blocking. The value defaults to 1 on uniprocessor systems and to 50
|
|
times the number of processors on multiprocessor systems.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.Overwrite">
|
|
<summary>
|
|
If true, overwrite files stored in encrypted formats before deleting
|
|
them.
|
|
</summary>
|
|
<remarks>
|
|
Berkeley DB overwrites files using alternating 0xff, 0x00 and 0xff
|
|
byte patterns. For file overwriting to be effective, the underlying
|
|
file must be stored on a fixed-block filesystem. Systems with
|
|
journaling or logging filesystems will require operating system
|
|
support and probably modification of the Berkeley DB sources.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.Private">
|
|
<summary>
|
|
If true, allocate region memory from the heap instead of from memory
|
|
backed by the filesystem or system shared memory.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.Register">
|
|
<summary>
|
|
If true, Berkeley DB will have checked to see if recovery needed to
|
|
be performed before opening the database environment.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepAckTimeout">
|
|
<summary>
|
|
The amount of time the replication manager's transport function
|
|
waits to collect enough acknowledgments from replication group
|
|
clients, before giving up and returning a failure indication. The
|
|
default wait time is 1 second.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepBulkTransfer">
|
|
<summary>
|
|
If true, the replication master sends groups of records to the
|
|
clients in a single network transfer
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepCheckpointDelay">
|
|
<summary>
|
|
The amount of time a master site will delay between completing a
|
|
checkpoint and writing a checkpoint record into the log.
|
|
</summary>
|
|
<remarks>
|
|
This delay allows clients to complete their own checkpoints before
|
|
the master requires completion of them. The default is 30 seconds.
|
|
If all databases in the environment, and the environment's
|
|
transaction log, are configured to reside in memory (never preserved
|
|
to disk), then, although checkpoints are still necessary, the delay
|
|
is not useful and should be set to 0.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepClockskewFast">
|
|
<summary>
|
|
The value, relative to <see cref="P:BerkeleyDB.DatabaseEnvironment.RepClockskewSlow"/>, of the
|
|
fastest clock in the group of sites.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepClockskewSlow">
|
|
<summary>
|
|
The value of the slowest clock in the group of sites.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepConnectionRetry">
|
|
<summary>
|
|
The amount of time the replication manager will wait before trying
|
|
to re-establish a connection to another site after a communication
|
|
failure. The default wait time is 30 seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepDelayClientSync">
|
|
<summary>
|
|
If true, the client should delay synchronizing to a newly declared
|
|
master (defaults to false). Clients configured in this way will remain
|
|
unsynchronized until the application calls <see cref="M:BerkeleyDB.DatabaseEnvironment.RepSync"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepElectionRetry">
|
|
<summary>
|
|
Configure the amount of time the replication manager will wait
|
|
before retrying a failed election. The default wait time is 10
|
|
seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepElectionTimeout">
|
|
<summary>
|
|
The timeout period for an election. The default timeout is 2
|
|
seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepFullElectionTimeout">
|
|
<summary>
|
|
An optional configuration timeout period to wait for full election
|
|
participation the first time the replication group finds a master.
|
|
By default this option is turned off and normal election timeouts
|
|
are used. (See the Elections section in the Berkeley DB Reference
|
|
Guide for more information.)
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepHeartbeatMonitor">
|
|
<summary>
|
|
The amount of time the replication manager, running at a client
|
|
site, waits for some message activity on the connection from the
|
|
master (heartbeats or other messages) before concluding that the
|
|
connection has been lost. When 0 (the default), no monitoring is
|
|
performed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepHeartbeatSend">
|
|
<summary>
|
|
The frequency at which the replication manager, running at a master
|
|
site, broadcasts a heartbeat message in an otherwise idle system.
|
|
When 0 (the default), no heartbeat messages will be sent.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepLeaseTimeout">
|
|
<summary>
|
|
The amount of time a client grants its master lease to a master.
|
|
When using master leases all sites in a replication group must use
|
|
the same lease timeout value. There is no default value. If leases
|
|
are desired, this method must be called prior to calling
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/> or <see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepMgrAckPolicy">
|
|
<summary>
|
|
Specify how master and client sites will handle acknowledgment of
|
|
replication messages which are necessary for "permanent" records.
|
|
The current implementation requires all sites in a replication group
|
|
configure the same acknowledgement policy.
|
|
</summary>
|
|
<seealso cref="P:BerkeleyDB.DatabaseEnvironment.RepAckTimeout"/>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepMgrLocalSite">
|
|
<summary>
|
|
The host information for the local system.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepMgrRemoteSites">
|
|
<summary>
|
|
The status of the sites currently known by the replication manager.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepNoAutoInit">
|
|
<summary>
|
|
If true, the replication master will not automatically re-initialize
|
|
outdated clients (defaults to false).
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepNoBlocking">
|
|
<summary>
|
|
If true, Berkeley DB method calls that would normally block while
|
|
clients are in recovery will return errors immediately (defaults to
|
|
false).
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepNSites">
|
|
<summary>
|
|
The total number of sites in the replication group.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This setting is typically used by applications which use the
|
|
Berkeley DB library "replication manager" support. (However, see
|
|
also <see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>, the description of the nsites
|
|
parameter.)
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepPriority">
|
|
<summary>
|
|
The database environment's priority in replication group elections.
|
|
A special value of 0 indicates that this environment cannot be a
|
|
replication group master. If not configured, then a default value
|
|
of 100 is used.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepRetransmissionRequestMin">
|
|
<summary>
|
|
The minimum number of microseconds a client waits before requesting
|
|
retransmission.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepRetransmissionRequestMax">
|
|
<summary>
|
|
The maximum number of microseconds a client waits before requesting
|
|
retransmission.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepStrict2Site">
|
|
<summary>
|
|
Replication Manager observes the strict "majority" rule in managing
|
|
elections, even in a group with only 2 sites. This means the client
|
|
in a 2-site group will be unable to take over as master if the
|
|
original master fails or becomes disconnected. (See the Elections
|
|
section in the Berkeley DB Reference Guide for more information.)
|
|
Both sites in the replication group should have the same value for
|
|
this parameter.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepTransmitLimitGBytes">
|
|
<summary>
|
|
The gigabytes component of the 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)"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepTransmitLimitBytes">
|
|
<summary>
|
|
The bytes component of the 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)"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepTransport">
|
|
<summary>
|
|
The delegate used to transmit data using the replication
|
|
application's communication infrastructure.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RepUseMasterLeases">
|
|
<summary>
|
|
If true, master leases will be used for this site (defaults to
|
|
false).
|
|
</summary>
|
|
<remarks>
|
|
Configuring this option may result in a
|
|
<see cref="T:BerkeleyDB.LeaseExpiredException"/> when attempting to read entries
|
|
from a database after the site's master lease has expired.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RunFatalRecovery">
|
|
<summary>
|
|
If true, catastrophic recovery was run on this environment before
|
|
opening it for normal use.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.RunRecovery">
|
|
<summary>
|
|
If true, normal recovery was run on this environment before opening
|
|
it for normal use.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.SequentialWritePause">
|
|
<summary>
|
|
The number of microseconds the thread of control will pause before
|
|
scheduling further write operations.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.SetThreadID">
|
|
<summary>
|
|
A delegate that returns a unique identifier pair for the current
|
|
thread of control.
|
|
</summary>
|
|
<remarks>
|
|
This delegate supports <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>. 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.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.SetThreadName">
|
|
<summary>
|
|
A delegate that formats a process ID and thread ID identifier pair.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.SystemMemory">
|
|
<summary>
|
|
If true, allocate region memory from system shared memory instead of
|
|
from heap memory or memory backed by the filesystem.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TempDir">
|
|
<summary>
|
|
The path of a directory to be used as the location of temporary
|
|
files.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The files created to back in-memory access method databases will be
|
|
created relative to this path. These temporary files can be quite
|
|
large, depending on the size of the database.
|
|
</para>
|
|
<para>
|
|
If no directories are specified, the following alternatives are
|
|
checked in the specified order. The first existing directory path is
|
|
used for all temporary files.
|
|
</para>
|
|
<list type="number">
|
|
<item>The value of the environment variable TMPDIR.</item>
|
|
<item>The value of the environment variable TEMP.</item>
|
|
<item>The value of the environment variable TMP.</item>
|
|
<item>The value of the environment variable TempFolder.</item>
|
|
<item>The value returned by the GetTempPath interface.</item>
|
|
<item>The directory /var/tmp.</item>
|
|
<item>The directory /usr/tmp.</item>
|
|
<item>The directory /temp.</item>
|
|
<item>The directory /tmp.</item>
|
|
<item>The directory C:/temp.</item>
|
|
<item>The directory C:/tmp.</item>
|
|
</list>
|
|
<para>
|
|
Environment variables are only checked if
|
|
<see cref="P:BerkeleyDB.DatabaseEnvironment.UseEnvironmentVars"/> is true.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.ThreadCount">
|
|
<summary>
|
|
An approximate number of threads in the database environment.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.ThreadIsAlive">
|
|
<summary>
|
|
A delegate that returns if a thread of control (either a true thread
|
|
or a process) is still running.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TimeNotGranted">
|
|
<summary>
|
|
If true, database calls timing out based on lock or transaction
|
|
timeout values will throw <see cref="T:BerkeleyDB.LockNotGrantedException"/>
|
|
instead of <see cref="T:BerkeleyDB.DeadlockException"/>.
|
|
</summary>
|
|
<remarks>
|
|
If true, this allows applications to distinguish between operations
|
|
which have deadlocked and operations which have exceeded their time
|
|
limits.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TxnNoSync">
|
|
<summary>
|
|
If true, Berkeley DB will not write or synchronously flush the log
|
|
on transaction commit.
|
|
</summary>
|
|
<remarks>
|
|
This means that transactions exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability); that
|
|
is, database integrity will be maintained, but if the application or
|
|
system fails, it is possible some number of the most recently
|
|
committed transactions may be undone during recovery. The number of
|
|
transactions at risk is governed by how many log updates can fit
|
|
into the log buffer, how often the operating system flushes dirty
|
|
buffers to disk, and how often the log is checkpointed.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TxnNoWait">
|
|
<summary>
|
|
If true and a lock is unavailable for any Berkeley DB operation
|
|
performed in the context of a transaction, cause the operation to
|
|
throw <see cref="T:BerkeleyDB.DeadlockException"/> (or
|
|
<see cref="T:BerkeleyDB.LockNotGrantedException"/> if configured with
|
|
<see cref="P:BerkeleyDB.DatabaseEnvironment.TimeNotGranted"/>).
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TxnSnapshot">
|
|
<summary>
|
|
If true, all transactions in the environment will be started as if
|
|
<see cref="F:BerkeleyDB.TransactionConfig.Snapshot"/> was passed to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>, and all non-transactional cursors
|
|
will be opened as if <see cref="F:BerkeleyDB.CursorConfig.SnapshotIsolation"/>
|
|
was passed to <see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TxnTimeout">
|
|
<summary>
|
|
A value, in microseconds, representing transaction timeouts.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
All timeouts are checked whenever a thread of control blocks on a
|
|
lock or when deadlock detection is performed. As timeouts are only
|
|
checked when the lock request first blocks or when deadlock
|
|
detection is performed, the accuracy of the timeout depends on how
|
|
often deadlock detection is performed.
|
|
</para>
|
|
<para>
|
|
Timeout values specified for the database environment may be
|
|
overridden on a per-transaction basis, see
|
|
<see cref="M:BerkeleyDB.Transaction.SetTxnTimeout(System.UInt32)"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TxnTimestamp">
|
|
<summary>
|
|
The recovery timestamp
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.TxnWriteNoSync">
|
|
<summary>
|
|
If true, Berkeley DB will write, but will not synchronously flush,
|
|
the log on transaction commit.
|
|
</summary>
|
|
<remarks>
|
|
This means that transactions exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability); that
|
|
is, database integrity will be maintained, but if the system fails,
|
|
it is possible some number of the most recently committed
|
|
transactions may be undone during recovery. The number of
|
|
transactions at risk is governed by how often the system flushes
|
|
dirty buffers to disk and how often the log is checkpointed.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UseMVCC">
|
|
<summary>
|
|
If true, all databases in the environment will be opened as if
|
|
<see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> was set.
|
|
</summary>
|
|
<remarks>
|
|
This flag will be ignored for queue databases for which MVCC is not
|
|
supported.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UsingCDB">
|
|
<summary>
|
|
If true, locking for the Berkeley DB Concurrent Data Store product
|
|
was initialized.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UsingLocking">
|
|
<summary>
|
|
If true, the locking subsystem was initialized.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UsingLogging">
|
|
<summary>
|
|
If true, the logging subsystem was initialized.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UsingMPool">
|
|
<summary>
|
|
If true, the shared memory buffer pool subsystem was initialized.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UsingReplication">
|
|
<summary>
|
|
If true, the replication subsystem was initialized.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UsingTxns">
|
|
<summary>
|
|
If true, the transaction subsystem was initialized.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.Verbosity">
|
|
<summary>
|
|
Specific additional informational and debugging messages in the
|
|
Berkeley DB message output.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.YieldCPU">
|
|
<summary>
|
|
If true, Berkeley DB will yield the processor immediately after each
|
|
page or mutex acquisition.
|
|
</summary>
|
|
<remarks>
|
|
This functionality should never be used for purposes other than
|
|
stress testing.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironment.UseEnvironmentVars">
|
|
<summary>
|
|
The Berkeley DB process' environment may be permitted to specify
|
|
information to be used when naming files; see Berkeley DB File
|
|
Naming in the Programmer's Reference Guide for more information.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ReplicationStats">
|
|
<summary>
|
|
Statistical information about the replication subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.CurrentQueuedLogRecords">
|
|
<summary>
|
|
Log records currently queued.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ClientStartupComplete">
|
|
<summary>
|
|
Site completed client sync-up.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.Status">
|
|
<summary>
|
|
Current replication status.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.NextLSN">
|
|
<summary>
|
|
Next LSN to use or expect.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.AwaitedLSN">
|
|
<summary>
|
|
LSN we're awaiting, if any.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MaxPermanentLSN">
|
|
<summary>
|
|
Maximum permanent LSN.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.NextPage">
|
|
<summary>
|
|
Next pg we expect.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.AwaitedPage">
|
|
<summary>
|
|
pg we're awaiting, if any.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.DupMasters">
|
|
<summary>
|
|
# of times a duplicate master condition was detected.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.EnvID">
|
|
<summary>
|
|
Current environment ID.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.EnvPriority">
|
|
<summary>
|
|
Current environment priority.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.BulkBufferFills">
|
|
<summary>
|
|
Bulk buffer fills.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.BulkBufferOverflows">
|
|
<summary>
|
|
Bulk buffer overflows.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.BulkRecordsStored">
|
|
<summary>
|
|
Bulk records stored.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.BulkBufferTransfers">
|
|
<summary>
|
|
Transfers of bulk buffers.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ForcedRerequests">
|
|
<summary>
|
|
Number of forced rerequests.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ClientServiceRequests">
|
|
<summary>
|
|
Number of client service requests received by this client.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ClientServiceRequestsMissing">
|
|
<summary>
|
|
Number of client service requests missing on this client.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.CurrentGenerationNumber">
|
|
<summary>
|
|
Current generation number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.CurrentElectionGenerationNumber">
|
|
<summary>
|
|
Current election gen number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.DuplicateLogRecords">
|
|
<summary>
|
|
Log records received multiply.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MaxQueuedLogRecords">
|
|
<summary>
|
|
Max. log records queued at once.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.QueuedLogRecords">
|
|
<summary>
|
|
Total # of log recs. ever queued.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ReceivedLogRecords">
|
|
<summary>
|
|
Log records received and put.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MissedLogRecords">
|
|
<summary>
|
|
Log recs. missed and requested.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MasterEnvID">
|
|
<summary>
|
|
Env. ID of the current master.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MasterChanges">
|
|
<summary>
|
|
# of times we've switched masters.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.BadGenerationMessages">
|
|
<summary>
|
|
Messages with a bad generation #.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ReceivedMessages">
|
|
<summary>
|
|
Messages received and processed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.IgnoredMessages">
|
|
<summary>
|
|
Messages ignored because this site was a client in recovery.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.FailedMessageSends">
|
|
<summary>
|
|
# of failed message sends.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MessagesSent">
|
|
<summary>
|
|
# of successful message sends.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.NewSiteMessages">
|
|
<summary>
|
|
# of NEWSITE msgs. received.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.Sites">
|
|
<summary>
|
|
Current number of sites we will assume during elections.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.Throttled">
|
|
<summary>
|
|
# of times we were throttled.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.Outdated">
|
|
<summary>
|
|
# of times we detected and returned an OUTDATED condition.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.DuplicatePages">
|
|
<summary>
|
|
Pages received multiply.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ReceivedPages">
|
|
<summary>
|
|
Pages received and stored.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MissedPages">
|
|
<summary>
|
|
Pages missed and requested.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.AppliedTransactions">
|
|
<summary>
|
|
# of transactions applied.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.StartSyncMessagesDelayed">
|
|
<summary>
|
|
# of STARTSYNC msgs delayed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.Elections">
|
|
<summary>
|
|
# of elections held.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ElectionsWon">
|
|
<summary>
|
|
# of elections won by this site.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.CurrentWinner">
|
|
<summary>
|
|
Current front-runner.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ElectionGenerationNumber">
|
|
<summary>
|
|
Election generation number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.CurrentWinnerMaxLSN">
|
|
<summary>
|
|
Max. LSN of current winner.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.RegisteredSites">
|
|
<summary>
|
|
# of "registered voters".
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.RegisteredSitesNeeded">
|
|
<summary>
|
|
# of "registered voters" needed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ElectionPriority">
|
|
<summary>
|
|
Current election priority.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ElectionStatus">
|
|
<summary>
|
|
Current election status.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ElectionTiebreaker">
|
|
<summary>
|
|
Election tiebreaker value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.Votes">
|
|
<summary>
|
|
Votes received in this round.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ElectionTimeSec">
|
|
<summary>
|
|
Last election time seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.ElectionTimeUSec">
|
|
<summary>
|
|
Last election time useconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MaxLeaseSec">
|
|
<summary>
|
|
Maximum lease timestamp seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationStats.MaxLeaseUSec">
|
|
<summary>
|
|
Maximum lease timestamp useconds.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ErrorCodes">
|
|
<summary>
|
|
Constants representing error codes returned by the Berkeley DB library.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_BUFFER_SMALL">
|
|
<summary>
|
|
User memory too small for return.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_DONOTINDEX">
|
|
<summary>
|
|
"Null" return from 2ndary callbk.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_FOREIGN_CONFLICT">
|
|
<summary>
|
|
A foreign db constraint triggered.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_KEYEMPTY">
|
|
<summary>
|
|
Key/data deleted or never created.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_KEYEXIST">
|
|
<summary>
|
|
The key/data pair already exists.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_LOCK_DEADLOCK">
|
|
<summary>
|
|
Deadlock.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_LOCK_NOTGRANTED">
|
|
<summary>
|
|
Lock unavailable.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_LOG_BUFFER_FULL">
|
|
<summary>
|
|
In-memory log buffer full.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_NOSERVER">
|
|
<summary>
|
|
Server panic return.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_NOSERVER_HOME">
|
|
<summary>
|
|
Bad home sent to server.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_NOSERVER_ID">
|
|
<summary>
|
|
Bad ID sent to server.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_NOTFOUND">
|
|
<summary>
|
|
Key/data pair not found (EOF).
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_OLD_VERSION">
|
|
<summary>
|
|
Out-of-date version.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_PAGE_NOTFOUND">
|
|
<summary>
|
|
Requested page not found.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_DUPMASTER">
|
|
<summary>
|
|
There are two masters.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_HANDLE_DEAD">
|
|
<summary>
|
|
Rolled back a commit.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_HOLDELECTION">
|
|
<summary>
|
|
Time to hold an election.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_IGNORE">
|
|
<summary>
|
|
This msg should be ignored.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_ISPERM">
|
|
<summary>
|
|
Cached not written perm written.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_JOIN_FAILURE">
|
|
<summary>
|
|
Unable to join replication group.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_LEASE_EXPIRED">
|
|
<summary>
|
|
Master lease has expired.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_LOCKOUT">
|
|
<summary>
|
|
API/Replication lockout now.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_NEWSITE">
|
|
<summary>
|
|
New site entered system.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_NOTPERM">
|
|
<summary>
|
|
Permanent log record not written.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_REP_UNAVAIL">
|
|
<summary>
|
|
Site cannot currently be reached.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_RUNRECOVERY">
|
|
<summary>
|
|
Panic return.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_SECONDARY_BAD">
|
|
<summary>
|
|
Secondary index corrupt.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_VERIFY_BAD">
|
|
<summary>
|
|
Verify failed; bad format.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ErrorCodes.DB_VERSION_MISMATCH">
|
|
<summary>
|
|
Environment version mismatch.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ActiveTransaction">
|
|
<summary>
|
|
The ActiveTransaction class describes a currently active transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.ID">
|
|
<summary>
|
|
The transaction ID of the transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.ParentID">
|
|
<summary>
|
|
The transaction ID of the parent transaction (or 0, if no parent).
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.ProcessID">
|
|
<summary>
|
|
The process ID of the originator of the transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.ThreadID">
|
|
<summary>
|
|
The thread of control ID of the originator of the transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.Begun">
|
|
<summary>
|
|
The current log sequence number when the transaction was begun.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.SnapshotReads">
|
|
<summary>
|
|
The log sequence number of reads for snapshot transactions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.BufferCopiesInCache">
|
|
<summary>
|
|
The number of MVCC buffer copies created by this transaction that
|
|
remain in cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.Status">
|
|
<summary>
|
|
Status of the transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.GlobalID">
|
|
<summary>
|
|
If the transaction is a prepare transaction, the transaction's
|
|
Global ID. Otherwise, the GlobalID contents are undefined.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ActiveTransaction.Name">
|
|
<summary>
|
|
If a name was specified for the transaction, up to the first 50
|
|
bytes of that name.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ActiveTransaction.TransactionStatus">
|
|
<summary>
|
|
The status of an active transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.ABORTED">
|
|
<summary>
|
|
The transaction has been aborted
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.COMMITTED">
|
|
<summary>
|
|
The transaction has been committed
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.PREPARED">
|
|
<summary>
|
|
The transaction has been prepared
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ActiveTransaction.TransactionStatus.RUNNING">
|
|
<summary>
|
|
The transaction is running
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryRecnoDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.RecnoDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.SecondaryDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for <see cref="T:BerkeleyDB.Database"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.Env">
|
|
<summary>
|
|
The Berkeley DB environment within which to create a database. If
|
|
null, the database will be created stand-alone; that is, it is not
|
|
part of any Berkeley DB environment.
|
|
</summary>
|
|
<remarks>
|
|
The database access methods automatically make calls to the other
|
|
subsystems in Berkeley DB, based on the enclosing environment. For
|
|
example, if the environment has been configured to use locking, the
|
|
access methods will automatically acquire the correct locks when
|
|
reading and writing pages of the database.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.Priority">
|
|
<summary>
|
|
The cache priority for pages referenced by the database.
|
|
</summary>
|
|
<remarks>
|
|
The priority of a page biases the replacement algorithm to be more
|
|
or less likely to discard a page when space is needed in the buffer
|
|
pool. The bias is temporary, and pages will eventually be discarded
|
|
if they are not referenced again. This priority is only advisory,
|
|
and does not guarantee pages will be treated in a specific way.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.CacheSize">
|
|
<summary>
|
|
The size of the shared memory buffer pool -- that is, the cache.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The cache should be the size of the normal working data set of the
|
|
application, with some small amount of additional memory for unusual
|
|
situations. (Note: the working set is not the same as the number of
|
|
pages accessed simultaneously, and is usually much larger.)
|
|
</para>
|
|
<para>
|
|
The default cache size is 256KB, and may not be specified as less
|
|
than 20KB. Any cache size less than 500MB is automatically increased
|
|
by 25% to account for buffer pool overhead; cache sizes larger than
|
|
500MB are used as specified. The maximum size of a single cache is
|
|
4GB on 32-bit systems and 10TB on 64-bit systems. (All sizes are in
|
|
powers-of-two, that is, 256KB is 2^18 not 256,000.) For information
|
|
on tuning the Berkeley DB cache size, see Selecting a cache size in
|
|
the Programmer's Reference Guide.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.ByteOrder">
|
|
<summary>
|
|
The byte order for integers in the stored database metadata. The
|
|
host byte order of the machine where the Berkeley DB library was
|
|
compiled is the default value.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The access methods provide no guarantees about the byte ordering of
|
|
the application data stored in the database, and applications are
|
|
responsible for maintaining any necessary ordering.
|
|
</para>
|
|
<para>
|
|
If creating additional databases in a single physical file, this
|
|
parameter will be ignored and the byte order of the existing
|
|
databases will be used.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseConfig.SetEncryption(System.String,BerkeleyDB.EncryptionAlgorithm)">
|
|
<summary>
|
|
Set the password and algorithm used by the Berkeley DB library to
|
|
perform encryption and decryption.
|
|
</summary>
|
|
<param name="password">
|
|
The password used to perform encryption and decryption.
|
|
</param>
|
|
<param name="alg">
|
|
The algorithm used to perform encryption and decryption.
|
|
</param>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.ErrorPrefix">
|
|
<summary>
|
|
The prefix string that appears before error messages issued by
|
|
Berkeley DB.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.MessagePrefix">
|
|
<summary>
|
|
The prefix string that appears before informational messages issued
|
|
by Berkeley DB.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.ErrorFeedback">
|
|
<summary>
|
|
The mechanism for reporting error messages to the application.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
In some cases, when an error occurs, Berkeley DB will call
|
|
ErrorFeedback with additional error information. It is up to the
|
|
delegate function to display the error message in an appropriate
|
|
manner.
|
|
</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 Berkeley DB environments, setting
|
|
ErrorFeedback affects the entire environment and is equivalent to
|
|
setting <see cref="P:BerkeleyDB.DatabaseEnvironment.ErrorFeedback"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.Feedback">
|
|
<summary>
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.DoChecksum">
|
|
<summary>
|
|
If true, do checksum verification of pages read into the cache from
|
|
the backing filestore.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Berkeley DB uses the SHA1 Secure Hash Algorithm if encryption is
|
|
configured and a general hash algorithm if it is not.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.NonDurableTxns">
|
|
<summary>
|
|
If true, Berkeley DB will not write log records for this database.
|
|
</summary>
|
|
<remarks>
|
|
If Berkeley DB does not write log records, updates of this database
|
|
will exhibit the ACI (atomicity, consistency, and isolation)
|
|
properties, but not D (durability); that is, database integrity will
|
|
be maintained, but if the application or system fails, integrity
|
|
will not persist. The database file must be verified and/or restored
|
|
from backup after a failure. In order to ensure integrity after
|
|
application shut down, the database must be synced when closed, or
|
|
all database changes must be flushed from the database environment
|
|
cache using either
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Checkpoint"/> or
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.SyncMemPool"/>. All database objects
|
|
for a single physical file must set NonDurableTxns, including
|
|
database objects for different databases in a physical file.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.AutoCommit">
|
|
<summary>
|
|
Enclose the open call within a transaction. If the call succeeds,
|
|
the open operation will be recoverable and all subsequent database
|
|
modification operations based on this handle will be transactionally
|
|
protected. If the call fails, no database will have been created.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.FreeThreaded">
|
|
<summary>
|
|
Cause the database object to be free-threaded; that is, concurrently
|
|
usable by multiple threads in the address space.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.NoMMap">
|
|
<summary>
|
|
Do not map this database into process memory.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.ReadOnly">
|
|
<summary>
|
|
Open the database 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="F:BerkeleyDB.DatabaseConfig.ReadUncommitted">
|
|
<summary>
|
|
Support transactional read operations with degree 1 isolation.
|
|
</summary>
|
|
<remarks>
|
|
Read operations on the database may request the return of modified
|
|
but not yet committed data. This flag must be specified on all
|
|
database objects used to perform dirty reads or database updates,
|
|
otherwise requests for dirty reads may not be honored and the read
|
|
may block.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.Truncate">
|
|
<summary>
|
|
Physically truncate the underlying file, discarding all previous databases it might have held.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Underlying filesystem primitives are used to implement this flag.
|
|
For this reason, it is applicable only to the file and cannot be
|
|
used to discard databases within a file.
|
|
</para>
|
|
<para>
|
|
This setting cannot be lock or transaction-protected, and it is an
|
|
error to specify it in a locking or transaction-protected
|
|
environment.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseConfig.UseMVCC">
|
|
<summary>
|
|
Open the database with support for multiversion concurrency control.
|
|
</summary>
|
|
<remarks>
|
|
This will cause updates to the database to follow a copy-on-write
|
|
protocol, which is required to support snapshot isolation. This
|
|
settting requires that the database be transactionally protected
|
|
during its open and is not supported by the queue format.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseConfig.#ctor">
|
|
<summary>
|
|
Instantiate a new DatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseConfig.PageSize">
|
|
<summary>
|
|
The size of the pages used to hold items in the database, in bytes.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The minimum page size is 512 bytes, the maximum page size is 64K
|
|
bytes, and the page size must be a power-of-two. If the page size is
|
|
not explicitly set, one is selected based on the underlying
|
|
filesystem I/O block size. The automatically selected size has a
|
|
lower limit of 512 bytes and an upper limit of 16K bytes.
|
|
</para>
|
|
<para>
|
|
For information on tuning the Berkeley DB page size, see Selecting a
|
|
page size in the Programmer's Reference Guide.
|
|
</para>
|
|
<para>
|
|
If creating additional databases in a single physical file, this
|
|
parameter will be ignored and the page size of the existing
|
|
databases will be used.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseConfig.EncryptionPassword">
|
|
<summary>
|
|
The password used to perform encryption and decryption.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseConfig.EncryptAlgorithm">
|
|
<summary>
|
|
The algorithm used to perform encryption and decryption.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryDatabaseConfig.Populate">
|
|
<summary>
|
|
If true and the secondary database is empty, walk through Primary
|
|
and create an index to it in the empty secondary. This operation is
|
|
potentially very expensive.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If the secondary database has been opened in an environment
|
|
configured with transactions, the entire secondary index creation is
|
|
performed in the context of a single transaction.
|
|
</para>
|
|
<para>
|
|
Care should be taken not to use a newly-populated secondary database
|
|
in another thread of control until
|
|
<see cref="M:BerkeleyDB.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig)"/> has returned successfully in
|
|
the first thread.
|
|
</para>
|
|
<para>
|
|
If transactions are not being used, care should be taken not to
|
|
modify a primary database being used to populate a secondary
|
|
database, in another thread of control, until
|
|
<see cref="M:BerkeleyDB.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig)"/> has returned successfully in
|
|
the first thread. If transactions are being used, Berkeley DB will
|
|
perform appropriate locking and the application need not do any
|
|
special operation ordering.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryDatabaseConfig.ImmutableKey">
|
|
<summary>
|
|
If true, the secondary key is immutable.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This setting can be used to optimize updates when the secondary key
|
|
in a primary record will never be changed after the primary record
|
|
is inserted. For immutable secondary keys, a best effort is made to
|
|
avoid calling the secondary callback function when primary records
|
|
are updated. This optimization may reduce the overhead of update
|
|
operations significantly if the callback function is expensive.
|
|
</para>
|
|
<para>
|
|
Be sure to specify this setting only if the secondary key in the
|
|
primary record is never changed. If this rule is violated, the
|
|
secondary index will become corrupted, that is, it will become out
|
|
of sync with the primary.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
|
|
<summary>
|
|
Instantiate a new SecondaryDatabaseConfig object, with the default
|
|
configuration settings.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
|
|
<summary>
|
|
All updates to Primary will be automatically reflected in the
|
|
secondary and all reads from the secondary will return corresponding
|
|
data from Primary.
|
|
</summary>
|
|
<remarks>
|
|
Note that as primary keys must be unique for secondary indices to
|
|
work, Primary must have been configured with
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryDatabaseConfig.KeyGen">
|
|
<summary>
|
|
The delegate that creates the set of secondary keys corresponding to
|
|
a given primary key and data pair.
|
|
</summary>
|
|
<remarks>
|
|
KeyGen may be null if both
|
|
<see cref="P:BerkeleyDB.BaseDatabase.ReadOnly">Primary.ReadOnly</see> and
|
|
<see cref="F:BerkeleyDB.DatabaseConfig.ReadOnly"/> are true.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Renumber">
|
|
<summary>
|
|
Cause the logical record numbers to be mutable, and change as
|
|
records are added to and deleted from the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
For example, the deletion of record number 4 causes records numbered
|
|
5 and greater to be renumbered downward by one. If a cursor was
|
|
positioned to record number 4 before the deletion, it will refer to
|
|
the new record number 4, if any such record exists, after the
|
|
deletion. If a cursor was positioned after record number 4 before
|
|
the deletion, it will be shifted downward one logical record,
|
|
continuing to refer to the same record as it did before.
|
|
</para>
|
|
<para>
|
|
Using <see cref="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> or <see cref="M:BerkeleyDB.Cursor.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32)"/> to
|
|
create new records will cause the creation of multiple records if
|
|
the record number is more than one greater than the largest record
|
|
currently in the database. For example, creating record 28, when
|
|
record 25 was previously the last record in the database, will
|
|
create records 26 and 27 as well as 28. Attempts to retrieve records
|
|
that were created in this manner will throw a
|
|
<see cref="T:BerkeleyDB.KeyEmptyException"/>.
|
|
</para>
|
|
<para>
|
|
If a created record is not at the end of the database, all records
|
|
following the new record will be automatically renumbered upward by
|
|
one. For example, the creation of a new record numbered 8 causes
|
|
records numbered 8 and greater to be renumbered upward by one. If a
|
|
cursor was positioned to record number 8 or greater before the
|
|
insertion, it will be shifted upward one logical record, continuing
|
|
to refer to the same record as it did before.
|
|
</para>
|
|
<para>
|
|
For these reasons, concurrent access to a
|
|
<see cref="T:BerkeleyDB.SecondaryRecnoDatabase"/> with this setting specified may
|
|
be largely meaningless, although it is supported.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting must be the same as the
|
|
existing database or an exception will be thrown.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Snapshot">
|
|
<summary>
|
|
If true, any <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> file will be read in its
|
|
entirety when <see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> is called.
|
|
If false, <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> may be read lazily.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile">
|
|
<summary>
|
|
The underlying source file for the Recno access method.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The purpose of the source file is to provide fast access and
|
|
modification to databases that are normally stored as flat text
|
|
files.
|
|
</para>
|
|
<para>
|
|
The source parameter specifies an underlying flat text database file
|
|
that is read to initialize a transient record number index. In the
|
|
case of variable length records, the records are separated, as
|
|
specified by <see cref="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.Delimiter"/>. For example, standard UNIX
|
|
byte stream files can be interpreted as a sequence of variable
|
|
length records separated by newline characters.
|
|
</para>
|
|
<para>
|
|
In addition, when cached data would normally be written back to the
|
|
underlying database file (for example,
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Close"/> or
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Sync"/>), the in-memory copy of the
|
|
database will be written back to the source file.
|
|
</para>
|
|
<para>
|
|
By default, the backing source file is read lazily; that is, records
|
|
are not read from the file until they are requested by the
|
|
application. If multiple processes (not threads) are accessing a
|
|
Recno database concurrently, and are either inserting or deleting
|
|
records, the backing source file must be read in its entirety before
|
|
more than a single process accesses the database, and only that
|
|
process should specify the backing source file as part of the
|
|
<see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> call. See
|
|
<see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.Snapshot"/> for more information.
|
|
</para>
|
|
<para>
|
|
Reading and writing the backing source file specified by source
|
|
cannot be transaction-protected because it involves filesystem
|
|
operations that are not part of the Db transaction methodology. For
|
|
this reason, if a temporary database is used to hold the records, it
|
|
is possible to lose the contents of the source file, for example, if
|
|
the system crashes at the right instant. If a file is used to hold
|
|
the database, normal database recovery on that file can be used to
|
|
prevent information loss, although it is still possible that the
|
|
contents of source will be lost if the system crashes.
|
|
</para>
|
|
<para>
|
|
The source file must already exist (but may be zero-length) when
|
|
<see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> is called.
|
|
</para>
|
|
<para>
|
|
It is not an error to specify a read-only source file when creating
|
|
a database, nor is it an error to modify the resulting database.
|
|
However, any attempt to write the changes to the backing source file
|
|
using either the <see cref="M:BerkeleyDB.BaseDatabase.Sync"/> or
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Close"/> methods will fail, of course.
|
|
Use <see cref="M:BerkeleyDB.BaseDatabase.Close(System.Boolean)"/> to stop it from
|
|
attempting to write the changes to the backing file; instead, they
|
|
will be silently discarded.
|
|
</para>
|
|
<para>
|
|
For all of the previous reasons, the source file is generally used
|
|
to specify databases that are read-only for Berkeley DB
|
|
applications; and that are either generated on the fly by software
|
|
tools or modified using a different mechanism — for example, a text
|
|
editor.
|
|
</para>
|
|
<para>
|
|
If the database already exists, BackingFile must be the same as that
|
|
historically used to create the database or corruption can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryRecnoDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
|
|
<summary>
|
|
Instantiate a new SecondaryRecnoDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.Delimiter">
|
|
<summary>
|
|
The delimiting byte used to mark the end of a record in
|
|
<see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/>.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This byte is used for variable length records if
|
|
<see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> is set. If <see cref="F:BerkeleyDB.SecondaryRecnoDatabaseConfig.BackingFile"/> is
|
|
specified and no delimiting byte was specified, newline characters
|
|
(that is, ASCII 0x0a) are interpreted as end-of-record markers.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.Length">
|
|
<summary>
|
|
Specify that the records are fixed-length, not byte-delimited, and
|
|
are of length Length.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Any records added to the database that are less than Length bytes
|
|
long are automatically padded (see <see cref="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.PadByte"/> for more
|
|
information).
|
|
</para>
|
|
<para>
|
|
Any attempt to insert records into the database that are greater
|
|
than Length bytes long will cause the call to fail immediately and
|
|
return an error.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabaseConfig.PadByte">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If no pad character is specified, space characters (that is, ASCII
|
|
0x20) are used for padding.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.MultipleDatabaseEntry">
|
|
<summary>
|
|
A class providing access to multiple <see cref="T:BerkeleyDB.DatabaseEntry"/>
|
|
objects.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.MultipleDatabaseEntry.GetEnumerator">
|
|
<summary>
|
|
Return an enumerator which iterates over all
|
|
<see cref="T:BerkeleyDB.DatabaseEntry"/> objects represented by the
|
|
<see cref="T:BerkeleyDB.MultipleDatabaseEntry"/>.
|
|
</summary>
|
|
<returns>
|
|
An enumerator for the <see cref="T:BerkeleyDB.MultipleDatabaseEntry"/>
|
|
</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.CachePriority">
|
|
<summary>
|
|
A class to represent cache priority for database pages
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CachePriority.VERY_LOW">
|
|
<summary>
|
|
The lowest priority: pages are the most likely to be discarded.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CachePriority.LOW">
|
|
<summary>
|
|
The next lowest priority.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CachePriority.DEFAULT">
|
|
<summary>
|
|
The default priority.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CachePriority.HIGH">
|
|
<summary>
|
|
The next highest priority.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CachePriority.VERY_HIGH">
|
|
<summary>
|
|
The highest priority: pages are the least likely to be discarded.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SequenceStats">
|
|
<summary>
|
|
Statistical information about a Sequence
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.CacheSize">
|
|
<summary>
|
|
Cache size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.CachedValue">
|
|
<summary>
|
|
Current cached value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.Flags">
|
|
<summary>
|
|
Flag value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.LastCachedValue">
|
|
<summary>
|
|
Last cached value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.LockWait">
|
|
<summary>
|
|
Sequence lock granted w/o wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.LockNoWait">
|
|
<summary>
|
|
Sequence lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.Max">
|
|
<summary>
|
|
Maximum value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.Min">
|
|
<summary>
|
|
Minimum value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceStats.StoredValue">
|
|
<summary>
|
|
Current value in db.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.QueueDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.QueueDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.QueueDatabaseConfig.ConsumeInOrder">
|
|
<summary>
|
|
If true, modify the operation of <see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/>
|
|
to return key/data pairs in order. That is, they will always return
|
|
the key/data item from the head of the queue.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The default behavior of queue databases is optimized for multiple
|
|
readers, and does not guarantee that record will be retrieved in the
|
|
order they are added to the queue. Specifically, if a writing thread
|
|
adds multiple records to an empty queue, reading threads may skip
|
|
some of the initial records when the next
|
|
<see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/> call returns.
|
|
</para>
|
|
<para>
|
|
This setting modifies <see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/> to verify
|
|
that the record being returned is in fact the head of the queue.
|
|
This will increase contention and reduce concurrency when there are
|
|
many reading threads.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.QueueDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.QueueDatabaseConfig.Append">
|
|
<summary>
|
|
A function to call after the record number has been selected but
|
|
before the data has been stored into the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
When using <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>, it may be useful to
|
|
modify the stored data based on the generated key. If a delegate is
|
|
specified, it will be called after the record number has been
|
|
selected, but before the data has been stored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabaseConfig.#ctor">
|
|
<summary>
|
|
Instantiate a new QueueDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueDatabaseConfig.Length">
|
|
<summary>
|
|
Specify the length of records in the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The record length must be enough smaller than
|
|
<see cref="P:BerkeleyDB.DatabaseConfig.PageSize"/> that at least one record plus
|
|
the database page's metadata information can fit on each database
|
|
page.
|
|
</para>
|
|
<para>
|
|
Any records added to the database that are less than Length bytes
|
|
long are automatically padded (see <see cref="P:BerkeleyDB.QueueDatabaseConfig.PadByte"/> for more
|
|
information).
|
|
</para>
|
|
<para>
|
|
Any attempt to insert records into the database that are greater
|
|
than Length bytes long will cause the call to fail immediately and
|
|
return an error.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueDatabaseConfig.PadByte">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If no pad character is specified, space characters (that is, ASCII
|
|
0x20) are used for padding.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueDatabaseConfig.ExtentSize">
|
|
<summary>
|
|
The size of the extents used to hold pages in a
|
|
<see cref="T:BerkeleyDB.QueueDatabase"/>, specified as a number of pages.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Each extent is created as a separate physical file. If no extent
|
|
size is set, the default behavior is to create only a single
|
|
underlying database file.
|
|
</para>
|
|
<para>
|
|
For information on tuning the extent size, see Selecting a extent
|
|
size in the Programmer's Reference Guide.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.HashDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.HashDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.HashDatabaseConfig.Duplicates">
|
|
<summary>
|
|
Policy for duplicate data items in the database; that is, insertion
|
|
when the key of the key/data pair being inserted already exists in
|
|
the database will be successful.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The ordering of duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
|
|
of insertion, unless the ordering is otherwise specified by use of a
|
|
cursor operation or a duplicate sort function. The ordering of
|
|
duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
|
|
duplicate comparison function. If the application does not specify a
|
|
comparison function using
|
|
<see cref="F:BerkeleyDB.HashDatabaseConfig.DuplicateCompare"/>, a default lexical
|
|
comparison will be used.
|
|
</para>
|
|
<para>
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
|
|
applications wanting to order duplicate data items manually.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the value of Duplicates must be the
|
|
same as the existing database or an error will be returned.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.HashDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.HashDatabaseConfig.HashComparison">
|
|
<summary>
|
|
The Hash key comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the keys are compared
|
|
lexically, with shorter keys collating before longer keys.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the comparison function must be the
|
|
same as that historically used to create the database or corruption
|
|
can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.HashDatabaseConfig.HashFunction">
|
|
<summary>
|
|
A user-defined hash function; if no hash function is specified, a
|
|
default hash function is used.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Because no hash function performs equally well on all possible data,
|
|
the user may find that the built-in hash function performs poorly
|
|
with a particular data set.
|
|
</para>
|
|
<para>
|
|
If the database already exists, HashFunction must be the same as
|
|
that historically used to create the database or corruption can
|
|
occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.HashDatabaseConfig.DuplicateCompare">
|
|
<summary>
|
|
The duplicate data item comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The comparison function is called whenever it is necessary to
|
|
compare a data item specified by the application with a data item
|
|
currently stored in the database. Setting DuplicateCompare implies
|
|
setting <see cref="F:BerkeleyDB.HashDatabaseConfig.Duplicates"/> to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the data items are compared
|
|
lexically, with shorter data items collating before longer data
|
|
items.
|
|
</para>
|
|
<para>
|
|
If the database already exists when <see cref="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)"/>
|
|
is called, the delegate must be the same as that historically used
|
|
to create the database or corruption can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.HashDatabaseConfig.#ctor">
|
|
<summary>
|
|
Instantiate a new HashDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashDatabaseConfig.FillFactor">
|
|
<summary>
|
|
The desired density within the hash table. If no value is specified,
|
|
the fill factor will be selected dynamically as pages are filled.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The density is an approximation of the number of keys allowed to
|
|
accumulate in any one bucket, determining when the hash table grows
|
|
or shrinks. If you know the average sizes of the keys and data in
|
|
your data set, setting the fill factor can enhance performance. A
|
|
reasonable rule computing fill factor is to set it to the following:
|
|
</para>
|
|
<para>
|
|
(pagesize - 32) / (average_key_size + average_data_size + 8)
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashDatabaseConfig.TableSize">
|
|
<summary>
|
|
An estimate of the final size of the hash table.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
In order for the estimate to be used when creating the database,
|
|
<see cref="P:BerkeleyDB.HashDatabaseConfig.FillFactor"/> must also be set. If the estimate or fill
|
|
factor are not set or are set too low, hash tables will still expand
|
|
gracefully as keys are entered, although a slight performance
|
|
degradation may be noticed.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryRecnoDatabase">
|
|
<summary>
|
|
A class representing a RecnoDatabase. The Recno format supports fixed-
|
|
or variable-length records, accessed sequentially or by logical record
|
|
number, and optionally backed by a flat text file.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryDatabase">
|
|
<summary>
|
|
A class representing a secondary Berkeley DB database, a base class for
|
|
access method specific classes.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryDatabase.#ctor(BerkeleyDB.DatabaseEnvironment,System.UInt32)">
|
|
<summary>
|
|
Protected construtor
|
|
</summary>
|
|
<param name="env">The environment in which to open the DB</param>
|
|
<param name="flags">Flags to pass to DB->create</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryDatabase.Config(BerkeleyDB.SecondaryDatabaseConfig)">
|
|
<summary>
|
|
Protected method to configure the DB. Only valid before DB->open.
|
|
</summary>
|
|
<param name="cfg">Configuration parameters.</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryDatabase object, open the database
|
|
represented by <paramref name="Filename"/> and associate the
|
|
database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
|
|
primary index</see>. 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.SecondaryDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryDatabase object, open the database
|
|
represented by <paramref name="Filename"/> and associate the
|
|
database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
|
|
primary index</see>. 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.
|
|
</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.SecondaryDatabase.Open(System.String,BerkeleyDB.SecondaryDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryDatabase object, open the database
|
|
represented by <paramref name="Filename"/> and associate the
|
|
database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
|
|
primary index</see>. 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>
|
|
<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.SecondaryDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryDatabase object, open the database
|
|
represented by <paramref name="Filename"/> and associate the
|
|
database with the <see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">
|
|
primary index</see>. 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.
|
|
</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.SecondaryDatabase.doAssociate(System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr)">
|
|
<summary>
|
|
Protected method to call the key generation function.
|
|
</summary>
|
|
<param name="dbp">Secondary DB Handle</param>
|
|
<param name="keyp">Primary Key</param>
|
|
<param name="datap">Primary Data</param>
|
|
<param name="skeyp">Scondary Key</param>
|
|
<returns>0 on success, !0 on failure</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryDatabase.doNullify(System.IntPtr,System.IntPtr,System.IntPtr,System.IntPtr,System.Int32@)">
|
|
<summary>
|
|
Protected method to nullify a foreign key
|
|
</summary>
|
|
<param name="dbp">Secondary DB Handle</param>
|
|
<param name="keyp">Primary Key</param>
|
|
<param name="datap">Primary Data</param>
|
|
<param name="fkeyp">Foreign Key</param>
|
|
<param name="changed">Whether the foreign key has changed</param>
|
|
<returns>0 on success, !0 on failure</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryDatabase.SecondaryCursor">
|
|
<summary>
|
|
Create a secondary database cursor.
|
|
</summary>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryDatabase.SecondaryCursor(BerkeleyDB.CursorConfig)">
|
|
<summary>
|
|
Create a secondary 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.SecondaryDatabase.SecondaryCursor(BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Create a transactionally protected secondary 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.SecondaryDatabase.SecondaryCursor(BerkeleyDB.CursorConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Create a transactionally protected secondary 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="P:BerkeleyDB.SecondaryDatabase.KeyGen">
|
|
<summary>
|
|
The delegate that creates the set of secondary keys corresponding to
|
|
a given primary key and data pair.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryRecnoDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryRecnoDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryRecnoDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryRecnoDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryRecnoDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryRecnoDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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="P:BerkeleyDB.SecondaryRecnoDatabase.Renumber">
|
|
<summary>
|
|
If true, the logical record numbers are mutable, and change as
|
|
records are added to and deleted from the database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabase.Snapshot">
|
|
<summary>
|
|
If true, any <see cref="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile"/> file will be read in its
|
|
entirety when <see cref="M:BerkeleyDB.SecondaryRecnoDatabase.Open(System.String,BerkeleyDB.SecondaryRecnoDatabaseConfig)"/> is called. If false,
|
|
<see cref="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile"/> may be read lazily.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabase.Delimiter">
|
|
<summary>
|
|
The delimiting byte used to mark the end of a record in
|
|
<see cref="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabase.Length">
|
|
<summary>
|
|
If using fixed-length, not byte-delimited records, the length of the
|
|
records.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabase.PadByte">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryRecnoDatabase.BackingFile">
|
|
<summary>
|
|
The underlying source file for the Recno access method.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.TransactionStats">
|
|
<summary>
|
|
Statistical information about the transaction subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.Aborted">
|
|
<summary>
|
|
Number of aborted transactions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.Active">
|
|
<summary>
|
|
Number of active transactions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.Begun">
|
|
<summary>
|
|
Number of begun transactions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.Committed">
|
|
<summary>
|
|
Number of committed transactions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.LastCheckpoint">
|
|
<summary>
|
|
LSN of the last checkpoint
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.LastCheckpointTime">
|
|
<summary>
|
|
Time of last checkpoint
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.LastID">
|
|
<summary>
|
|
Last transaction id given out
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.MaxActive">
|
|
<summary>
|
|
Maximum active transactions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.MaxSnapshot">
|
|
<summary>
|
|
Maximum snapshot transactions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.MaxTransactions">
|
|
<summary>
|
|
Maximum txns possible
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.RegionLockNoWait">
|
|
<summary>
|
|
Region lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.RegionSize">
|
|
<summary>
|
|
Region size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.RegionLockWait">
|
|
<summary>
|
|
Region lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.Restored">
|
|
<summary>
|
|
Number of restored transactions after recovery.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.Snapshot">
|
|
<summary>
|
|
Number of snapshot transactions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionStats.Transactions">
|
|
<summary>
|
|
List of active transactions
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.HashCursor">
|
|
<summary>
|
|
A class for traversing the records of a <see cref="T:BerkeleyDB.HashDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.Cursor">
|
|
<summary>
|
|
A class representing database cursors, which allow for traversal of
|
|
database records.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BaseCursor">
|
|
<summary>
|
|
<para>
|
|
The abstract base class from which all cursor classes inherit.
|
|
</para>
|
|
<para>
|
|
Cursors may span threads, but only serially, that is, the application
|
|
must serialize access to the cursor handle.
|
|
</para>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BaseCursor.dbc">
|
|
<summary>
|
|
The underlying DBC handle
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BaseCursor.Compare(BerkeleyDB.Cursor)">
|
|
<summary>
|
|
Compare this cursor's position to another's.
|
|
</summary>
|
|
<param name="compareTo">The cursor with which to compare.</param>
|
|
<returns>
|
|
True if both cursors point to the same item, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BaseCursor.Count">
|
|
<summary>
|
|
Returns a count of the number of data items for the key to which the
|
|
cursor refers.
|
|
</summary>
|
|
<returns>
|
|
A count of the number of data items for the key to which the cursor
|
|
refers.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BaseCursor.Close">
|
|
<summary>
|
|
<para>
|
|
Discard the cursor.
|
|
</para>
|
|
<para>
|
|
It is possible for the Close() method to throw a
|
|
<see cref="T:BerkeleyDB.DeadlockException"/>, signaling that any enclosing
|
|
transaction should be aborted. If the application is already
|
|
intending to abort the transaction, this error should be ignored,
|
|
and the application should proceed.
|
|
</para>
|
|
<para>
|
|
After Close has been called, regardless of its result, the object
|
|
may not be used again.
|
|
</para>
|
|
</summary>
|
|
<exception cref="T:BerkeleyDB.DeadlockException"></exception>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BaseCursor.Dispose">
|
|
<summary>
|
|
Release the resources held by this object, and close the cursor if
|
|
it's still open.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BaseCursor.Delete">
|
|
<summary>
|
|
<para>
|
|
Delete the key/data pair to which the cursor refers.
|
|
</para>
|
|
<para>
|
|
When called on a SecondaryCursor, delete the key/data pair from the
|
|
primary database and all secondary indices.
|
|
</para>
|
|
<para>
|
|
The cursor position is unchanged after a delete, and subsequent
|
|
calls to cursor functions expecting the cursor to refer to an
|
|
existing key will fail.
|
|
</para>
|
|
</summary>
|
|
<exception cref="T:BerkeleyDB.KeyEmptyException">
|
|
Thrown if the element has already been deleted.
|
|
</exception>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BaseCursor.GetEnumerator">
|
|
<summary>
|
|
Returns an enumerator that iterates through the cursor.
|
|
</summary>
|
|
<returns>An enumerator for the cursor.</returns>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Cursor.pgsz">
|
|
<summary>
|
|
Protected member, storing the pagesize of the underlying database.
|
|
Used during bulk get (i.e. Move*Multiple).
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},BerkeleyDB.Cursor.InsertLocation)">
|
|
<summary>
|
|
Protected method for BTree and Hash to insert with KEYFIRST and
|
|
KEYLAST.
|
|
</summary>
|
|
<param name="pair">The key/data pair to add</param>
|
|
<param name="loc">Where to add, if adding duplicate data</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.AddUnique(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
|
|
<summary>
|
|
Protected method for BTree and Hash to insert with NODUPDATA.
|
|
</summary>
|
|
<param name="pair">The key/data pair to add</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
|
|
<summary>
|
|
Protected method for BTree, Hash and Recno to insert with AFTER and
|
|
BEFORE.
|
|
</summary>
|
|
<param name="data">The duplicate data item to add</param>
|
|
<param name="loc">
|
|
Whether to add the dup data before or after the current cursor
|
|
position
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Get(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Protected method wrapping DBC->get.
|
|
</summary>
|
|
<param name="key">The key to retrieve</param>
|
|
<param name="data">The data to retrieve</param>
|
|
<param name="flags">Modify the behavior of get</param>
|
|
<param name="info">The locking configuration to use</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.GetMultiple(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32,System.UInt32,BerkeleyDB.LockingInfo,System.Boolean)">
|
|
<summary>
|
|
Protected method wrapping DBC->get for bulk get.
|
|
</summary>
|
|
<param name="key">The key to retrieve</param>
|
|
<param name="data">The data to retrieve</param>
|
|
<param name="BufferSize">Size of the bulk buffer</param>
|
|
<param name="flags">Modify the behavior of get</param>
|
|
<param name="info">The locking configuration to use</param>
|
|
<param name="isMultKey">
|
|
If true, use DB_MULTIPLE_KEY instead of DB_MULTIPLE
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32)">
|
|
<summary>
|
|
Protected method wrapping DBC->put.
|
|
</summary>
|
|
<param name="key">The key to store</param>
|
|
<param name="data">The data to store</param>
|
|
<param name="flags">Modify the behavior of put</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
|
|
<summary>
|
|
Stores the key/data pair in the database.
|
|
</summary>
|
|
<remarks>
|
|
If the underlying database supports duplicate data items, and if the
|
|
key already exists in the database and a duplicate sort function has
|
|
been specified, the inserted data item is added in its sorted
|
|
location. If the key already exists in the database and no duplicate
|
|
sort function has been specified, the inserted data item is added as
|
|
the first of the data items for that key.
|
|
</remarks>
|
|
<param name="pair">
|
|
The key/data pair to be stored in the database.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Delete">
|
|
<summary>
|
|
Delete the key/data pair to which the cursor refers.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The cursor position is unchanged after a delete, and subsequent
|
|
calls to cursor functions expecting the cursor to refer to an
|
|
existing key will fail.
|
|
</para>
|
|
</remarks>
|
|
<exception cref="T:BerkeleyDB.KeyEmptyException">
|
|
The element has already been deleted.
|
|
</exception>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Duplicate(System.Boolean)">
|
|
<summary>
|
|
Create a new cursor that uses the same transaction and locker ID as
|
|
the original cursor.
|
|
</summary>
|
|
<remarks>
|
|
This is useful when an application is using locking and requires two
|
|
or more cursors in the same thread of control.
|
|
</remarks>
|
|
<param name="keepPosition">
|
|
If true, the newly created cursor is initialized to refer to the
|
|
same position in the database as the original cursor (if any) and
|
|
hold the same locks (if any). If false, or the original cursor does
|
|
not hold a database position and locks, the created cursor is
|
|
uninitialized and will behave like a cursor newly created by
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.</param>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.GetEnumerator">
|
|
<summary>
|
|
Returns an enumerator that iterates through the
|
|
<see cref="T:BerkeleyDB.Cursor"/>.
|
|
</summary>
|
|
<remarks>
|
|
The enumerator will begin at the cursor's current position (or the
|
|
first record if the cursor has not yet been positioned) and iterate
|
|
forwards (i.e. in the direction of <see cref="M:BerkeleyDB.Cursor.MoveNext"/>) over the
|
|
remaining records.
|
|
</remarks>
|
|
<returns>An enumerator for the Cursor.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirst">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the first key has
|
|
duplicate values, the first data item in the set of duplicates is
|
|
stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirst(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the first key has
|
|
duplicate values, the first data item in the set of duplicates is
|
|
stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultiple">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that key and as many duplicate data items that can fit in
|
|
a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<overloads>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> will
|
|
contain an empty
|
|
<see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</overloads>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that key and as many duplicate data items that can fit in
|
|
a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultiple(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that key and as many duplicate data items that can fit in
|
|
a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that key and as many duplicate data items that can fit in
|
|
a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that pair and as many ensuing key/data pairs that can fit
|
|
in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that pair and as many ensuing key/data pairs that can fit
|
|
in a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that pair and as many ensuing key/data pairs that can fit
|
|
in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store that pair and as many ensuing key/data pairs that can fit
|
|
in a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store the
|
|
datum associated with the given key in <see cref="P:BerkeleyDB.Cursor.Current"/>. In the
|
|
presence of duplicate key values, the first data item in the set of
|
|
duplicates is stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store the
|
|
datum associated with the given key in <see cref="P:BerkeleyDB.Cursor.Current"/>. In the
|
|
presence of duplicate key values, the first data item in the set of
|
|
duplicates is stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database. The
|
|
cursor is positioned to a key/data pair if both the key and data
|
|
match the values provided on the key and data parameters.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</para>
|
|
<para>
|
|
If this flag is specified on a database configured without sorted
|
|
duplicate support, the value of <paramref name="exact"/> is ignored.
|
|
</para>
|
|
</remarks>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database. The
|
|
cursor is positioned to a key/data pair if both the key and data
|
|
match the values provided on the key and data parameters.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</para>
|
|
<para>
|
|
If this flag is specified on a database configured without sorted
|
|
duplicate support, the value of <paramref name="exact"/> is ignored.
|
|
</para>
|
|
</remarks>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveLast">
|
|
<summary>
|
|
Set the cursor to refer to the last key/data pair of the database,
|
|
and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the last key has
|
|
duplicate values, the last data item in the set of duplicates is
|
|
stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveLast(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the last key/data pair of the database,
|
|
and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>. If the last key has
|
|
duplicate values, the last data item in the set of duplicates is
|
|
stored in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many duplicate data items associated with the given key that
|
|
can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many duplicate data items associated with the given key that
|
|
can fit in a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many duplicate data items associated with the given key that
|
|
can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many duplicate data items associated with the given key that
|
|
can fit in a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many duplicate data items associated
|
|
with the given key that can fit in a buffer the size of one database
|
|
page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The cursor is positioned to a
|
|
key/data pair if both the key and data match the values provided on
|
|
the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many duplicate data items associated
|
|
with the given key that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The
|
|
cursor is positioned to a key/data pair if both the key and data
|
|
match the values provided on the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many duplicate data items associated
|
|
with the given key that can fit in a buffer the size of one database
|
|
page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The cursor is positioned to a
|
|
key/data pair if both the key and data match the values provided on
|
|
the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultiple(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many duplicate data items associated
|
|
with the given key that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. The
|
|
cursor is positioned to a key/data pair if both the key and data
|
|
match the values provided on the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many ensuing key/data pairs that can fit in a buffer the
|
|
size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many ensuing key/data pairs that can fit in a buffer the
|
|
size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many ensuing key/data pairs that can fit in a buffer the
|
|
size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(BerkeleyDB.DatabaseEntry,System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store that
|
|
key and as many ensuing key/data pairs that can fit in a buffer the
|
|
size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
|
|
key/data pair if both the key and data match the values provided on
|
|
the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
|
|
key/data pair if both the key and data match the values provided on
|
|
the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
|
|
key/data pair if both the key and data match the values provided on
|
|
the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveMultipleKey(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},System.Boolean,System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database, and
|
|
store that key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. The cursor is positioned to a
|
|
key/data pair if both the key and data match the values provided on
|
|
the key and data parameters.
|
|
</summary>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNext">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNext is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveFirst"/>. Otherwise, move the cursor to the next
|
|
key/data pair of the database, and store that pair in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
|
|
value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNext(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNext is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveFirst(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
|
|
the next key/data pair of the database, and store that pair in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
|
|
value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultiple">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultiple is identical
|
|
to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple"/>. Otherwise, move the cursor to
|
|
the next key/data pair of the database, and store that pair and as
|
|
many duplicate data items that can fit in a buffer the size of one
|
|
database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In the presence of
|
|
duplicate key values, the value of
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
|
|
change.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultiple(System.Int32)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultiple is identical
|
|
to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32)"/>. Otherwise, move the cursor
|
|
to the next key/data pair of the database, and store that pair and
|
|
as many duplicate data items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In
|
|
the presence of duplicate key values, the value of
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
|
|
change.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultiple(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultiple is identical
|
|
to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(BerkeleyDB.LockingInfo)"/>. Otherwise, move the
|
|
cursor to the next key/data pair of the database, and store that
|
|
pair and as many duplicate data items that can fit in a buffer the
|
|
size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In the
|
|
presence of duplicate key values, the value of
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
|
|
change.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultiple(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultiple is identical
|
|
to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32,BerkeleyDB.LockingInfo)"/>. Otherwise,
|
|
move the cursor to the next key/data pair of the database, and store
|
|
that pair and as many duplicate data items that can fit in a buffer
|
|
the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. In the presence of duplicate key
|
|
values, the value of
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple">CurrentMultiple.Key</see> may not
|
|
change.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey"/>. Otherwise, move
|
|
the cursor to the next key/data pair of the database, and store that
|
|
pair and as many ensuing key/data pairs that can fit in a buffer the
|
|
size of one database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In
|
|
the presence of duplicate key values, the keys of
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not change.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey(System.Int32)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32)"/>. Otherwise,
|
|
move the cursor to the next key/data pair of the database, and store
|
|
that pair and as many ensuing key/data pairs that can fit in a
|
|
buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In the presence of duplicate key
|
|
values, the keys of <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not change.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(BerkeleyDB.LockingInfo)"/>.
|
|
Otherwise, move the cursor to the next key/data pair of the
|
|
database, and store that pair and as many ensuing key/data pairs
|
|
that can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In the presence of duplicate key
|
|
values, the keys of <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not change.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32,BerkeleyDB.LockingInfo)"/>.
|
|
Otherwise, move the cursor to the next key/data pair of the
|
|
database, and store that pair and as many ensuing key/data pairs
|
|
that can fit in a buffer the size of <paramref name="BufferSize"/>
|
|
in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. In the presence of duplicate
|
|
key values, the keys of <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> may not
|
|
change.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicate">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
MoveNextDuplicate will return false if the next key/data pair of the
|
|
database is not a duplicate data record for the current key/data
|
|
pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicate(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
MoveNextDuplicate will return false if the next key/data pair of the
|
|
database is not a duplicate data record for the current key/data
|
|
pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextDuplicateMultiple will return
|
|
false if the next key/data pair of the database is not a duplicate
|
|
data record for the current key/data pair.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple(System.Int32)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, then move cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
MoveNextDuplicateMultiple will return false if the next key/data
|
|
pair of the database is not a duplicate data record for the current
|
|
key/data pair.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextDuplicateMultiple will return
|
|
false if the next key/data pair of the database is not a duplicate
|
|
data record for the current key/data pair.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultiple(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
MoveNextDuplicateMultiple will return false if the next key/data
|
|
pair of the database is not a duplicate data record for the current
|
|
key/data pair.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. MoveNextDuplicateMultipleKey will
|
|
return false if the next key/data pair of the database is not a
|
|
duplicate data record for the current key/data pair.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey(System.Int32)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
MoveNextDuplicateMultipleKey will return false if the next key/data
|
|
pair of the database is not a duplicate data record for the current
|
|
key/data pair.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. MoveNextDuplicateMultipleKey will
|
|
return false if the next key/data pair of the database is not a
|
|
duplicate data record for the current key/data pair.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextDuplicateMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store that pair and as many duplicate data
|
|
items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
MoveNextDuplicateMultipleKey will return false if the next key/data
|
|
pair of the database is not a duplicate data record for the current
|
|
key/data pair.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUnique">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUnique is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveFirst"/>. Otherwise, move the cursor to the next
|
|
non-duplicate key in the database, and store that key and associated
|
|
datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MoveNextUnique will return false if
|
|
no non-duplicate key/data pairs exist after the cursor position in
|
|
the database.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUnique(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUnique is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveFirst(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
|
|
the next non-duplicate key in the database, and store that key and
|
|
associated datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MoveNextUnique will
|
|
return false if no non-duplicate key/data pairs exist after the
|
|
cursor position in the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If the database is a Queue or Recno database, MoveNextUnique will
|
|
ignore any keys that exist but were never explicitly created by the
|
|
application, or those that were created and later deleted.
|
|
</para>
|
|
<para>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</para>
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultiple is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple"/>. Otherwise, move the
|
|
cursor to the next non-duplicate key in the database, and store that
|
|
key and associated datum and as many duplicate data items that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextUniqueMultiple will return
|
|
false if no non-duplicate key/data pairs exist after the cursor
|
|
position in the database.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple(System.Int32)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultiple is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32)"/>. Otherwise, move
|
|
the cursor to the next non-duplicate key in the database, and store
|
|
that key and associated datum and as many duplicate data items that
|
|
can fit in a buffer the size of <paramref name="BufferSize"/> in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>. MoveNextUniqueMultiple will return
|
|
false if no non-duplicate key/data pairs exist after the cursor
|
|
position in the database.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultiple is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(BerkeleyDB.LockingInfo)"/>.
|
|
Otherwise, move the cursor to the next non-duplicate key in the
|
|
database, and store that key and associated datum and as many
|
|
duplicate data items that can fit in a buffer the size of one
|
|
database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
MoveNextUniqueMultiple will return false if no non-duplicate
|
|
key/data pairs exist after the cursor position in the database.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultiple(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultiple is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultiple(System.Int32,BerkeleyDB.LockingInfo)"/>.
|
|
Otherwise, move the cursor to the next non-duplicate key in the
|
|
database, and store that key and associated datum and as many
|
|
duplicate data items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
MoveNextUniqueMultiple will return false if no non-duplicate
|
|
key/data pairs exist after the cursor position in the database.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey"/>. Otherwise, move
|
|
the cursor to the next non-duplicate key in the database, and store
|
|
that key and associated datum and as many ensuing key/data pairs
|
|
that can fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>. MoveNextUniqueMultipleKey will
|
|
return false if no non-duplicate key/data pairs exist after the
|
|
cursor position in the database.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey(System.Int32)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32)"/>. Otherwise,
|
|
move the cursor to the next non-duplicate key in the database, and
|
|
store that key and associated datum and as many ensuing key/data
|
|
pairs that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
MoveNextUniqueMultipleKey will return false if no non-duplicate
|
|
key/data pairs exist after the cursor position in the database.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(BerkeleyDB.LockingInfo)"/>.
|
|
Otherwise, move the cursor to the next non-duplicate key in the
|
|
database, and store that key and associated datum and as many
|
|
ensuing key/data pairs that can fit in a buffer the size of one
|
|
database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
MoveNextUniqueMultipleKey will return false if no non-duplicate
|
|
key/data pairs exist after the cursor position in the database.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MoveNextUniqueMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUniqueMultipleKey is
|
|
identical to <see cref="M:BerkeleyDB.Cursor.MoveFirstMultipleKey(System.Int32,BerkeleyDB.LockingInfo)"/>.
|
|
Otherwise, move the cursor to the next non-duplicate key in the
|
|
database, and store that key and associated datum and as many
|
|
ensuing key/data pairs that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
MoveNextUniqueMultipleKey will return false if no non-duplicate
|
|
key/data pairs exist after the cursor position in the database.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MovePrev">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrev is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveLast"/>. Otherwise, move the cursor to the previous
|
|
key/data pair of the database, and store that pair in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
|
|
value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MovePrev(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrev is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
|
|
the previous key/data pair of the database, and store that pair in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>. In the presence of duplicate key values, the
|
|
value of <see cref="P:BerkeleyDB.Cursor.Current">Current.Key</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MovePrevDuplicate">
|
|
<summary>
|
|
If the previous key/data pair of the database is a duplicate data
|
|
record for the current key/data pair, the cursor is moved to the
|
|
previous key/data pair of the database, and that pair is stored in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevDuplicate will return false if the
|
|
previous key/data pair of the database is not a duplicate data
|
|
record for the current key/data pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MovePrevDuplicate(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the previous key/data pair of the database is a duplicate data
|
|
record for the current key/data pair, the cursor is moved to the
|
|
previous key/data pair of the database, and that pair is stored in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevDuplicate will return false if the
|
|
previous key/data pair of the database is not a duplicate data
|
|
record for the current key/data pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MovePrevUnique">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrevUnique is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveLast"/>. Otherwise, move the cursor to the previous
|
|
non-duplicate key in the database, and store that key and associated
|
|
datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevUnique will return false if
|
|
no non-duplicate key/data pairs exist after the cursor position in
|
|
the database.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.MovePrevUnique(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrevUnique is identical to
|
|
<see cref="M:BerkeleyDB.Cursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
|
|
the previous non-duplicate key in the database, and store that key
|
|
and associated datum in <see cref="P:BerkeleyDB.Cursor.Current"/>. MovePrevUnique will
|
|
return false if no non-duplicate key/data pairs exist after the
|
|
cursor position in the database.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Overwrite(BerkeleyDB.DatabaseEntry)">
|
|
<summary>
|
|
Overwrite the data of the key/data pair to which the cursor refers
|
|
with the specified data item.
|
|
</summary>
|
|
<param name="data"></param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Refresh">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.Refresh(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers in
|
|
<see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.Cursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultiple">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
duplicate data items that can fit in a buffer the size of one
|
|
database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultiple(System.Int32)">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
duplicate data items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultiple(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
duplicate data items that can fit in a buffer the size of one
|
|
database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultiple(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
duplicate data items that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultipleKey">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
ensuing key/data pairs that can fit in a buffer the size of one
|
|
database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultipleKey(System.Int32)">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
ensuing key/data pairs that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultipleKey(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
ensuing key/data pairs that can fit in a buffer the size of one
|
|
database page in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Cursor.RefreshMultipleKey(System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Store the key/data pair to which the cursor refers and as many
|
|
ensuing key/data pairs that can fit in a buffer the size of
|
|
<paramref name="BufferSize"/> in <see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Cursor.Current">
|
|
<summary>
|
|
The key/data pair at which the cursor currently points.
|
|
</summary>
|
|
<remarks>
|
|
Only one of <see cref="P:BerkeleyDB.Cursor.Current"/>, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> and
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> will ever be non-empty.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Cursor.CurrentMultiple">
|
|
<summary>
|
|
The key and multiple data items at which the cursor currently
|
|
points.
|
|
</summary>
|
|
<remarks>
|
|
Only one of <see cref="P:BerkeleyDB.Cursor.Current"/>, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> and
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> will ever be non-empty.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Cursor.CurrentMultipleKey">
|
|
<summary>
|
|
The multiple key and data items at which the cursor currently
|
|
points.
|
|
</summary>
|
|
<remarks>
|
|
Only one of <see cref="P:BerkeleyDB.Cursor.Current"/>, <see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/> and
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/> will ever be non-empty.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Cursor.Priority">
|
|
<summary>
|
|
The cache priority for pages referenced by the cursor.
|
|
</summary>
|
|
<remarks>
|
|
The priority of a page biases the replacement algorithm to be more
|
|
or less likely to discard a page when space is needed in the buffer
|
|
pool. The bias is temporary, and pages will eventually be discarded
|
|
if they are not referenced again. The setting is only advisory, and
|
|
does not guarantee pages will be treated in a specific way.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.Cursor.InsertLocation">
|
|
<summary>
|
|
Specifies where to place duplicate data elements of the key to which
|
|
the cursor refers.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Cursor.InsertLocation.AFTER">
|
|
<summary>
|
|
The new element appears immediately after the current cursor
|
|
position.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Cursor.InsertLocation.BEFORE">
|
|
<summary>
|
|
The new element appears immediately before the current cursor
|
|
position.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Cursor.InsertLocation.FIRST">
|
|
<summary>
|
|
The new element appears as the first of the data items for the
|
|
given key
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Cursor.InsertLocation.LAST">
|
|
<summary>
|
|
The new element appears as the last of the data items for the
|
|
given key
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.HashCursor.Duplicate(System.Boolean)">
|
|
<summary>
|
|
Create a new cursor that uses the same transaction and locker ID as
|
|
the original cursor.
|
|
</summary>
|
|
<remarks>
|
|
This is useful when an application is using locking and requires two
|
|
or more cursors in the same thread of control.
|
|
</remarks>
|
|
<param name="keepPosition">
|
|
If true, the newly created cursor is initialized to refer to the
|
|
same position in the database as the original cursor (if any) and
|
|
hold the same locks (if any). If false, or the original cursor does
|
|
not hold a database position and locks, the created cursor is
|
|
uninitialized and will behave like a cursor newly created by
|
|
<see cref="M:BerkeleyDB.HashDatabase.Cursor"/>.</param>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.HashCursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
|
|
<summary>
|
|
Insert the data element as a duplicate element of the key to which
|
|
the cursor refers.
|
|
</summary>
|
|
<param name="data">The data element to insert</param>
|
|
<param name="loc">
|
|
Specify whether to insert the data item immediately before or
|
|
immediately after the cursor's current position.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.HashCursor.AddUnique(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
|
|
<summary>
|
|
Insert the specified key/data pair into the database, unless a
|
|
key/data pair comparing equally to it already exists in the
|
|
database.
|
|
</summary>
|
|
<param name="pair">The key/data pair to be inserted</param>
|
|
<exception cref="T:BerkeleyDB.KeyExistException">
|
|
Thrown if a matching key/data pair already exists in the database.
|
|
</exception>
|
|
</member>
|
|
<member name="M:BerkeleyDB.HashCursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},BerkeleyDB.Cursor.InsertLocation)">
|
|
<summary>
|
|
Insert the specified key/data pair into the database.
|
|
</summary>
|
|
<param name="pair">The key/data pair to be inserted</param>
|
|
<param name="loc">
|
|
If the key already exists in the database and no duplicate sort
|
|
function has been specified, specify whether the inserted data item
|
|
is added as the first or the last of the data items for that key.
|
|
</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.Transaction">
|
|
<summary>
|
|
A class representing Berkeley DB transactions
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Calling <see cref="M:BerkeleyDB.Transaction.Abort"/>,
|
|
<see cref="M:BerkeleyDB.Transaction.Commit"/> or
|
|
<see cref="M:BerkeleyDB.Transaction.Discard"/> will release the resources held by
|
|
the created object.
|
|
</para>
|
|
<para>
|
|
Transactions may only span threads if they do so serially; that is,
|
|
each transaction must be active in only a single thread of control
|
|
at a time. This restriction holds for parents of nested transactions
|
|
as well; no two children may be concurrently active in more than one
|
|
thread of control at any one time.
|
|
</para>
|
|
<para>
|
|
Cursors may not span transactions; that is, each cursor must be
|
|
opened and closed within a single transaction.
|
|
</para>
|
|
<para>
|
|
A parent transaction may not issue any Berkeley DB operations —
|
|
except for <see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>,
|
|
<see cref="M:BerkeleyDB.Transaction.Abort"/>and <see cref="M:BerkeleyDB.Transaction.Commit"/>
|
|
— while it has active child transactions (child transactions that
|
|
have not yet been committed or aborted).
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Transaction.GlobalIdLength">
|
|
<summary>
|
|
The size of the global transaction ID
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Transaction.Abort">
|
|
<summary>
|
|
Cause an abnormal termination of the transaction.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Before Abort returns, any locks held by the transaction will have
|
|
been released.
|
|
</para>
|
|
<para>
|
|
In the case of nested transactions, aborting a parent transaction
|
|
causes all children (unresolved or not) of the parent transaction to
|
|
be aborted.
|
|
</para>
|
|
<para>
|
|
All cursors opened within the transaction must be closed before the
|
|
transaction is aborted.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Transaction.Commit">
|
|
<summary>
|
|
End the transaction.
|
|
</summary>
|
|
<overloads>
|
|
<para>
|
|
In the case of nested transactions, if the transaction is a parent
|
|
transaction, committing the parent transaction causes all unresolved
|
|
children of the parent to be committed. In the case of nested
|
|
transactions, if the transaction is a child transaction, its locks
|
|
are not released, but are acquired by its parent. Although the
|
|
commit of the child transaction will succeed, the actual resolution
|
|
of the child transaction is postponed until the parent transaction
|
|
is committed or aborted; that is, if its parent transaction commits,
|
|
it will be committed; and if its parent transaction aborts, it will
|
|
be aborted.
|
|
</para>
|
|
<para>
|
|
All cursors opened within the transaction must be closed before the
|
|
transaction is committed.
|
|
</para>
|
|
</overloads>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Transaction.Commit(System.Boolean)">
|
|
<summary>
|
|
End the transaction.
|
|
</summary>
|
|
<remarks>
|
|
Synchronously flushing the log is the default for Berkeley DB
|
|
environments unless
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoSync"/> was specified.
|
|
Synchronous log flushing may also be set or unset for a single
|
|
transaction using
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>. The
|
|
value of <paramref name="syncLog"/> overrides both of those
|
|
settings.
|
|
</remarks>
|
|
<param name="syncLog">If true, synchronously flush the log.</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Transaction.Discard">
|
|
<summary>
|
|
Free up all the per-process resources associated with the specified
|
|
Transaction instance, neither committing nor aborting the
|
|
transaction.
|
|
</summary>
|
|
<remarks>
|
|
This call may be used only after calls to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/> when there are multiple
|
|
global transaction managers recovering transactions in a single
|
|
Berkeley DB environment. Any transactions returned by
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/> that are not handled by
|
|
the current global transaction manager should be discarded using
|
|
Discard.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Transaction.Prepare(System.Byte[])">
|
|
<summary>
|
|
Initiate the beginning of a two-phase commit.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
In a distributed transaction environment, Berkeley DB can be used as
|
|
a local transaction manager. In this case, the distributed
|
|
transaction manager must send prepare messages to each local
|
|
manager. The local manager must then call Prepare and await its
|
|
successful return before responding to the distributed transaction
|
|
manager. Only after the distributed transaction manager receives
|
|
successful responses from all of its prepare messages should it
|
|
issue any commit messages.
|
|
</para>
|
|
<para>
|
|
In the case of nested transactions, preparing the parent causes all
|
|
unresolved children of the parent transaction to be committed. Child
|
|
transactions should never be explicitly prepared. Their fate will be
|
|
resolved along with their parent's during global recovery.
|
|
</para>
|
|
</remarks>
|
|
<param name="globalId">
|
|
The global transaction ID by which this transaction will be known.
|
|
This global transaction ID will be returned in calls to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/> telling the
|
|
application which global transactions must be resolved.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Transaction.SetLockTimeout(System.UInt32)">
|
|
<summary>
|
|
Set the timeout value for locks for this transaction.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Timeouts are checked whenever a thread of control blocks on a lock
|
|
or when deadlock detection is performed. This timeout is for any
|
|
single lock request. As timeouts are only checked when the lock
|
|
request first blocks or when deadlock detection is performed, the
|
|
accuracy of the timeout depends on how often deadlock detection is
|
|
performed.
|
|
</para>
|
|
<para>
|
|
Timeout values may be specified for the database environment as a
|
|
whole. See <see cref="P:BerkeleyDB.DatabaseEnvironment.LockTimeout"/> for more
|
|
information.
|
|
</para>
|
|
</remarks>
|
|
<param name="timeout">
|
|
An unsigned 32-bit number of microseconds, limiting the maximum
|
|
timeout to roughly 71 minutes. A value of 0 disables timeouts for
|
|
the transaction.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Transaction.SetTxnTimeout(System.UInt32)">
|
|
<summary>
|
|
Set the timeout value for transactions for this transaction.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Timeouts are checked whenever a thread of control blocks on a lock
|
|
or when deadlock detection is performed. This timeout is for the
|
|
life of the transaction. As timeouts are only checked when the lock
|
|
request first blocks or when deadlock detection is performed, the
|
|
accuracy of the timeout depends on how often deadlock detection is
|
|
performed.
|
|
</para>
|
|
<para>
|
|
Timeout values may be specified for the database environment as a
|
|
whole. See <see cref="P:BerkeleyDB.DatabaseEnvironment.TxnTimeout"/> for more
|
|
information.
|
|
</para>
|
|
</remarks>
|
|
<param name="timeout">
|
|
An unsigned 32-bit number of microseconds, limiting the maximum
|
|
timeout to roughly 71 minutes. A value of 0 disables timeouts for
|
|
the transaction.
|
|
</param>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Transaction.Id">
|
|
<summary>
|
|
The unique transaction id associated with this transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Transaction.Name">
|
|
<summary>
|
|
The transaction's name. The name is returned by
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats"/>
|
|
and displayed by
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats"/>.
|
|
</summary>
|
|
<remarks>
|
|
If the database environment has been configured for logging and the
|
|
Berkeley DB library was built in Debug mode (or with DIAGNOSTIC
|
|
defined), a debugging log record is written including the
|
|
transaction ID and the name.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.QueueDatabase">
|
|
<summary>
|
|
A class representing a QueueDatabase. The Queue format supports fast
|
|
access to fixed-length records accessed sequentially or by logical
|
|
record number.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new QueueDatabase 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.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new QueueDatabase 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.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)">
|
|
<summary>
|
|
Append the data item to the end of the database.
|
|
</summary>
|
|
<param name="data">The data item to store in the database</param>
|
|
<returns>The record number allocated to the record</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Append the data item to the end of the database.
|
|
</summary>
|
|
<remarks>
|
|
There is a minor behavioral difference between
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> and
|
|
<see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>. If a transaction enclosing an
|
|
Append operation aborts, the record number may be reallocated in a
|
|
subsequent <see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation, but it will
|
|
not be reallocated in a subsequent
|
|
<see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation.
|
|
</remarks>
|
|
<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>
|
|
<returns>The record number allocated to the record</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)">
|
|
<summary>
|
|
Return the record number and data from the available record closest
|
|
to the head of the queue, and delete the record.
|
|
</summary>
|
|
<param name="wait">
|
|
If true and the Queue database is empty, the thread of control will
|
|
wait until there is data in the queue before returning.
|
|
</param>
|
|
<exception cref="T:BerkeleyDB.LockNotGrantedException">
|
|
If lock or transaction timeouts have been specified, a
|
|
<see cref="T:BerkeleyDB.LockNotGrantedException"/> may be thrown. This failure,
|
|
by itself, does not require the enclosing transaction be aborted.
|
|
</exception>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
|
|
parameter is the record number and whose Value parameter is the
|
|
retrieved data.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Return the record number and data from the available record closest
|
|
to the head of the queue, and delete the record.
|
|
</summary>
|
|
<param name="wait">
|
|
If true and the Queue database is empty, the thread of control will
|
|
wait until there is data in the queue before returning.
|
|
</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.LockNotGrantedException">
|
|
If lock or transaction timeouts have been specified, a
|
|
<see cref="T:BerkeleyDB.LockNotGrantedException"/> may be thrown. This failure,
|
|
by itself, does not require the enclosing transaction be aborted.
|
|
</exception>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
|
|
parameter is the record number and whose Value parameter is the
|
|
retrieved data.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Return the record number and data from the available record closest
|
|
to the head of the queue, and delete the record.
|
|
</summary>
|
|
<param name="wait">
|
|
If true and the Queue database is empty, the thread of control will
|
|
wait until there is data in the queue before returning.
|
|
</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.LockNotGrantedException">
|
|
If lock or transaction timeouts have been specified, a
|
|
<see cref="T:BerkeleyDB.LockNotGrantedException"/> may be thrown. This failure,
|
|
by itself, does not require the enclosing transaction be aborted.
|
|
</exception>
|
|
<returns>
|
|
A <see cref="T:System.Collections.Generic.KeyValuePair`2"/> whose Key
|
|
parameter is the record number and whose Value parameter is the
|
|
retrieved data.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabase.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.QueueDatabase.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.QueueDatabase.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.QueueDatabase.Stats">
|
|
<summary>
|
|
Return the database statistical information for this database.
|
|
</summary>
|
|
<returns>Database statistical information.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.QueueDatabase.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.QueueDatabase.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.QueueDatabase.ExtentSize">
|
|
<summary>
|
|
The size of the extents used to hold pages in a
|
|
<see cref="T:BerkeleyDB.QueueDatabase"/>, specified as a number of pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueDatabase.InOrder">
|
|
<summary>
|
|
If true, modify the operation of <see cref="M:BerkeleyDB.QueueDatabase.Consume(System.Boolean)"/>
|
|
to return key/data pairs in order. That is, they will always return
|
|
the key/data item from the head of the queue.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueDatabase.Length">
|
|
<summary>
|
|
The length of records in the database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueDatabase.PadByte">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.PreparedTransaction">
|
|
<summary>
|
|
A class representing a transaction that must be resolved by the
|
|
application following <see cref="M:BerkeleyDB.DatabaseEnvironment.Recover(System.UInt32,System.Boolean)"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.PreparedTransaction.Txn">
|
|
<summary>
|
|
The transaction which must be committed, aborted or discarded.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.PreparedTransaction.GlobalID">
|
|
<summary>
|
|
The global transaction ID for the transaction. The global
|
|
transaction ID is the one specified when the transaction was
|
|
prepared. The application is responsible for ensuring uniqueness
|
|
among global transaction IDs.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.MPoolFileStats">
|
|
<summary>
|
|
Statistical information about a file in the memory pool
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.FileName">
|
|
<summary>
|
|
File name.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.MappedPages">
|
|
<summary>
|
|
Pages from mapped files.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.PagesCreatedInCache">
|
|
<summary>
|
|
Pages created in the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.PagesInCache">
|
|
<summary>
|
|
Pages found in the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.PagesNotInCache">
|
|
<summary>
|
|
Pages not found in the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.PagesRead">
|
|
<summary>
|
|
Pages read in.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.PageSize">
|
|
<summary>
|
|
Page size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolFileStats.PagesWritten">
|
|
<summary>
|
|
Pages written out.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.LockingConfig">
|
|
<summary>
|
|
A class representing configuration parameters for a
|
|
<see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s locking subsystem.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LockingConfig.DeadlockResolution">
|
|
<summary>
|
|
If non-null, the deadlock detector is to be run whenever a lock
|
|
conflict occurs, lock request(s) should be rejected according to the
|
|
specified policy.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
As transactions acquire locks on behalf of a single locker ID,
|
|
rejecting a lock request associated with a transaction normally
|
|
requires the transaction be aborted.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockingConfig.Conflicts">
|
|
<summary>
|
|
The locking conflicts matrix.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If Conflicts is never set, a standard conflicts array is used; see
|
|
Standard Lock Modes in the Programmer's Reference Guide for more
|
|
information.
|
|
</para>
|
|
<para>
|
|
Conflicts parameter is an nmodes by nmodes array. A non-0 value for
|
|
the array element indicates that requested_mode and held_mode
|
|
conflict:
|
|
<code>
|
|
conflicts[requested_mode][held_mode]
|
|
</code>
|
|
</para>
|
|
<para>The not-granted mode must be represented by 0.</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
Conflicts will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockingConfig.MaxLockers">
|
|
<summary>
|
|
The maximum number of simultaneous locking entities supported by the
|
|
Berkeley DB environment
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This value is used by <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> to
|
|
estimate how much space to allocate for various lock-table data
|
|
structures. The default value is 1000 lockers. For specific
|
|
information on configuring the size of the lock subsystem, see
|
|
Configuring locking: sizing the system in the Programmer's Reference
|
|
Guide.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
MaxLockers will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockingConfig.MaxLocks">
|
|
<summary>
|
|
The maximum number of locks supported by the Berkeley DB
|
|
environment.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This value is used by <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> to
|
|
estimate how much space to allocate for various lock-table data
|
|
structures. The default value is 1000 lockers. For specific
|
|
information on configuring the size of the lock subsystem, see
|
|
Configuring locking: sizing the system in the Programmer's Reference
|
|
Guide.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
MaxLocks will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockingConfig.MaxObjects">
|
|
<summary>
|
|
The maximum number of locked objects supported by the Berkeley DB
|
|
environment.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This value is used by <see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> to
|
|
estimate how much space to allocate for various lock-table data
|
|
structures. The default value is 1000 lockers. For specific
|
|
information on configuring the size of the lock subsystem, see
|
|
Configuring locking: sizing the system in the Programmer's Reference
|
|
Guide.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
MaxObjects will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockingConfig.Partitions">
|
|
<summary>
|
|
The number of lock table partitions in the Berkeley DB environment.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The default value is 10 times the number of CPUs on the system if
|
|
there is more than one CPU. Increasing the number of partitions can
|
|
provide for greater throughput on a system with multiple CPUs and
|
|
more than one thread contending for the lock manager. On single
|
|
processor systems more than one partition may increase the overhead
|
|
of the lock manager. Systems often report threading contexts as
|
|
CPUs. If your system does this, set the number of partitions to 1 to
|
|
get optimal performance.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
Partitions will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BTreeDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.BTreeDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BTreeDatabaseConfig.Duplicates">
|
|
<summary>
|
|
Policy for duplicate data items in the database; that is, insertion
|
|
when the key of the key/data pair being inserted already exists in
|
|
the database will be successful.
|
|
</summary>
|
|
<remarks>
|
|
<para>The ordering of duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
|
|
of insertion, unless the ordering is otherwise specified by use of a
|
|
cursor operation or a duplicate sort function. The ordering of
|
|
duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
|
|
duplicate comparison function. If the application does not specify a
|
|
comparison function using
|
|
<see cref="F:BerkeleyDB.BTreeDatabaseConfig.DuplicateCompare"/>, a default lexical
|
|
comparison will be used.
|
|
</para>
|
|
<para>
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
|
|
applications wanting to order duplicate data items manually.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the value of Duplicates must be the
|
|
same as the existing database or an error will be returned.
|
|
</para>
|
|
<para>
|
|
It is an error to specify <see cref="F:BerkeleyDB.BTreeDatabaseConfig.UseRecordNumbers"/> and
|
|
anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BTreeDatabaseConfig.NoReverseSplitting">
|
|
<summary>
|
|
Turn reverse splitting in the Btree on or off.
|
|
</summary>
|
|
<remarks>
|
|
As pages are emptied in a database, the Berkeley DB Btree
|
|
implementation attempts to coalesce empty pages into higher-level
|
|
pages in order to keep the database as small as possible and
|
|
minimize search time. This can hurt performance in applications with
|
|
cyclical data demands; that is, applications where the database
|
|
grows and shrinks repeatedly. For example, because Berkeley DB does
|
|
page-level locking, the maximum level of concurrency in a database
|
|
of two pages is far smaller than that in a database of 100 pages, so
|
|
a database that has shrunk to a minimal size can cause severe
|
|
deadlocking when a new cycle of data insertion begins.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BTreeDatabaseConfig.UseRecordNumbers">
|
|
<summary>
|
|
If true, support retrieval from the Btree using record numbers.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Logical record numbers in Btree databases are mutable in the face of
|
|
record insertion or deletion. See
|
|
<see cref="F:BerkeleyDB.RecnoDatabaseConfig.Renumber"/> for further discussion.
|
|
</para>
|
|
<para>
|
|
Maintaining record counts within a Btree introduces a serious point
|
|
of contention, namely the page locations where the record counts are
|
|
stored. In addition, the entire database must be locked during both
|
|
insertions and deletions, effectively single-threading the database
|
|
for those operations. Specifying UseRecordNumbers can result in
|
|
serious performance degradation for some applications and data sets.
|
|
</para>
|
|
<para>
|
|
It is an error to specify <see cref="F:BerkeleyDB.BTreeDatabaseConfig.UseRecordNumbers"/> and
|
|
anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the value of UseRecordNumbers must
|
|
be the same as the existing database or an error will be returned.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BTreeDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BTreeDatabaseConfig.BTreeCompare">
|
|
<summary>
|
|
The Btree key comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the keys are compared
|
|
lexically, with shorter keys collating before longer keys.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the comparison function must be the
|
|
same as that historically used to create the database or corruption
|
|
can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BTreeDatabaseConfig.BTreePrefixCompare">
|
|
<summary>
|
|
The Btree prefix function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The prefix function is used to determine the amount by which keys
|
|
stored on the Btree internal pages can be safely truncated without
|
|
losing their uniqueness. See the Btree prefix comparison section of
|
|
the Berkeley DB Reference Guide for more details about how this
|
|
works. The usefulness of this is data-dependent, but can produce
|
|
significantly reduced tree sizes and search times in some data sets.
|
|
</para>
|
|
<para>
|
|
If no prefix function or key comparison function is specified by the
|
|
application, a default lexical comparison function is used as the
|
|
prefix function. If no prefix function is specified and
|
|
<see cref="F:BerkeleyDB.BTreeDatabaseConfig.BTreeCompare"/> is specified, no prefix function is
|
|
used. It is an error to specify a prefix function without also
|
|
specifying <see cref="F:BerkeleyDB.BTreeDatabaseConfig.BTreeCompare"/>.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the prefix function must be the
|
|
same as that historically used to create the database or corruption
|
|
can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.BTreeDatabaseConfig.DuplicateCompare">
|
|
<summary>
|
|
The duplicate data item comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The comparison function is called whenever it is necessary to
|
|
compare a data item specified by the application with a data item
|
|
currently stored in the database. Setting DuplicateCompare implies
|
|
setting <see cref="F:BerkeleyDB.BTreeDatabaseConfig.Duplicates"/> to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the data items are compared
|
|
lexically, with shorter data items collating before longer data
|
|
items.
|
|
</para>
|
|
<para>
|
|
If the database already exists when
|
|
<see cref="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)"/> is called, the
|
|
delegate must be the same as that historically used to create the
|
|
database or corruption can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabaseConfig.SetCompression">
|
|
<summary>
|
|
Enable compression of the key/data pairs stored in the database,
|
|
using the default compression and decompression functions.
|
|
</summary>
|
|
<remarks>
|
|
The default functions perform prefix compression on keys, and prefix
|
|
compression on data items for duplicate keys.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabaseConfig.SetCompression(BerkeleyDB.BTreeCompressDelegate,BerkeleyDB.BTreeDecompressDelegate)">
|
|
<summary>
|
|
Enable compression of the key/data pairs stored in the database,
|
|
using the specified compression and decompression functions.
|
|
</summary>
|
|
<param name="compression">The compression function</param>
|
|
<param name="decompression">The decompression function</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabaseConfig.#ctor">
|
|
<summary>
|
|
Create a new BTreeDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabaseConfig.Compress">
|
|
<summary>
|
|
The compression function used to store key/data pairs in the
|
|
database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabaseConfig.Decompress">
|
|
<summary>
|
|
The decompression function used to retrieve key/data pairs from the
|
|
database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabaseConfig.MinKeysPerPage">
|
|
<summary>
|
|
The minimum number of key/data pairs intended to be stored on any
|
|
single Btree leaf page.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This value is used to determine if key or data items will be stored
|
|
on overflow pages instead of Btree leaf pages. For more information
|
|
on the specific algorithm used, see the Berkeley DB Reference Guide.
|
|
The value specified must be at least 2; if not explicitly set, a
|
|
value of 2 is used.
|
|
</para>
|
|
<para>
|
|
If the database already exists, MinKeysPerPage will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SequenceConfig">
|
|
<summary>
|
|
Configuration properties for a Sequence
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SequenceConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle sequence creation.
|
|
</summary>
|
|
<remarks>
|
|
If the sequence does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set, the Sequence constructor
|
|
will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SequenceConfig.FreeThreaded">
|
|
<summary>
|
|
If true, the object returned by the Sequence constructor will be
|
|
free-threaded; that is, usable by multiple threads within a single
|
|
address space. Note that if multiple threads create multiple
|
|
sequences using the same <see cref="F:BerkeleyDB.SequenceConfig.BackingDatabase"/>, that
|
|
database must have also been opened free-threaded.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SequenceConfig.BackingDatabase">
|
|
<summary>
|
|
An open database which holds the persistent data for the sequence.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The database may be of any type, but must not have been configured
|
|
to support duplicate data items.
|
|
</para>
|
|
<para>
|
|
If <paramref name="P:BackingDatabase"/> was opened in a transaction,
|
|
calling Get may result in changes to the sequence object; these
|
|
changes will be automatically committed in a transaction internal to
|
|
the Berkeley DB library. If the thread of control calling Get has an
|
|
active transaction, which holds locks on the same database as the
|
|
one in which the sequence object is stored, it is possible for a
|
|
thread of control calling Get to self-deadlock because the active
|
|
transaction's locks conflict with the internal transaction's locks.
|
|
For this reason, it is often preferable for sequence objects to be
|
|
stored in their own database.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SequenceConfig.key">
|
|
<summary>
|
|
The record in the database that stores the persistent sequence data.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SequenceConfig.Wrap">
|
|
<summary>
|
|
If true, the sequence should wrap around when it is incremented
|
|
(decremented) past the specified maximum (minimum) value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SequenceConfig.SetRange(System.Int64,System.Int64)">
|
|
<summary>
|
|
Set the minimum and maximum values in the sequence.
|
|
</summary>
|
|
<param name="Max">The maximum value in the sequence.</param>
|
|
<param name="Min">The minimum value in the sequence.</param>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceConfig.InitialValue">
|
|
<summary>
|
|
The initial value for a sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceConfig.Decrement">
|
|
<summary>
|
|
If true, the sequence will be decremented.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceConfig.Increment">
|
|
<summary>
|
|
If true, the sequence will be incremented. This is the default.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceConfig.CacheSize">
|
|
<summary>
|
|
The number of elements cached by a sequence handle.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceConfig.Min">
|
|
<summary>
|
|
The minimum value in the sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SequenceConfig.Max">
|
|
<summary>
|
|
The maximum value in the sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryHashDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.SecondaryHashDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.Duplicates">
|
|
<summary>
|
|
Policy for duplicate data items in the database; that is, insertion
|
|
when the key of the key/data pair being inserted already exists in
|
|
the database will be successful.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The ordering of duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
|
|
of insertion, unless the ordering is otherwise specified by use of a
|
|
cursor operation or a duplicate sort function. The ordering of
|
|
duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
|
|
duplicate comparison function. If the application does not specify a
|
|
comparison function using
|
|
<see cref="F:BerkeleyDB.SecondaryHashDatabaseConfig.DuplicateCompare"/>, a default lexical
|
|
comparison will be used.
|
|
</para>
|
|
<para>
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
|
|
applications wanting to order duplicate data items manually.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the value of Duplicates must be the
|
|
same as the existing database or an error will be returned.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.Compare">
|
|
<summary>
|
|
The Secondary Hash key comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the keys are compared
|
|
lexically, with shorter keys collating before longer keys.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the comparison function must be the
|
|
same as that historically used to create the database or corruption
|
|
can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.HashFunction">
|
|
<summary>
|
|
A user-defined hash function; if no hash function is specified, a
|
|
default hash function is used.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Because no hash function performs equally well on all possible data,
|
|
the user may find that the built-in hash function performs poorly
|
|
with a particular data set.
|
|
</para>
|
|
<para>
|
|
If the database already exists, HashFunction must be the same as
|
|
that historically used to create the database or corruption can
|
|
occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryHashDatabaseConfig.DuplicateCompare">
|
|
<summary>
|
|
The duplicate data item comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The comparison function is called whenever it is necessary to
|
|
compare a data item specified by the application with a data item
|
|
currently stored in the database. Setting DuplicateCompare implies
|
|
setting <see cref="F:BerkeleyDB.SecondaryHashDatabaseConfig.Duplicates"/> to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the data items are compared
|
|
lexically, with shorter data items collating before longer data
|
|
items.
|
|
</para>
|
|
<para>
|
|
If the database already exists when
|
|
<see cref="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig)"/> is called, the delegate
|
|
must be the same as that historically used to create the database or
|
|
corruption can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryHashDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
|
|
<summary>
|
|
Instantiate a new SecondaryHashDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryHashDatabaseConfig.FillFactor">
|
|
<summary>
|
|
The desired density within the hash table. If no value is specified,
|
|
the fill factor will be selected dynamically as pages are filled.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The density is an approximation of the number of keys allowed to
|
|
accumulate in any one bucket, determining when the hash table grows
|
|
or shrinks. If you know the average sizes of the keys and data in
|
|
your data set, setting the fill factor can enhance performance. A
|
|
reasonable rule computing fill factor is to set it to the following:
|
|
</para>
|
|
<para>
|
|
(pagesize - 32) / (average_key_size + average_data_size + 8)
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryHashDatabaseConfig.TableSize">
|
|
<summary>
|
|
An estimate of the final size of the hash table.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
In order for the estimate to be used when creating the database,
|
|
<see cref="P:BerkeleyDB.SecondaryHashDatabaseConfig.FillFactor"/> must also be set. If the estimate or fill
|
|
factor are not set or are set too low, hash tables will still expand
|
|
gracefully as keys are entered, although a slight performance
|
|
degradation may be noticed.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.MPoolStats">
|
|
<summary>
|
|
Statistical information about the memory pool subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.CacheSettings">
|
|
<summary>
|
|
Total cache size and number of regions
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxCacheRegions">
|
|
<summary>
|
|
Maximum number of regions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxMMapSize">
|
|
<summary>
|
|
Maximum file size for mmap.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxOpenFileDescriptors">
|
|
<summary>
|
|
Maximum number of open fd's.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxBufferWrites">
|
|
<summary>
|
|
Maximum buffers to write.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxBufferWritesSleep">
|
|
<summary>
|
|
Sleep after writing max buffers.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.Pages">
|
|
<summary>
|
|
Total number of pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MappedPages">
|
|
<summary>
|
|
Pages from mapped files.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PagesInCache">
|
|
<summary>
|
|
Pages found in the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PagesNotInCache">
|
|
<summary>
|
|
Pages not found in the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PagesCreatedInCache">
|
|
<summary>
|
|
Pages created in the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PagesRead">
|
|
<summary>
|
|
Pages read in.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PagesWritten">
|
|
<summary>
|
|
Pages written out.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.CleanPagesEvicted">
|
|
<summary>
|
|
Clean pages forced from the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.DirtyPagesEvicted">
|
|
<summary>
|
|
Dirty pages forced from the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PagesTrickled">
|
|
<summary>
|
|
Pages written by memp_trickle.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.CleanPages">
|
|
<summary>
|
|
Clean pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.DirtyPages">
|
|
<summary>
|
|
Dirty pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.HashBuckets">
|
|
<summary>
|
|
Number of hash buckets.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PageSize">
|
|
<summary>
|
|
Assumed page size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.HashChainSearches">
|
|
<summary>
|
|
Total hash chain searches.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.LongestHashChainSearch">
|
|
<summary>
|
|
Longest hash chain searched.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.HashEntriesSearched">
|
|
<summary>
|
|
Total hash entries searched.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.HashLockNoWait">
|
|
<summary>
|
|
Hash lock granted with nowait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.HashLockWait">
|
|
<summary>
|
|
Hash lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxHashLockNoWait">
|
|
<summary>
|
|
Max hash lock granted with nowait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxHashLockWait">
|
|
<summary>
|
|
Max hash lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.RegionLockNoWait">
|
|
<summary>
|
|
Region lock granted with nowait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.RegionLockWait">
|
|
<summary>
|
|
Region lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.FrozenBuffers">
|
|
<summary>
|
|
Buffers frozen.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.ThawedBuffers">
|
|
<summary>
|
|
Buffers thawed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.FrozenBuffersFreed">
|
|
<summary>
|
|
Frozen buffers freed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PageAllocations">
|
|
<summary>
|
|
Number of page allocations.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.BucketsCheckedDuringAlloc">
|
|
<summary>
|
|
Buckets checked during allocation.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxBucketsCheckedDuringAlloc">
|
|
<summary>
|
|
Max checked during allocation.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.PagesCheckedDuringAlloc">
|
|
<summary>
|
|
Pages checked during allocation.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.MaxPagesCheckedDuringAlloc">
|
|
<summary>
|
|
Max checked during allocation.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.BlockedOperations">
|
|
<summary>
|
|
Thread waited on buffer I/O.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.SyncInterrupted">
|
|
<summary>
|
|
Number of times sync interrupted.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.RegionSize">
|
|
<summary>
|
|
Region size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolStats.Files">
|
|
<summary>
|
|
Stats for files open in the memory pool
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BTreeStats">
|
|
<summary>
|
|
Statistical information about a BTreeDatabase
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.DuplicatePages">
|
|
<summary>
|
|
Duplicate pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.DuplicatePagesFreeBytes">
|
|
<summary>
|
|
Bytes free in duplicate pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.EmptyPages">
|
|
<summary>
|
|
Empty pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.FreePages">
|
|
<summary>
|
|
Pages on the free list.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.InternalPages">
|
|
<summary>
|
|
Internal pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.InternalPagesFreeBytes">
|
|
<summary>
|
|
Bytes free in internal pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.LeafPages">
|
|
<summary>
|
|
Leaf pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.LeafPagesFreeBytes">
|
|
<summary>
|
|
Bytes free in leaf pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.Levels">
|
|
<summary>
|
|
Tree levels.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.MagicNumber">
|
|
<summary>
|
|
Magic number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.MetadataFlags">
|
|
<summary>
|
|
Metadata flags.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.MinKey">
|
|
<summary>
|
|
Minkey value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.nBlobRecords">
|
|
<summary>
|
|
Number of blobs.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.nData">
|
|
<summary>
|
|
Number of data items.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.nKeys">
|
|
<summary>
|
|
Number of unique keys.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.nPages">
|
|
<summary>
|
|
Page count.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.OverflowPages">
|
|
<summary>
|
|
Overflow pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.OverflowPagesFreeBytes">
|
|
<summary>
|
|
Bytes free in overflow pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.PageSize">
|
|
<summary>
|
|
Page size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeStats.Version">
|
|
<summary>
|
|
Version number.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RecnoCursor">
|
|
<summary>
|
|
A class for traversing the records of a <see cref="T:BerkeleyDB.RecnoDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoCursor.Duplicate(System.Boolean)">
|
|
<summary>
|
|
Create a new cursor that uses the same transaction and locker ID as
|
|
the original cursor.
|
|
</summary>
|
|
<remarks>
|
|
This is useful when an application is using locking and requires two
|
|
or more cursors in the same thread of control.
|
|
</remarks>
|
|
<param name="keepPosition">
|
|
If true, the newly created cursor is initialized to refer to the
|
|
same position in the database as the original cursor (if any) and
|
|
hold the same locks (if any). If false, or the original cursor does
|
|
not hold a database position and locks, the created cursor is
|
|
uninitialized and will behave like a cursor newly created by
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Cursor"/>.</param>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoCursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
|
|
<summary>
|
|
Insert the data element as a duplicate element of the key to which
|
|
the cursor refers.
|
|
</summary>
|
|
<param name="data">The data element to insert</param>
|
|
<param name="loc">
|
|
Specify whether to insert the data item immediately before or
|
|
immediately after the cursor's current position.
|
|
</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryQueueDatabase">
|
|
<summary>
|
|
A class representing a SecondaryQueueDatabase. The Queue format supports
|
|
fast access to fixed-length records accessed sequentially or by logical
|
|
record number.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryQueueDatabase.Open(System.String,BerkeleyDB.SecondaryQueueDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryQueueDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryQueueDatabase.Open(System.String,BerkeleyDB.SecondaryQueueDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryQueueDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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="P:BerkeleyDB.SecondaryQueueDatabase.ExtentSize">
|
|
<summary>
|
|
The size of the extents used to hold pages in a
|
|
<see cref="T:BerkeleyDB.QueueDatabase"/>, specified as a number of pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryQueueDatabase.Length">
|
|
<summary>
|
|
The length of records in the database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryQueueDatabase.PadByte">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DatabaseEntry">
|
|
<summary>
|
|
A class representing a key or data item in a Berkeley DB database
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEntry.#ctor">
|
|
<summary>
|
|
Create a new, empty DatabaseEntry object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEntry.#ctor(System.Byte[])">
|
|
<summary>
|
|
Create a new DatabaseEntry object, with the specified data
|
|
</summary>
|
|
<param name="data">The new object's <see cref="P:BerkeleyDB.DatabaseEntry.Data"/></param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEntry.Dispose">
|
|
<summary>
|
|
Release the resources held by the underlying C library.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEntry.Data">
|
|
<summary>
|
|
The byte string stored in or retrieved from a database
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.AckPolicy">
|
|
<summary>
|
|
The AckPolicy class specifies how master and client sites will handle
|
|
acknowledgment of replication messages which are necessary for
|
|
"permanent" records. The current implementation requires all sites in a
|
|
replication group configure the same acknowledgement policy.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.AckPolicy.ALL">
|
|
<summary>
|
|
The master should wait until all replication clients have
|
|
acknowledged each permanent replication message.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.AckPolicy.ALL_PEERS">
|
|
<summary>
|
|
The master should wait until all electable peers have acknowledged
|
|
each permanent replication message (where "electable peer" means a
|
|
client capable of being subsequently elected master of the
|
|
replication group).
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.AckPolicy.NONE">
|
|
<summary>
|
|
The master should not wait for any client replication message
|
|
acknowledgments.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.AckPolicy.ONE">
|
|
<summary>
|
|
The master should wait until at least one client site has
|
|
acknowledged each permanent replication message.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.AckPolicy.ONE_PEER">
|
|
<summary>
|
|
The master should wait until at least one electable peer has
|
|
acknowledged each permanent replication message (where "electable
|
|
peer" means a client capable of being subsequently elected master of
|
|
the replication group).
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.AckPolicy.QUORUM">
|
|
<summary>
|
|
The master should wait until it has received acknowledgements from
|
|
the minimum number of electable peers sufficient to ensure that the
|
|
effect of the permanent record remains durable if an election is
|
|
held (where "electable peer" means a client capable of being
|
|
subsequently elected master of the replication group). This is the
|
|
default acknowledgement policy.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.TransactionConfig">
|
|
<summary>
|
|
A class representing configuration parameters for a
|
|
<see cref="T:BerkeleyDB.Transaction"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.IsolationDegree">
|
|
<summary>
|
|
The degree of isolation for this transaction
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.NoWait">
|
|
<summary>
|
|
If true and a lock is unavailable for any Berkeley DB operation
|
|
performed in the context of a transaction, cause the operation to
|
|
throw a <see cref="T:BerkeleyDB.DeadlockException"/>
|
|
(or <see cref="T:BerkeleyDB.LockNotGrantedException"/> if configured with
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted"/>).
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This setting overrides the behavior specified by
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoWait"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.Snapshot">
|
|
<summary>
|
|
If true, this transaction will execute with snapshot isolation.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
For databases with <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> set, data
|
|
values will be read as they are when the transaction begins, without
|
|
taking read locks. Silently ignored for operations on databases with
|
|
<see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> not set on the underlying
|
|
database (read locks are acquired).
|
|
</para>
|
|
<para>
|
|
A <see cref="T:BerkeleyDB.DeadlockException"/> will be thrown from update
|
|
operations if a snapshot transaction attempts to update data which
|
|
was modified after the snapshot transaction read it.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.SyncAction">
|
|
<summary>
|
|
Log sync behavior on transaction commit or prepare.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This setting overrides the behavior specified by
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoSync"/> and
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnWriteNoSync"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.TransactionConfig.#ctor">
|
|
<summary>
|
|
Instantiate a new TransactionConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionConfig.LockTimeout">
|
|
<summary>
|
|
The timeout value for locks for the transaction.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Timeouts are checked whenever a thread of control blocks on a lock
|
|
or when deadlock detection is performed. This timeout is for any
|
|
single lock request. As timeouts are only checked when the lock
|
|
request first blocks or when deadlock detection is performed, the
|
|
accuracy of the timeout depends on how often deadlock detection is
|
|
performed.
|
|
</para>
|
|
<para>
|
|
Timeout values may be specified for the database environment as a
|
|
whole. See <see cref="P:BerkeleyDB.DatabaseEnvironmentConfig.LockTimeout"/> for
|
|
more information.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionConfig.Name">
|
|
<summary>
|
|
The transaction's name. The name is returned by
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.TransactionSystemStats"/>
|
|
and displayed by
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.PrintTransactionSystemStats"/>.
|
|
</summary>
|
|
<remarks>
|
|
If the database environment has been configured for logging and the
|
|
Berkeley DB library was built in Debug mode (or with DIAGNOSTIC
|
|
defined), a debugging log record is written including the
|
|
transaction ID and the name.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.TransactionConfig.TxnTimeout">
|
|
<summary>
|
|
The timeout value for locks for the transaction.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Timeouts are checked whenever a thread of control blocks on a lock
|
|
or when deadlock detection is performed. This timeout is for the
|
|
life of the transaction. As timeouts are only checked when the lock
|
|
request first blocks or when deadlock detection is performed, the
|
|
accuracy of the timeout depends on how often deadlock detection is
|
|
performed.
|
|
</para>
|
|
<para>
|
|
Timeout values may be specified for the database environment as a
|
|
whole. See <see cref="P:BerkeleyDB.DatabaseEnvironmentConfig.TxnTimeout"/> for
|
|
more information.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.TransactionConfig.LogFlush">
|
|
<summary>
|
|
Specifies the log flushing behavior on transaction commit
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.LogFlush.DEFAULT">
|
|
<summary>
|
|
Use Berkeley DB's default behavior of syncing the log on commit.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.LogFlush.NOSYNC">
|
|
<summary>
|
|
Berkeley DB will not write or synchronously flush the log on
|
|
transaction commit or prepare.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This means the transaction will exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability);
|
|
that is, database integrity will be maintained but it is
|
|
possible that this transaction may be undone during recovery.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.LogFlush.WRITE_NOSYNC">
|
|
<summary>
|
|
Berkeley DB will write, but will not synchronously flush, the
|
|
log on transaction commit or prepare.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This means that transactions exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability);
|
|
that is, database integrity will be maintained, but if the
|
|
system fails, it is possible some number of the most recently
|
|
committed transactions may be undone during recovery. The number
|
|
of transactions at risk is governed by how often the system
|
|
flushes dirty buffers to disk and how often the log is
|
|
checkpointed.
|
|
</para>
|
|
<para>
|
|
For consistent behavior across the environment, all
|
|
<see cref="T:BerkeleyDB.DatabaseEnvironment"/> objects opened in the
|
|
environment must either set WRITE_NOSYNC, or the
|
|
DB_TXN_WRITE_NOSYNC flag should be specified in the DB_CONFIG
|
|
configuration file.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.TransactionConfig.LogFlush.SYNC">
|
|
<summary>
|
|
Berkeley DB will synchronously flush the log on transaction
|
|
commit or prepare.
|
|
</summary>
|
|
<remarks>
|
|
This means the transaction will exhibit all of the ACID
|
|
(atomicity, consistency, isolation, and durability) properties.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RepProcMsgResult">
|
|
<summary>
|
|
A class representing the return value of
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.Result">
|
|
<summary>
|
|
The result of processing an incoming replication message.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.RetLsn">
|
|
<summary>
|
|
The log sequence number of the permanent log message that could not
|
|
be written to disk if <see cref="F:BerkeleyDB.RepProcMsgResult.Result"/> is
|
|
<see cref="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.NOT_PERMANENT"/>. The largest log
|
|
sequence number of the permanent records that are now written to
|
|
disk as a result of processing the message, if
|
|
<see cref="F:BerkeleyDB.RepProcMsgResult.Result"/> is
|
|
<see cref="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.IS_PERMANENT"/>. In all other cases the
|
|
value is undefined.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RepProcMsgResult.ProcMsgResult">
|
|
<summary>
|
|
The result of processing an incoming replication message.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.DUPLICATE_MASTER">
|
|
<summary>
|
|
The replication group has more than one master.
|
|
</summary>
|
|
<remarks>
|
|
The application should reconfigure itself as a client by calling
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/>,
|
|
and then call for an election using
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.ERROR">
|
|
<summary>
|
|
An unspecified error occurred.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.HOLD_ELECTION">
|
|
<summary>
|
|
An election is needed.
|
|
</summary>
|
|
<remarks>
|
|
The application should call for an election using
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.IGNORED">
|
|
<summary>
|
|
A message cannot be processed.
|
|
</summary>
|
|
<remarks>
|
|
This is an indication that a message is irrelevant to the
|
|
current replication state (for example, an old message from a
|
|
previous generation arrives and is processed late).
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.IS_PERMANENT">
|
|
<summary>
|
|
Processing a message resulted in the processing of records that
|
|
are permanent.
|
|
</summary>
|
|
<remarks>
|
|
<see cref="F:BerkeleyDB.RepProcMsgResult.RetLsn"/> is the maximum LSN of the permanent
|
|
records stored.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.JOIN_FAILURE">
|
|
<summary>
|
|
A new master has been chosen but the client is unable to
|
|
synchronize with the new master.
|
|
</summary>
|
|
<remarks>
|
|
Possibly because the client has been configured with
|
|
<see cref="F:BerkeleyDB.ReplicationConfig.NoAutoInit"/> to turn off
|
|
automatic internal initialization.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.NEW_SITE">
|
|
<summary>
|
|
The system received contact information from a new environment.
|
|
</summary>
|
|
<remarks>
|
|
The rec parameter to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepProcessMessage(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.Int32)"/> contains the
|
|
opaque data specified in the cdata parameter to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/>. The
|
|
application should take whatever action is needed to establish a
|
|
communication channel with this new environment.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.NOT_PERMANENT">
|
|
<summary>
|
|
A message carrying a DB_REP_PERMANENT flag was processed
|
|
successfully, but was not written to disk.
|
|
</summary>
|
|
<remarks>
|
|
<see cref="F:BerkeleyDB.RepProcMsgResult.RetLsn"/> is the LSN of this record. The application
|
|
should take whatever action is deemed necessary to retain its
|
|
recoverability characteristics.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepProcMsgResult.ProcMsgResult.SUCCESS">
|
|
<summary>
|
|
Processing a message succeded.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.CompactConfig">
|
|
<summary>
|
|
A class to represent configuration settings for
|
|
<see cref="M:BerkeleyDB.BTreeDatabase.Compact(BerkeleyDB.CompactConfig)"/> and
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig)"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CompactConfig.returnEnd">
|
|
<summary>
|
|
Return the database key marking the end of the compaction operation
|
|
in a Btree or Recno database. This is generally the first key of the
|
|
page where the operation stopped.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CompactConfig.start">
|
|
<summary>
|
|
If non-null, the starting point for compaction. Compaction will
|
|
start at the smallest key greater than or equal to
|
|
<paramref name="start"/>. If null, compaction will start at the
|
|
beginning of the database.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CompactConfig.stop">
|
|
<summary>
|
|
If non-null, the stopping point for compaction. Compaction will stop
|
|
at the page with the smallest key greater than
|
|
<paramref name="stop"/>. If null, compaction will stop at the end of
|
|
the database.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CompactConfig.TruncatePages">
|
|
<summary>
|
|
If true, return pages to the filesystem when possible. If false,
|
|
pages emptied as a result of compaction will be placed on the free
|
|
list for re-use, but never returned to the filesystem.
|
|
</summary>
|
|
<remarks>
|
|
Note that only pages at the end of a file can be returned to the
|
|
filesystem. Because of the one-pass nature of the compaction
|
|
algorithm, any unemptied page near the end of the file inhibits
|
|
returning pages to the file system. A repeated call to
|
|
<see cref="M:BerkeleyDB.BTreeDatabase.Compact(BerkeleyDB.CompactConfig)"/> or
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig)"/> with a low
|
|
<see cref="P:BerkeleyDB.CompactConfig.FillPercentage"/> may be used to return pages in this
|
|
case.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.CompactConfig.#ctor">
|
|
<summary>
|
|
Create a new CompactConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactConfig.FillPercentage">
|
|
<summary>
|
|
If non-zero, this provides the goal for filling pages, specified as
|
|
a percentage between 1 and 100. Any page not at or above this
|
|
percentage full will be considered for compaction. The default
|
|
behavior is to consider every page for compaction, regardless of its
|
|
page fill percentage.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactConfig.Pages">
|
|
<summary>
|
|
If non-zero, compaction will complete after the specified number of
|
|
pages have been freed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactConfig.Timeout">
|
|
<summary>
|
|
If non-zero, and no <see cref="T:BerkeleyDB.Transaction"/> is specified, this
|
|
parameter identifies the lock timeout used for implicit
|
|
transactions, in microseconds.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ReplicationHostAddress">
|
|
<summary>
|
|
A class representing the address of a replication site used by Berkeley
|
|
DB HA.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationHostAddress.Host">
|
|
<summary>
|
|
The site's host identification string, generally a TCP/IP host name.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationHostAddress.Port">
|
|
<summary>
|
|
The port number on which the site is receiving.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ReplicationHostAddress.#ctor">
|
|
<summary>
|
|
Instantiate a new, empty address
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ReplicationHostAddress.#ctor(System.String)">
|
|
<summary>
|
|
Instantiate a new address, parsing the host and port from the given
|
|
string
|
|
</summary>
|
|
<param name="HostAndPort">A string in host:port format</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ReplicationHostAddress.#ctor(System.String,System.UInt32)">
|
|
<summary>
|
|
Instantiate a new address
|
|
</summary>
|
|
<param name="Host">The site's host identification string</param>
|
|
<param name="Port">
|
|
The port number on which the site is receiving.
|
|
</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.QueueStats">
|
|
<summary>
|
|
Statistical information about a QueueDatabase
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.DataPages">
|
|
<summary>
|
|
Data pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.DataPagesBytesFree">
|
|
<summary>
|
|
Bytes free in data pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.FirstRecordNumber">
|
|
<summary>
|
|
First not deleted record.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.MagicNumber">
|
|
<summary>
|
|
Magic number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.MetadataFlags">
|
|
<summary>
|
|
Metadata flags.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.NextRecordNumber">
|
|
<summary>
|
|
Next available record number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.nData">
|
|
<summary>
|
|
Number of data items.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.nKeys">
|
|
<summary>
|
|
Number of unique keys.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.PageSize">
|
|
<summary>
|
|
Page size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.PagesPerExtent">
|
|
<summary>
|
|
Pages per extent.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.RecordLength">
|
|
<summary>
|
|
Fixed-length record length.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.RecordPadByte">
|
|
<summary>
|
|
Fixed-length record pad.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.QueueStats.Version">
|
|
<summary>
|
|
Version number.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.CompactData">
|
|
<summary>
|
|
A class for representing compact operation statistics
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactData.Deadlocks">
|
|
<summary>
|
|
If no <see cref="T:BerkeleyDB.Transaction"/> parameter was specified, the
|
|
number of deadlocks which occurred.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactData.Levels">
|
|
<summary>
|
|
The number of levels removed from the Btree or Recno database during
|
|
the compaction phase.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactData.PagesExamined">
|
|
<summary>
|
|
The number of database pages reviewed during the compaction phase.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactData.PagesFreed">
|
|
<summary>
|
|
The number of database pages freed during the compaction phase.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactData.PagesTruncated">
|
|
<summary>
|
|
The number of database pages returned to the filesystem.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.CompactData.End">
|
|
<summary>
|
|
The database key marking the end of the compaction operation. This
|
|
is generally the first key of the page where the operation stopped
|
|
and is only non-null if <see cref="F:BerkeleyDB.CompactConfig.returnEnd"/> was
|
|
true.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ByteOrder">
|
|
<summary>
|
|
A class to represent the database byte order.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ByteOrder.MACHINE">
|
|
<summary>
|
|
The host byte order of the machine where the Berkeley DB library was
|
|
compiled.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ByteOrder.LITTLE_ENDIAN">
|
|
<summary>
|
|
Little endian byte order
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ByteOrder.BIG_ENDIAN">
|
|
<summary>
|
|
Big endian byte order
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ByteOrder.FromConst(System.Int32)">
|
|
<summary>
|
|
Convert from the integer constant used to represent byte order in
|
|
the C library to its corresponding ByteOrder object.
|
|
</summary>
|
|
<param name="order">The C library constant</param>
|
|
<returns>
|
|
The ByteOrder object corresponding to the given constant
|
|
</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BTreeDatabase">
|
|
<summary>
|
|
A class representing a BTreeDatabase. The Btree format is a
|
|
representation of a sorted, balanced tree structure.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new BTreeDatabase 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.BTreeDatabase.Open(System.String,System.String,BerkeleyDB.BTreeDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new BTreeDatabase 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.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new BTreeDatabase 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.BTreeDatabase.Open(System.String,System.String,BerkeleyDB.BTreeDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new BTreeDatabase 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.BTreeDatabase.Compact(BerkeleyDB.CompactConfig)">
|
|
<summary>
|
|
Compact the database, and optionally return unused database pages to
|
|
the underlying filesystem.
|
|
</summary>
|
|
<remarks>
|
|
If the operation occurs in a transactional database, the operation
|
|
will be implicitly transaction protected using multiple
|
|
transactions. These transactions will be periodically committed to
|
|
avoid locking large sections of the tree. Any deadlocks encountered
|
|
cause the compaction operation to be retried from the point of the
|
|
last transaction commit.
|
|
</remarks>
|
|
<param name="cdata">Compact configuration parameters</param>
|
|
<returns>Compact operation statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.Compact(BerkeleyDB.CompactConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Compact the database, and optionally return unused database pages to
|
|
the underlying filesystem.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If <paramref name="txn"/> is non-null, then the operation is
|
|
performed using that transaction. In this event, large sections of
|
|
the tree may be locked during the course of the transaction.
|
|
</para>
|
|
<para>
|
|
If <paramref name="txn"/> is null, but the operation occurs in a
|
|
transactional database, the operation will be implicitly transaction
|
|
protected using multiple transactions. These transactions will be
|
|
periodically committed to avoid locking large sections of the tree.
|
|
Any deadlocks encountered cause the compaction operation to be
|
|
retried from the point of the last transaction commit.
|
|
</para>
|
|
</remarks>
|
|
<param name="cdata">Compact configuration parameters</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>Compact operation statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.Cursor">
|
|
<summary>
|
|
Create a database cursor.
|
|
</summary>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.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.BTreeDatabase.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.BTreeDatabase.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.BTreeDatabase.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.BTreeDatabase.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.BTreeDatabase.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.BTreeDatabase.Get(System.UInt32)">
|
|
<summary>
|
|
Retrieve a specific numbered key/data pair from the database.
|
|
</summary>
|
|
<param name="recno">
|
|
The record number of the record to be retrieved.
|
|
</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.BTreeDatabase.Get(System.UInt32,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Retrieve a specific numbered key/data pair from the database.
|
|
</summary>
|
|
<param name="recno">
|
|
The record number of the record to be retrieved.
|
|
</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.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.Get(System.UInt32,BerkeleyDB.Transaction,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Retrieve a specific numbered key/data pair from the database.
|
|
</summary>
|
|
<param name="recno">
|
|
The record number of the record to be retrieved.
|
|
</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.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.KeyRange(BerkeleyDB.DatabaseEntry)">
|
|
<summary>
|
|
Return an estimate of the proportion of keys that are less than,
|
|
equal to, and greater than the specified key.
|
|
</summary>
|
|
<param name="key">The key to search for</param>
|
|
<returns>
|
|
An estimate of the proportion of keys that are less than, equal to,
|
|
and greater than the specified key.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.KeyRange(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Return an estimate of the proportion of keys that are less than,
|
|
equal to, and greater than the specified key.
|
|
</summary>
|
|
<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>
|
|
<returns>
|
|
An estimate of the proportion of keys that are less than, equal to,
|
|
and greater than the specified key.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.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.BTreeDatabase.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.BTreeDatabase.Stats">
|
|
<summary>
|
|
Return the database statistical information for this database.
|
|
</summary>
|
|
<returns>Database statistical information.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeDatabase.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.BTreeDatabase.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="M:BerkeleyDB.BTreeDatabase.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.BTreeDatabase.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="P:BerkeleyDB.BTreeDatabase.Compare">
|
|
<summary>
|
|
The Btree 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.BTreeDatabase.Compress">
|
|
<summary>
|
|
The compression function used to store key/data pairs in the
|
|
database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabase.Decompress">
|
|
<summary>
|
|
The decompression function used to retrieve key/data pairs from the
|
|
database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabase.DupCompare">
|
|
<summary>
|
|
The duplicate data item comparison function.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabase.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.BTreeDatabase.MinKeysPerPage">
|
|
<summary>
|
|
The minimum number of key/data pairs intended to be stored on any
|
|
single Btree leaf page.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabase.PrefixCompare">
|
|
<summary>
|
|
The Btree prefix function. The prefix function is used to determine
|
|
the amount by which keys stored on the Btree internal pages can be
|
|
safely truncated without losing their uniqueness.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabase.RecordNumbers">
|
|
<summary>
|
|
If true, this object supports retrieval from the Btree using record
|
|
numbers.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.BTreeDatabase.ReverseSplit">
|
|
<summary>
|
|
If false, empty pages will not be coalesced into higher-level pages.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RecnoDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.RecnoDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RecnoDatabaseConfig.Renumber">
|
|
<summary>
|
|
Cause the logical record numbers to be mutable, and change as
|
|
records are added to and deleted from the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Using <see cref="M:BerkeleyDB.Database.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> or <see cref="M:BerkeleyDB.Cursor.Put(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32)"/> to
|
|
create new records will cause the creation of multiple records if
|
|
the record number is more than one greater than the largest record
|
|
currently in the database. For example, creating record 28, when
|
|
record 25 was previously the last record in the database, will
|
|
create records 26 and 27 as well as 28. Attempts to retrieve records
|
|
that were created in this manner will throw a
|
|
<see cref="T:BerkeleyDB.KeyEmptyException"/>.
|
|
</para>
|
|
<para>
|
|
If a created record is not at the end of the database, all records
|
|
following the new record will be automatically renumbered upward by
|
|
one. For example, the creation of a new record numbered 8 causes
|
|
records numbered 8 and greater to be renumbered upward by one. If a
|
|
cursor was positioned to record number 8 or greater before the
|
|
insertion, it will be shifted upward one logical record, continuing
|
|
to refer to the same record as it did before.
|
|
</para>
|
|
<para>
|
|
If a deleted record is not at the end of the database, all records
|
|
following the removed record will be automatically renumbered
|
|
downward by one. For example, deleting the record numbered 8 causes
|
|
records numbered 9 and greater to be renumbered downward by one. If
|
|
a cursor was positioned to record number 9 or greater before the
|
|
removal, it will be shifted downward one logical record, continuing
|
|
to refer to the same record as it did before.
|
|
</para>
|
|
<para>
|
|
If a record is deleted, all cursors that were positioned on that
|
|
record prior to the removal will no longer be positioned on a valid
|
|
entry. This includes cursors used to delete an item. For example, if
|
|
a cursor was positioned to record number 8 before the removal of
|
|
that record, subsequent calls to <see cref="M:BerkeleyDB.Cursor.Refresh"/>
|
|
will return false until the cursor is moved to another record. A
|
|
call to <see cref="M:BerkeleyDB.Cursor.MoveNext"/> will return the new record
|
|
numbered 8 - which is the record that was numbered 9 prior to the
|
|
delete (if such a record existed).
|
|
</para>
|
|
<para>
|
|
For these reasons, concurrent access to a
|
|
<see cref="T:BerkeleyDB.RecnoDatabase"/> with this setting specified may be
|
|
largely meaningless, although it is supported.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting must be the same as the
|
|
existing database or an exception will be thrown.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RecnoDatabaseConfig.Snapshot">
|
|
<summary>
|
|
If true, any <see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> file will be read in its
|
|
entirety when <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is called. If false,
|
|
<see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> may be read lazily.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RecnoDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RecnoDatabaseConfig.Append">
|
|
<summary>
|
|
A function to call after the record number has been selected but
|
|
before the data has been stored into the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
When using <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>, it may be useful to
|
|
modify the stored data based on the generated key. If a delegate is
|
|
specified, it will be called after the record number has been
|
|
selected, but before the data has been stored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile">
|
|
<summary>
|
|
The underlying source file for the Recno access method.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The purpose of the source file is to provide fast access and
|
|
modification to databases that are normally stored as flat text
|
|
files.
|
|
</para>
|
|
<para>
|
|
The source parameter specifies an underlying flat text database file
|
|
that is read to initialize a transient record number index. In the
|
|
case of variable length records, the records are separated, as
|
|
specified by <see cref="P:BerkeleyDB.RecnoDatabaseConfig.Delimiter"/>. For example, standard UNIX
|
|
byte stream files can be interpreted as a sequence of variable
|
|
length records separated by newline characters.
|
|
</para>
|
|
<para>
|
|
In addition, when cached data would normally be written back to the
|
|
underlying database file (for example,
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Close"/> or
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Sync"/>), the in-memory copy of the
|
|
database will be written back to the source file.
|
|
</para>
|
|
<para>
|
|
By default, the backing source file is read lazily; that is, records
|
|
are not read from the file until they are requested by the
|
|
application. If multiple processes (not threads) are accessing a
|
|
Recno database concurrently, and are either inserting or deleting
|
|
records, the backing source file must be read in its entirety before
|
|
more than a single process accesses the database, and only that
|
|
process should specify the backing source file as part of the
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> call. See <see cref="F:BerkeleyDB.RecnoDatabaseConfig.Snapshot"/>
|
|
for more information.
|
|
</para>
|
|
<para>
|
|
Reading and writing the backing source file specified by source
|
|
cannot be transaction-protected because it involves filesystem
|
|
operations that are not part of the Db transaction methodology. For
|
|
this reason, if a temporary database is used to hold the records, it
|
|
is possible to lose the contents of the source file, for example, if
|
|
the system crashes at the right instant. If a file is used to hold
|
|
the database, normal database recovery on that file can be used to
|
|
prevent information loss, although it is still possible that the
|
|
contents of source will be lost if the system crashes.
|
|
</para>
|
|
<para>
|
|
The source file must already exist (but may be zero-length) when
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is called.
|
|
</para>
|
|
<para>
|
|
It is not an error to specify a read-only source file when creating
|
|
a database, nor is it an error to modify the resulting database.
|
|
However, any attempt to write the changes to the backing source file
|
|
using either the <see cref="M:BerkeleyDB.BaseDatabase.Sync"/> or
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Close"/> methods will fail, of course.
|
|
Use <see cref="M:BerkeleyDB.BaseDatabase.Close(System.Boolean)"/> to stop it from
|
|
attempting to write the changes to the backing file; instead, they
|
|
will be silently discarded.
|
|
</para>
|
|
<para>
|
|
For all of the previous reasons, the source file is generally used
|
|
to specify databases that are read-only for Berkeley DB
|
|
applications; and that are either generated on the fly by software
|
|
tools or modified using a different mechanism — for example, a text
|
|
editor.
|
|
</para>
|
|
<para>
|
|
If the database already exists, BackingFile must be the same as that
|
|
historically used to create the database or corruption can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabaseConfig.#ctor">
|
|
<summary>
|
|
Instantiate a new RecnoDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabaseConfig.Delimiter">
|
|
<summary>
|
|
The delimiting byte used to mark the end of a record in
|
|
<see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/>.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This byte is used for variable length records if
|
|
<see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> is set. If <see cref="F:BerkeleyDB.RecnoDatabaseConfig.BackingFile"/> is
|
|
specified and no delimiting byte was specified, newline characters
|
|
(that is, ASCII 0x0a) are interpreted as end-of-record markers.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabaseConfig.Length">
|
|
<summary>
|
|
Specify that the records are fixed-length, not byte-delimited, and
|
|
are of length Length.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Any records added to the database that are less than Length bytes
|
|
long are automatically padded (see <see cref="P:BerkeleyDB.RecnoDatabaseConfig.PadByte"/> for more
|
|
information).
|
|
</para>
|
|
<para>
|
|
Any attempt to insert records into the database that are greater
|
|
than Length bytes long will cause the call to fail immediately and
|
|
return an error.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabaseConfig.PadByte">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If no pad character is specified, space characters (that is, ASCII
|
|
0x20) are used for padding.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.HashStats">
|
|
<summary>
|
|
Statistical information about a HashDatabase
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.BigPages">
|
|
<summary>
|
|
Number of big key/data pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.BigPagesFreeBytes">
|
|
<summary>
|
|
Bytes free on big item pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.BucketPagesFreeBytes">
|
|
<summary>
|
|
Bytes free on bucket pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.DuplicatePages">
|
|
<summary>
|
|
Number of dup pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.DuplicatePagesFreeBytes">
|
|
<summary>
|
|
Bytes free on duplicate pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.FillFactor">
|
|
<summary>
|
|
Fill factor specified at create.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.FreePages">
|
|
<summary>
|
|
Pages on the free list.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.MetadataFlags">
|
|
<summary>
|
|
Metadata flags.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.MagicNumber">
|
|
<summary>
|
|
Magic number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.nBlobRecords">
|
|
<summary>
|
|
Number of blobs.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.nData">
|
|
<summary>
|
|
Number of data items.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.nHashBuckets">
|
|
<summary>
|
|
Number of hash buckets.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.nKeys">
|
|
<summary>
|
|
Number of unique keys.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.OverflowPages">
|
|
<summary>
|
|
Number of overflow pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.OverflowPagesFreeBytes">
|
|
<summary>
|
|
Bytes free on ovfl pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.nPages">
|
|
<summary>
|
|
Page count.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.PageSize">
|
|
<summary>
|
|
Page size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.HashStats.Version">
|
|
<summary>
|
|
Version number.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.CursorConfig">
|
|
<summary>
|
|
A class representing configuration parameters for <see cref="T:BerkeleyDB.Cursor"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CursorConfig.IsolationDegree">
|
|
<summary>
|
|
The isolation degree the cursor should use.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
<see cref="F:BerkeleyDB.Isolation.DEGREE_TWO"/> ensures the stability of the
|
|
current data item read by this cursor but permits data read by this
|
|
cursor to be modified or deleted prior to the commit of the
|
|
transaction for this cursor.
|
|
</para>
|
|
<para>
|
|
<see cref="F:BerkeleyDB.Isolation.DEGREE_ONE"/> allows read operations performed
|
|
by the cursor to return modified but not yet committed data.
|
|
Silently ignored if the <see cref="F:BerkeleyDB.DatabaseConfig.ReadUncommitted"/>
|
|
was not specified when the underlying database was opened.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CursorConfig.WriteCursor">
|
|
<summary>
|
|
If true, specify that the cursor will be used to update the
|
|
database. The underlying database environment must have been opened
|
|
with <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseCDB"/> set.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CursorConfig.SnapshotIsolation">
|
|
<summary>
|
|
<para>
|
|
Configure a transactional cursor to operate with read-only snapshot
|
|
isolation. For databases with <see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/>
|
|
set, data values will be read as they are when the cursor is opened,
|
|
without taking read locks.
|
|
</para>
|
|
<para>
|
|
This setting implicitly begins a transaction that is committed when
|
|
the cursor is closed.
|
|
</para>
|
|
<para>
|
|
This setting is silently ignored if
|
|
<see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> is not set on the underlying
|
|
database or if a transaction is supplied to
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>
|
|
</para>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CursorConfig.Priority">
|
|
<summary>
|
|
The cache priority for pages referenced by the cursor.
|
|
</summary>
|
|
<remarks>
|
|
The priority of a page biases the replacement algorithm to be more
|
|
or less likely to discard a page when space is needed in the buffer
|
|
pool. The bias is temporary, and pages will eventually be discarded
|
|
if they are not referenced again. The setting is only advisory, and
|
|
does not guarantee pages will be treated in a specific way.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.CursorConfig.#ctor">
|
|
<summary>
|
|
Instantiate a new CursorConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryQueueDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.SecondaryQueueDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryQueueDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.SecondaryQueueDatabase.Open(System.String,BerkeleyDB.SecondaryQueueDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryQueueDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
|
|
<summary>
|
|
Instantiate a new SecondaryQueueDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryQueueDatabaseConfig.Length">
|
|
<summary>
|
|
Specify the length of records in the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The record length must be enough smaller than
|
|
<see cref="P:BerkeleyDB.DatabaseConfig.PageSize"/> that at least one record plus
|
|
the database page's metadata information can fit on each database
|
|
page.
|
|
</para>
|
|
<para>
|
|
Any records added to the database that are less than Length bytes
|
|
long are automatically padded (see <see cref="P:BerkeleyDB.SecondaryQueueDatabaseConfig.PadByte"/> for more
|
|
information).
|
|
</para>
|
|
<para>
|
|
Any attempt to insert records into the database that are greater
|
|
than Length bytes long will cause the call to fail immediately and
|
|
return an error.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryQueueDatabaseConfig.PadByte">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If no pad character is specified, space characters (that is, ASCII
|
|
0x20) are used for padding.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryQueueDatabaseConfig.ExtentSize">
|
|
<summary>
|
|
The size of the extents used to hold pages in a
|
|
<see cref="T:BerkeleyDB.SecondaryQueueDatabase"/>, specified as a number of
|
|
pages.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Each extent is created as a separate physical file. If no extent
|
|
size is set, the default behavior is to create only a single
|
|
underlying database file.
|
|
</para>
|
|
<para>
|
|
For information on tuning the extent size, see Selecting a extent
|
|
size in the Programmer's Reference Guide.
|
|
</para>
|
|
<para>
|
|
If the database already exists, this setting will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryHashDatabase">
|
|
<summary>
|
|
A class representing a SecondaryHashDatabase. The Hash format is an
|
|
extensible, dynamic hashing scheme.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryHashDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryHashDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryHashDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryHashDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryHashDatabase.Open(System.String,BerkeleyDB.SecondaryHashDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryHashDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryHashDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryHashDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryHashDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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="P:BerkeleyDB.SecondaryHashDatabase.Compare">
|
|
<summary>
|
|
The secondary 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.SecondaryHashDatabase.DupCompare">
|
|
<summary>
|
|
The duplicate data item comparison function.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryHashDatabase.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.SecondaryHashDatabase.FillFactor">
|
|
<summary>
|
|
The desired density within the hash table.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryHashDatabase.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.SecondaryHashDatabase.TableSize">
|
|
<summary>
|
|
An estimate of the final size of the hash table.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RepMgrStats">
|
|
<summary>
|
|
Statistical information about the Replication Manager
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RepMgrStats.DroppedConnections">
|
|
<summary>
|
|
Existing connections dropped.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RepMgrStats.DroppedMessages">
|
|
<summary>
|
|
# msgs discarded due to excessive queue length.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RepMgrStats.FailedConnections">
|
|
<summary>
|
|
Failed new connection attempts.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RepMgrStats.FailedMessages">
|
|
<summary>
|
|
# of insufficiently ack'ed msgs.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RepMgrStats.QueuedMessages">
|
|
<summary>
|
|
# msgs queued for network delay.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ReplicationConfig">
|
|
<summary>
|
|
A class representing configuration parameters for a
|
|
<see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s replication subsystem.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ReplicationConfig.#ctor">
|
|
<summary>
|
|
Instantiate a new ReplicationConfig object with default
|
|
configuration values.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.BulkTransfer">
|
|
<summary>
|
|
If true, the replication master will send groups of records to the
|
|
clients in a single network transfer
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.DelayClientSync">
|
|
<summary>
|
|
If true, the client will delay synchronizing to a newly declared
|
|
master (defaults to false). Clients configured in this way will
|
|
remain unsynchronized until the application calls
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepSync"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.UseMasterLeases">
|
|
<summary>
|
|
If true, master leases will be used for this site (defaults to
|
|
false).
|
|
</summary>
|
|
<remarks>
|
|
Configuring this option may result in a
|
|
<see cref="T:BerkeleyDB.LeaseExpiredException"/> when attempting to read entries
|
|
from a database after the site's master lease has expired.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.NoAutoInit">
|
|
<summary>
|
|
If true, the replication master will not automatically re-initialize
|
|
outdated clients (defaults to false).
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.NoBlocking">
|
|
<summary>
|
|
If true, Berkeley DB method calls that would normally block while
|
|
clients are in recovery will return errors immediately (defaults to
|
|
false).
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.Strict2Site">
|
|
<summary>
|
|
If true, the Replication Manager will observe the strict "majority"
|
|
rule in managing elections, even in a group with only 2 sites. This
|
|
means the client in a 2-site group will be unable to take over as
|
|
master if the original master fails or becomes disconnected. (See
|
|
the Elections section in the Berkeley DB Reference Guide for more
|
|
information.) Both sites in the replication group should have the
|
|
same value for this parameter.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ReplicationConfig.Clockskew(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="F:BerkeleyDB.ReplicationConfig.UseMasterLeases"/>. Additionally, the user must also
|
|
set the master lease timeout via <see cref="P:BerkeleyDB.ReplicationConfig.LeaseTimeout"/> and
|
|
the number of sites in the replication group via
|
|
<see cref="P:BerkeleyDB.ReplicationConfig.NSites"/>. 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.ReplicationConfig.RetransmissionRequest(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.ReplicationConfig.TransmitLimit(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="F:BerkeleyDB.ReplicationConfig.Transport">
|
|
<summary>
|
|
The delegate used to transmit data using the replication
|
|
application's communication infrastructure.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.RepMgrAckPolicy">
|
|
<summary>
|
|
Specify how master and client sites will handle acknowledgment of
|
|
replication messages which are necessary for "permanent" records.
|
|
The current implementation requires all sites in a replication group
|
|
configure the same acknowledgement policy.
|
|
</summary>
|
|
<seealso cref="P:BerkeleyDB.ReplicationConfig.AckTimeout"/>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ReplicationConfig.RepMgrLocalSite">
|
|
<summary>
|
|
The host information for the local system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ReplicationConfig.AddRemoteSite(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>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.AckTimeout">
|
|
<summary>
|
|
The amount of time the replication manager's transport function
|
|
waits to collect enough acknowledgments from replication group
|
|
clients, before giving up and returning a failure indication. The
|
|
default wait time is 1 second.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.CheckpointDelay">
|
|
<summary>
|
|
The amount of time a master site will delay between completing a
|
|
checkpoint and writing a checkpoint record into the log.
|
|
</summary>
|
|
<remarks>
|
|
This delay allows clients to complete their own checkpoints before
|
|
the master requires completion of them. The default is 30 seconds.
|
|
If all databases in the environment, and the environment's
|
|
transaction log, are configured to reside in memory (never preserved
|
|
to disk), then, although checkpoints are still necessary, the delay
|
|
is not useful and should be set to 0.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.ConnectionRetry">
|
|
<summary>
|
|
The amount of time the replication manager will wait before trying
|
|
to re-establish a connection to another site after a communication
|
|
failure. The default wait time is 30 seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.ElectionTimeout">
|
|
<summary>
|
|
The timeout period for an election. The default timeout is 2
|
|
seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.ElectionRetry">
|
|
<summary>
|
|
Configure the amount of time the replication manager will wait
|
|
before retrying a failed election. The default wait time is 10
|
|
seconds.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.FullElectionTimeout">
|
|
<summary>
|
|
An optional configuration timeout period to wait for full election
|
|
participation the first time the replication group finds a master.
|
|
By default this option is turned off and normal election timeouts
|
|
are used. (See the Elections section in the Berkeley DB Reference
|
|
Guide for more information.)
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.HeartbeatMonitor">
|
|
<summary>
|
|
The amount of time the replication manager, running at a client
|
|
site, waits for some message activity on the connection from the
|
|
master (heartbeats or other messages) before concluding that the
|
|
connection has been lost. When 0 (the default), no monitoring is
|
|
performed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.HeartbeatSend">
|
|
<summary>
|
|
The frequency at which the replication manager, running at a master
|
|
site, broadcasts a heartbeat message in an otherwise idle system.
|
|
When 0 (the default), no heartbeat messages will be sent.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.LeaseTimeout">
|
|
<summary>
|
|
The amount of time a client grants its master lease to a master.
|
|
When using master leases all sites in a replication group must use
|
|
the same lease timeout value. There is no default value. If leases
|
|
are desired, this method must be called prior to calling
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartClient"/> or
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.ClockskewFast">
|
|
<summary>
|
|
The value, relative to <see cref="P:BerkeleyDB.ReplicationConfig.ClockskewSlow"/>, of the fastest
|
|
clock in the group of sites.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.ClockskewSlow">
|
|
<summary>
|
|
The value of the slowest clock in the group of sites.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.NSites">
|
|
<summary>
|
|
The total number of sites in the replication group.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This setting is typically used by applications which use the
|
|
Berkeley DB library "replication manager" support. (However, see
|
|
also <see cref="M:BerkeleyDB.DatabaseEnvironment.RepHoldElection"/>, the
|
|
description of the nsites parameter.)
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.Priority">
|
|
<summary>
|
|
The database environment's priority in replication group elections.
|
|
A special value of 0 indicates that this environment cannot be a
|
|
replication group master. If not configured, then a default value
|
|
of 100 is used.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.RetransmissionRequestMin">
|
|
<summary>
|
|
The minimum number of microseconds a client waits before requesting
|
|
retransmission.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.RetransmissionRequestMax">
|
|
<summary>
|
|
The maximum number of microseconds a client waits before requesting
|
|
retransmission.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.TransmitLimitGBytes">
|
|
<summary>
|
|
The gigabytes component of the 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)"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.ReplicationConfig.TransmitLimitBytes">
|
|
<summary>
|
|
The bytes component of the 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)"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.MutexConfig">
|
|
<summary>
|
|
A class representing configuration parameters for a
|
|
<see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s mutex subsystem.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexConfig.Alignment">
|
|
<summary>
|
|
The mutex alignment, in bytes.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
It is sometimes advantageous to align mutexes on specific byte
|
|
boundaries in order to minimize cache line collisions. Alignment
|
|
specifies an alignment for mutexes allocated by Berkeley DB.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
Alignment will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexConfig.Increment">
|
|
<summary>
|
|
Configure the number of additional mutexes to allocate.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If both Increment and <see cref="P:BerkeleyDB.MutexConfig.MaxMutexes"/> are set, the value of
|
|
Increment will be silently ignored.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
Increment will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexConfig.MaxMutexes">
|
|
<summary>
|
|
The total number of mutexes to allocate.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Berkeley DB allocates a default number of mutexes based on the
|
|
initial configuration of the database environment. That default
|
|
calculation may be too small if the application has an unusual need
|
|
for mutexes (for example, if the application opens an unexpectedly
|
|
large number of databases) or too large (if the application is
|
|
trying to minimize its memory footprint). MaxMutexes is used to
|
|
specify an absolute number of mutexes to allocate.
|
|
</para>
|
|
<para>
|
|
If both <see cref="P:BerkeleyDB.MutexConfig.Increment"/> and MaxMutexes are set, the value of
|
|
Increment will be silently ignored.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
MaxMutexes will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexConfig.NumTestAndSetSpins">
|
|
<summary>
|
|
The number of spins test-and-set mutexes should execute before
|
|
blocking.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.AppendRecordDelegate">
|
|
<summary>
|
|
A function to call after the record number has been selected but before
|
|
the data has been stored into the database.
|
|
</summary>
|
|
<param name="data">The data to be stored.</param>
|
|
<param name="recno">The generated record number.</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BTreeCompressDelegate">
|
|
<summary>
|
|
A function to store a compressed key/data pair into a supplied buffer.
|
|
</summary>
|
|
<param name="prevKey">The key immediately preceding the application supplied key.</param>
|
|
<param name="prevData">The data associated with prevKey.</param>
|
|
<param name="key">The application supplied key.</param>
|
|
<param name="data">The application supplied data. </param>
|
|
<param name="dest">The compressed data to be stored in the
|
|
database.</param>
|
|
<param name="size">The number of compressed bytes written to
|
|
<paramref name="dest"/>, or the required size of
|
|
<paramref name="dest"/>, if too small.</param>
|
|
<returns>True on success, false if dest is too small to contain the
|
|
compressed data. All other errors should throw an exception.</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BTreeDecompressDelegate">
|
|
<summary>
|
|
A function to decompress a key/data pair from a supplied buffer.
|
|
</summary>
|
|
<param name="prevKey">The key immediately preceding the key being decompressed.</param>
|
|
<param name="prevData">The data associated with prevKey.</param>
|
|
<param name="compressed">The data stored in the tree, that is, the compressed data.</param>
|
|
<param name="bytesRead">The number of bytes read from <paramref name="compressed"/>.</param>
|
|
<returns>Two new DatabaseEntry objects representing the decompressed
|
|
key/data pair.</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DatabaseFeedbackDelegate">
|
|
<summary>
|
|
The application-specified feedback function called to report Berkeley DB
|
|
operation progress.
|
|
</summary>
|
|
<param name="opcode">
|
|
An operation code specifying the Berkley DB operation
|
|
</param>
|
|
<param name="percent">
|
|
The percent of the operation that has been completed, specified as an
|
|
integer value between 0 and 100.
|
|
</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.EntryComparisonDelegate">
|
|
<summary>
|
|
An application-specified comparison function.
|
|
</summary>
|
|
<param name="dbt1">The application supplied key.</param>
|
|
<param name="dbt2">The current tree's key.</param>
|
|
<returns>
|
|
An integer value less than, equal to, or greater than zero if the first
|
|
key parameter is considered to be respectively less than, equal to, or
|
|
greater than the second key parameter.
|
|
</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.EnvironmentFeedbackDelegate">
|
|
<summary>
|
|
The application-specified feedback function called to report Berkeley DB
|
|
operation progress.
|
|
</summary>
|
|
<param name="opcode">
|
|
An operation code specifying the Berkley DB operation
|
|
</param>
|
|
<param name="percent">
|
|
The percent of the operation that has been completed, specified as an
|
|
integer value between 0 and 100.
|
|
</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ErrorFeedbackDelegate">
|
|
<summary>
|
|
The application-specified error reporting function.
|
|
</summary>
|
|
<param name="errPrefix">The prefix string</param>
|
|
<param name="errMessage">The error message string</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.EventNotifyDelegate">
|
|
<summary>
|
|
The application's event notification function.
|
|
</summary>
|
|
<param name="eventcode">
|
|
An even code specifying the Berkeley DB event
|
|
</param>
|
|
<param name="event_info">
|
|
Additional information describing an event. By default, event_info is
|
|
null; specific events may pass non-null values, in which case the event
|
|
will also describe the information's structure.
|
|
</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ForeignKeyNullifyDelegate">
|
|
<summary>
|
|
|
|
</summary>
|
|
<param name="key"></param>
|
|
<param name="data"></param>
|
|
<param name="foreignkey"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.HashFunctionDelegate">
|
|
<summary>
|
|
The application-specified hash function.
|
|
</summary>
|
|
<param name="data">
|
|
A byte string representing a key in the database
|
|
</param>
|
|
<returns>The hashed value of <paramref name="data"/></returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ReplicationTransportDelegate">
|
|
<summary>
|
|
The function used to transmit data using the replication application's
|
|
communication infrastructure.
|
|
</summary>
|
|
<param name="control">
|
|
The first of the two data elements to be transmitted by the send
|
|
function.
|
|
</param>
|
|
<param name="rec">
|
|
The second of the two data elements to be transmitted by the send
|
|
function.
|
|
</param>
|
|
<param name="lsn">
|
|
If the type of message to be sent has an LSN associated with it, then
|
|
this is the LSN of the record being sent. This LSN can be used to
|
|
determine that certain records have been processed successfully by
|
|
clients.
|
|
</param>
|
|
<param name="envid">
|
|
<para>
|
|
A positive integer identifier that specifies the replication environment
|
|
to which the message should be sent.
|
|
</para>
|
|
<para>
|
|
The special identifier DB_EID_BROADCAST indicates that a message should
|
|
be broadcast to every environment in the replication group. The
|
|
application may use a true broadcast protocol or may send the message
|
|
in sequence to each machine with which it is in communication. In both
|
|
cases, the sending site should not be asked to process the message.
|
|
</para>
|
|
<para>
|
|
The special identifier DB_EID_INVALID indicates an invalid environment
|
|
ID. This may be used to initialize values that are subsequently checked
|
|
for validity.
|
|
</para>
|
|
</param>
|
|
<param name="flags">XXX: TBD</param>
|
|
<returns>0 on success and non-zero on failure</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryKeyGenDelegate">
|
|
<summary>
|
|
The function that creates the set of secondary keys corresponding to a
|
|
given primary key and data pair.
|
|
</summary>
|
|
<param name="key">The primary key</param>
|
|
<param name="data">The primary data item</param>
|
|
<returns>The secondary key(s)</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SetThreadIDDelegate">
|
|
<summary>
|
|
A function which returns a unique identifier pair for a thread of
|
|
control in a Berkeley DB application.
|
|
</summary>
|
|
<returns>
|
|
A DbThreadID object describing the current thread of control
|
|
</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SetThreadNameDelegate">
|
|
<summary>
|
|
A function which returns an identifier pair for a thread of control
|
|
formatted for display.
|
|
</summary>
|
|
<param name="info">The thread of control to format</param>
|
|
<returns>The formatted identifier pair</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ThreadIsAliveDelegate">
|
|
<summary>
|
|
A function which returns whether the thread of control, identified by
|
|
<paramref name="info"/>, is still running.
|
|
</summary>
|
|
<param name="info">The thread of control to check</param>
|
|
<param name="procOnly">
|
|
If true, return only if the process is alive, and the
|
|
<see cref="F:BerkeleyDB.DbThreadID.threadID"/> portion of <paramref name="info"/>
|
|
should be ignored.
|
|
</param>
|
|
<returns>True if the tread is alive, false otherwise.</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DatabaseEnvironmentConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.DatabaseEnvironment"/>
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironmentConfig.#ctor">
|
|
<summary>
|
|
Create a new object, with default settings
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.LockSystemCfg">
|
|
<summary>
|
|
Configuration for the locking subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.LogSystemCfg">
|
|
<summary>
|
|
Configuration for the logging subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.MPoolSystemCfg">
|
|
<summary>
|
|
Configuration for the memory pool subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.MutexSystemCfg">
|
|
<summary>
|
|
Configuration for the mutex subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.RepSystemCfg">
|
|
<summary>
|
|
Configuration for the replication subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.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>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.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="F:BerkeleyDB.DatabaseEnvironmentConfig.EventNotify">
|
|
<summary>
|
|
A delegate which is called to notify the process of specific
|
|
Berkeley DB events.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.SetThreadID">
|
|
<summary>
|
|
A delegate that returns a unique identifier pair for the current
|
|
thread of control.
|
|
</summary>
|
|
<remarks>
|
|
This delegate supports <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>.
|
|
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.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadName">
|
|
<summary>
|
|
A delegate that formats a process ID and thread ID identifier pair.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadIsAlive">
|
|
<summary>
|
|
A delegate that returns if a thread of control (either a true thread
|
|
or a process) is still running.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.DataDirs">
|
|
<summary>
|
|
Paths of directories to be used as the location of the access method
|
|
database files.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Paths specified to <see cref="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)"/> will be searched
|
|
relative to this path. Paths set using this method are additive, and
|
|
specifying more than one will result in each specified directory
|
|
being searched for database files.
|
|
</para>
|
|
<para>
|
|
If no database directories are specified, database files must be
|
|
named either by absolute paths or relative to the environment home
|
|
directory. See Berkeley DB File Naming in the Programmer's Reference
|
|
Guide for more information.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.CreationDir">
|
|
<summary>
|
|
The path of a directory to be used as the location to create the
|
|
access method database files. When <see cref="M:BerkeleyDB.BTreeDatabase.Open(System.String,BerkeleyDB.BTreeDatabaseConfig)"/>,
|
|
<see cref="M:BerkeleyDB.HashDatabase.Open(System.String,BerkeleyDB.HashDatabaseConfig)"/>, <see cref="M:BerkeleyDB.QueueDatabase.Open(System.String,BerkeleyDB.QueueDatabaseConfig)"/> or
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is used to create a file it will be
|
|
created relative to this path.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This path must also exist in <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.DataDirs"/>.
|
|
</para>
|
|
<para>
|
|
If no database directory is specified, database files must be named
|
|
either by absolute paths or relative to the environment home
|
|
directory. See Berkeley DB File Naming in the Programmer's Reference
|
|
Guide for more information.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseEnvironmentConfig.SetEncryption(System.String,BerkeleyDB.EncryptionAlgorithm)">
|
|
<summary>
|
|
Set the password and algorithm used by the Berkeley DB library to
|
|
perform encryption and decryption.
|
|
</summary>
|
|
<param name="password">
|
|
The password used to perform encryption and decryption.
|
|
</param>
|
|
<param name="alg">
|
|
The algorithm used to perform encryption and decryption.
|
|
</param>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.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>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.MessagePrefix">
|
|
<summary>
|
|
The prefix string that appears before informational messages issued
|
|
by Berkeley DB.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
For databases opened inside of a DatabaseEnvironment, setting
|
|
MessagePrefix affects the entire environment and is equivalent to
|
|
setting <see cref="P:BerkeleyDB.DatabaseEnvironment.MessagePrefix"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.IntermediateDirMode">
|
|
<summary>
|
|
The permissions for any intermediate directories created by Berkeley
|
|
DB.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
By default, Berkeley DB does not create intermediate directories
|
|
needed for recovery, that is, if the file /a/b/c/mydatabase is being
|
|
recovered, and the directory path b/c does not exist, recovery will
|
|
fail. This default behavior is because Berkeley DB does not know
|
|
what permissions are appropriate for intermediate directory
|
|
creation, and creating the directory might result in a security
|
|
problem.
|
|
</para>
|
|
<para>
|
|
Directory permissions are interpreted as a string of nine
|
|
characters, using the character set r (read), w (write), x (execute
|
|
or search), and - (none). The first character is the read
|
|
permissions for the directory owner (set to either r or -). The
|
|
second character is the write permissions for the directory owner
|
|
(set to either w or -). The third character is the execute
|
|
permissions for the directory owner (set to either x or -).
|
|
</para>
|
|
<para>
|
|
Similarly, the second set of three characters are the read, write
|
|
and execute/search permissions for the directory group, and the
|
|
third set of three characters are the read, write and execute/search
|
|
permissions for all others. For example, the string rwx------ would
|
|
configure read, write and execute/search access for the owner only.
|
|
The string rwxrwx--- would configure read, write and execute/search
|
|
access for both the owner and the group. The string rwxr----- would
|
|
configure read, write and execute/search access for the directory
|
|
owner and read-only access for the directory group.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TempDir">
|
|
<summary>
|
|
The path of a directory to be used as the location of temporary
|
|
files.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The files created to back in-memory access method databases will be
|
|
created relative to this path. These temporary files can be quite
|
|
large, depending on the size of the database.
|
|
</para>
|
|
<para>
|
|
If no directories are specified, the following alternatives are
|
|
checked in the specified order. The first existing directory path is
|
|
used for all temporary files.
|
|
</para>
|
|
<list type="number">
|
|
<item>The value of the environment variable TMPDIR.</item>
|
|
<item>The value of the environment variable TEMP.</item>
|
|
<item>The value of the environment variable TMP.</item>
|
|
<item>The value of the environment variable TempFolder.</item>
|
|
<item>The value returned by the GetTempPath interface.</item>
|
|
<item>The directory /var/tmp.</item>
|
|
<item>The directory /usr/tmp.</item>
|
|
<item>The directory /temp.</item>
|
|
<item>The directory /tmp.</item>
|
|
<item>The directory C:/temp.</item>
|
|
<item>The directory C:/tmp.</item>
|
|
</list>
|
|
<para>
|
|
Environment variables are only checked if
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseEnvironmentVars"/> is true.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Verbosity">
|
|
<summary>
|
|
Specific additional informational and debugging messages in the
|
|
Berkeley DB message output.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.AutoCommit">
|
|
<summary>
|
|
If true, database operations for which no explicit transaction
|
|
handle was specified, and which modify databases in the database
|
|
environment, will be automatically enclosed within a transaction.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.CDB_ALLDB">
|
|
<summary>
|
|
If true, Berkeley DB Concurrent Data Store applications will perform
|
|
locking on an environment-wide basis rather than on a per-database
|
|
basis.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.ForceFlush">
|
|
<summary>
|
|
If true, Berkeley DB will flush database writes to the backing disk
|
|
before returning from the write system call, rather than flushing
|
|
database writes explicitly in a separate system call, as necessary.
|
|
</summary>
|
|
<remarks>
|
|
This is only available on some systems (for example, systems
|
|
supporting the IEEE/ANSI Std 1003.1 (POSIX) standard O_DSYNC flag,
|
|
or systems supporting the Windows FILE_FLAG_WRITE_THROUGH flag).
|
|
This flag may result in inaccurate file modification times and other
|
|
file-level information for Berkeley DB database files. This flag
|
|
will almost certainly result in a performance decrease on most
|
|
systems. This flag is only applicable to certain filesysystems (for
|
|
example, the Veritas VxFS filesystem), where the filesystem's
|
|
support for trickling writes back to stable storage behaves badly
|
|
(or more likely, has been misconfigured).
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.InitRegions">
|
|
<summary>
|
|
If true, Berkeley DB will page-fault shared regions into memory when
|
|
initially creating or joining a Berkeley DB environment. In
|
|
addition, Berkeley DB will write the shared regions when creating an
|
|
environment, forcing the underlying virtual memory and filesystems
|
|
to instantiate both the necessary memory and the necessary disk
|
|
space. This can also avoid out-of-disk space failures later on.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
In some applications, the expense of page-faulting the underlying
|
|
shared memory regions can affect performance. (For example, if the
|
|
page-fault occurs while holding a lock, other lock requests can
|
|
convoy, and overall throughput may decrease.)
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoBuffer">
|
|
<summary>
|
|
If true, turn off system buffering of Berkeley DB database files to
|
|
avoid double caching.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoLocking">
|
|
<summary>
|
|
If true, Berkeley DB will grant all requested mutual exclusion
|
|
mutexes and database locks without regard for their actual
|
|
availability. This functionality should never be used for purposes
|
|
other than debugging.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoMMap">
|
|
<summary>
|
|
If true, Berkeley DB will copy read-only database files into the
|
|
local cache instead of potentially mapping them into process memory
|
|
(see <see cref="P:BerkeleyDB.MPoolConfig.MMapSize"/> for further information).
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.NoPanic">
|
|
<summary>
|
|
If true, Berkeley DB will ignore any panic state in the database
|
|
environment. (Database environments in a panic state normally refuse
|
|
all attempts to call Berkeley DB functions, throwing
|
|
<see cref="T:BerkeleyDB.RunRecoveryException"/>. This functionality should never
|
|
be used for purposes other than debugging.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Overwrite">
|
|
<summary>
|
|
If true, overwrite files stored in encrypted formats before deleting
|
|
them.
|
|
</summary>
|
|
<remarks>
|
|
Berkeley DB overwrites files using alternating 0xff, 0x00 and 0xff
|
|
byte patterns. For file overwriting to be effective, the underlying
|
|
file must be stored on a fixed-block filesystem. Systems with
|
|
journaling or logging filesystems will require operating system
|
|
support and probably modification of the Berkeley DB sources.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted">
|
|
<summary>
|
|
If true, database calls timing out based on lock or transaction
|
|
timeout values will throw <see cref="T:BerkeleyDB.LockNotGrantedException"/>
|
|
instead of <see cref="T:BerkeleyDB.DeadlockException"/>. This allows applications
|
|
to distinguish between operations which have deadlocked and
|
|
operations which have exceeded their time limits.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoSync">
|
|
<summary>
|
|
If true, Berkeley DB will not write or synchronously flush the log
|
|
on transaction commit.
|
|
</summary>
|
|
<remarks>
|
|
This means that transactions exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability); that
|
|
is, database integrity will be maintained, but if the application or
|
|
system fails, it is possible some number of the most recently
|
|
committed transactions may be undone during recovery. The number of
|
|
transactions at risk is governed by how many log updates can fit
|
|
into the log buffer, how often the operating system flushes dirty
|
|
buffers to disk, and how often the log is checkpointed.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnNoWait">
|
|
<summary>
|
|
If true and a lock is unavailable for any Berkeley DB operation
|
|
performed in the context of a transaction, cause the operation to
|
|
throw <see cref="T:BerkeleyDB.DeadlockException"/> (or
|
|
<see cref="T:BerkeleyDB.LockNotGrantedException"/> if
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted"/> is set.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnSnapshot">
|
|
<summary>
|
|
If true, all transactions in the environment will be started as if
|
|
<see cref="F:BerkeleyDB.TransactionConfig.Snapshot"/> were passed to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/>, and all
|
|
non-transactional cursors will be opened as if
|
|
<see cref="F:BerkeleyDB.CursorConfig.SnapshotIsolation"/> were passed to
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.TxnWriteNoSync">
|
|
<summary>
|
|
If true, Berkeley DB will write, but will not synchronously flush,
|
|
the log on transaction commit.
|
|
</summary>
|
|
<remarks>
|
|
This means that transactions exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability); that
|
|
is, database integrity will be maintained, but if the system fails,
|
|
it is possible some number of the most recently committed
|
|
transactions may be undone during recovery. The number of
|
|
transactions at risk is governed by how often the system flushes
|
|
dirty buffers to disk and how often the log is checkpointed.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseMVCC">
|
|
<summary>
|
|
If true, all databases in the environment will be opened as if
|
|
<see cref="F:BerkeleyDB.DatabaseConfig.UseMVCC"/> is passed to
|
|
<see cref="M:BerkeleyDB.Database.Open(System.String,BerkeleyDB.DatabaseConfig)"/>. This flag will be ignored for queue
|
|
databases for which MVCC is not supported.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.YieldCPU">
|
|
<summary>
|
|
If true, Berkeley DB will yield the processor immediately after each
|
|
page or mutex acquisition. This functionality should never be used
|
|
for purposes other than stress testing.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Create">
|
|
<summary>
|
|
If true, Berkeley DB subsystems will create any underlying files, as
|
|
necessary.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.FreeThreaded">
|
|
<summary>
|
|
If true, the created <see cref="T:BerkeleyDB.DatabaseEnvironment"/> object will
|
|
be free-threaded; that is, concurrently usable by multiple threads
|
|
in the address space.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Required to be true if the created <see cref="T:BerkeleyDB.DatabaseEnvironment"/>
|
|
object will be concurrently used by more than one thread in the
|
|
process, or if any <see cref="T:BerkeleyDB.Database"/> objects opened in the
|
|
scope of the <see cref="T:BerkeleyDB.DatabaseEnvironment"/> object will be
|
|
concurrently used by more than one thread in the process.
|
|
</para>
|
|
<para>Required to be true when using the Replication Manager.</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Lockdown">
|
|
<summary>
|
|
If true, lock shared Berkeley DB environment files and memory-mapped
|
|
databases into memory.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Private">
|
|
<summary>
|
|
If true, allocate region memory from the heap instead of from memory
|
|
backed by the filesystem or system shared memory.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This setting implies the environment will only be accessed by a
|
|
single process (although that process may be multithreaded). This
|
|
flag has two effects on the Berkeley DB environment. First, all
|
|
underlying data structures are allocated from per-process memory
|
|
instead of from shared memory that is accessible to more than a
|
|
single process. Second, mutexes are only configured to work between
|
|
threads.
|
|
</para>
|
|
<para>
|
|
This setting should be false if more than a single process is
|
|
accessing the environment because it is likely to cause database
|
|
corruption and unpredictable behavior. For example, if both a server
|
|
application and Berkeley DB utilities (for example, db_archive,
|
|
db_checkpoint or db_stat) are expected to access the environment,
|
|
this setting should be false.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.Register">
|
|
<summary>
|
|
If true, check to see if recovery needs to be performed before
|
|
opening the database environment. (For this check to be accurate,
|
|
all processes using the environment must specify it when opening the
|
|
environment.)
|
|
</summary>
|
|
<remarks>
|
|
If recovery needs to be performed for any reason (including the
|
|
initial use of this setting), and <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery"/>is also
|
|
specified, recovery will be performed and the open will proceed
|
|
normally. If recovery needs to be performed and
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery"/> is not specified,
|
|
<see cref="T:BerkeleyDB.RunRecoveryException"/> will be thrown. If recovery does
|
|
not need to be performed, <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery"/> will be ignored.
|
|
See Architecting Transactional Data Store applications in the
|
|
Programmer's Reference Guide for more information.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.RunFatalRecovery">
|
|
<summary>
|
|
If true, catastrophic recovery will be run on this environment
|
|
before opening it for normal use.
|
|
</summary>
|
|
<remarks>
|
|
If true, the <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.Create"/> and <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/> must
|
|
also be set, because the regions will be removed and re-created,
|
|
and transactions are required for application recovery.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.RunRecovery">
|
|
<summary>
|
|
If true, normal recovery will be run on this environment before
|
|
opening it for normal use.
|
|
</summary>
|
|
<remarks>
|
|
If true, the <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.Create"/> and <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/> must
|
|
also be set, because the regions will be removed and re-created,
|
|
and transactions are required for application recovery.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.SystemMemory">
|
|
<summary>
|
|
If true, allocate region memory from system shared memory instead of
|
|
from heap memory or memory backed by the filesystem.
|
|
</summary>
|
|
<remarks>
|
|
See Shared Memory Regions in the Programmer's Reference Guide for
|
|
more information.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseEnvironmentVars">
|
|
<summary>
|
|
If true, the Berkeley DB process' environment may be permitted to
|
|
specify information to be used when naming files.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
See Berkeley DB File Naming in the Programmer's Reference Guide for
|
|
more information.
|
|
</para>
|
|
<para>
|
|
Because permitting users to specify which files are used can create
|
|
security problems, environment information will be used in file
|
|
naming for all users only if UseEnvironmentVars is true.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseCDB">
|
|
<summary>
|
|
If true, initialize locking for the Berkeley DB Concurrent Data
|
|
Store product.
|
|
</summary>
|
|
<remarks>
|
|
In this mode, Berkeley DB provides multiple reader/single writer
|
|
access. The only other subsystem that should be specified with
|
|
UseCDB flag is <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseMPool"/>.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLocking">
|
|
<summary>
|
|
If true, initialize the locking subsystem.
|
|
</summary>
|
|
<remarks>
|
|
This subsystem should be used when multiple processes or threads are
|
|
going to be reading and writing a Berkeley DB database, so that they
|
|
do not interfere with each other. If all threads are accessing the
|
|
database(s) read-only, locking is unnecessary. When UseLocking is
|
|
specified, it is usually necessary to run a deadlock detector, as
|
|
well. See <see cref="M:BerkeleyDB.DatabaseEnvironment.DetectDeadlocks(BerkeleyDB.DeadlockPolicy)"/> for more
|
|
information.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLogging">
|
|
<summary>
|
|
If true, initialize the logging subsystem.
|
|
</summary>
|
|
<remarks>
|
|
This subsystem should be used when recovery from application or
|
|
system failure is necessary. If the log region is being created and
|
|
log files are already present, the log files are reviewed;
|
|
subsequent log writes are appended to the end of the log, rather
|
|
than overwriting current log entries.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseMPool">
|
|
<summary>
|
|
If true, initialize the shared memory buffer pool subsystem.
|
|
</summary>
|
|
<remarks>
|
|
This subsystem should be used whenever an application is using any
|
|
Berkeley DB access method.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseReplication">
|
|
<summary>
|
|
If true, initialize the replication subsystem.
|
|
</summary>
|
|
<remarks>
|
|
This subsystem should be used whenever an application plans on using
|
|
replication. UseReplication requires <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns"/> and
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLocking"/> also be set.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseEnvironmentConfig.UseTxns">
|
|
<summary>
|
|
If true, initialize the transaction subsystem.
|
|
</summary>
|
|
<remarks>
|
|
This subsystem should be used when recovery and atomicity of
|
|
multiple operations are important. UseTxns implies
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.UseLogging"/>.
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironmentConfig.EncryptionPassword">
|
|
<summary>
|
|
The password used to perform encryption and decryption.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironmentConfig.EncryptAlgorithm">
|
|
<summary>
|
|
The algorithm used to perform encryption and decryption.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironmentConfig.LockTimeout">
|
|
<summary>
|
|
A value, in microseconds, representing lock timeouts.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
All timeouts are checked whenever a thread of control blocks on a
|
|
lock or when deadlock detection is performed. As timeouts are only
|
|
checked when the lock request first blocks or when deadlock
|
|
detection is performed, the accuracy of the timeout depends on how
|
|
often deadlock detection is performed.
|
|
</para>
|
|
<para>
|
|
Timeout values specified for the database environment may be
|
|
overridden on a per-transaction basis, see
|
|
<see cref="M:BerkeleyDB.Transaction.SetLockTimeout(System.UInt32)"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironmentConfig.MaxTransactions">
|
|
<summary>
|
|
The number of active transactions supported by the environment. This
|
|
value bounds the size of the memory allocated for transactions.
|
|
Child transactions are counted as active until they either commit or
|
|
abort.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Transactions that update multiversion databases are not freed until
|
|
the last page version that the transaction created is flushed from
|
|
cache. This means that applications using multi-version concurrency
|
|
control may need a transaction for each page in cache, in the
|
|
extreme case.
|
|
</para>
|
|
<para>
|
|
When all of the memory available in the database environment for
|
|
transactions is in use, calls to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.BeginTransaction"/> will fail (until
|
|
some active transactions complete). If MaxTransactions is never set,
|
|
the database environment is configured to support at least 100
|
|
active transactions.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironmentConfig.ThreadCount">
|
|
<summary>
|
|
An approximate number of threads in the database environment.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
ThreadCount must set if <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>
|
|
will be used. ThreadCount does not set the maximum number of threads
|
|
but is used to determine memory sizing and the thread control block
|
|
reclamation policy.
|
|
</para>
|
|
<para>
|
|
If a process has not configured <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadIsAlive"/>, and
|
|
then attempts to join a database environment configured for failure
|
|
checking with <see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/>,
|
|
<see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.SetThreadID"/>, <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.ThreadIsAlive"/> and
|
|
ThreadCount, the program may be unable to allocate a thread control
|
|
block and fail to join the environment. This is true of the
|
|
standalone Berkeley DB utility programs. To avoid problems when
|
|
using the standalone Berkeley DB utility programs with environments
|
|
configured for failure checking, incorporate the utility's
|
|
functionality directly in the application, or call
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.FailCheck"/> before running the
|
|
utility.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironmentConfig.TxnTimeout">
|
|
<summary>
|
|
A value, in microseconds, representing transaction timeouts.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
All timeouts are checked whenever a thread of control blocks on a
|
|
lock or when deadlock detection is performed. As timeouts are only
|
|
checked when the lock request first blocks or when deadlock
|
|
detection is performed, the accuracy of the timeout depends on how
|
|
often deadlock detection is performed.
|
|
</para>
|
|
<para>
|
|
Timeout values specified for the database environment may be
|
|
overridden on a per-transaction basis, see
|
|
<see cref="M:BerkeleyDB.Transaction.SetTxnTimeout(System.UInt32)"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.DatabaseEnvironmentConfig.TxnTimestamp">
|
|
<summary>
|
|
Recover to the time specified by timestamp rather than to the most
|
|
current possible date.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Once a database environment has been upgraded to a new version of
|
|
Berkeley DB involving a log format change (see Upgrading Berkeley DB
|
|
installations in the Programmer's Reference Guide), it is no longer
|
|
possible to recover to a specific time before that upgrade.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryBTreeDatabase">
|
|
<summary>
|
|
A class representing a SecondaryBTreeDatabase. The Btree format is a
|
|
representation of a sorted, balanced tree structure.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryBTreeDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryBTreeDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new SecondaryBTreeDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryBTreeDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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.SecondaryBTreeDatabase.Open(System.String,System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new SecondaryBTreeDatabase object, open the
|
|
database represented by <paramref name="Filename"/> and associate
|
|
the database with the
|
|
<see cref="P:BerkeleyDB.SecondaryDatabaseConfig.Primary">primary index</see>.
|
|
</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="P:BerkeleyDB.SecondaryBTreeDatabase.Compare">
|
|
<summary>
|
|
The Btree 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.SecondaryBTreeDatabase.DupCompare">
|
|
<summary>
|
|
The duplicate data item comparison function.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryBTreeDatabase.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.SecondaryBTreeDatabase.MinKeysPerPage">
|
|
<summary>
|
|
The minimum number of key/data pairs intended to be stored on any
|
|
single Btree leaf page.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryBTreeDatabase.ReverseSplit">
|
|
<summary>
|
|
If false, empty pages will not be coalesced into higher-level pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryBTreeDatabase.PrefixCompare">
|
|
<summary>
|
|
The Btree prefix function. The prefix function is used to determine
|
|
the amount by which keys stored on the Btree internal pages can be
|
|
safely truncated without losing their uniqueness.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryBTreeDatabase.RecordNumbers">
|
|
<summary>
|
|
If true, this object supports retrieval from the Btree using record
|
|
numbers.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.CreatePolicy">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CreatePolicy.NEVER">
|
|
<summary>
|
|
Never create the database.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CreatePolicy.IF_NEEDED">
|
|
<summary>
|
|
Create the database if it does not already exist.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CreatePolicy.ALWAYS">
|
|
<summary>
|
|
Do not open the database and return an error if it already exists.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DatabaseFeedbackEvent">
|
|
<summary>
|
|
Specifies the database operation whose progress is being reported
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseFeedbackEvent.UPGRADE">
|
|
<summary>
|
|
The underlying database is being upgraded.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseFeedbackEvent.VERIFY">
|
|
<summary>
|
|
The underlying database is being verified.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DuplicatesPolicy">
|
|
<summary>
|
|
Policy for duplicate data items in the database; that is, whether insertion
|
|
when the key of the key/data pair being inserted already exists in the
|
|
database will be successful.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DuplicatesPolicy.NONE">
|
|
<summary>
|
|
Insertion when the key of the key/data pair being inserted already
|
|
exists in the database will fail.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DuplicatesPolicy.SORTED">
|
|
<summary>
|
|
Duplicates are allowed and mainted in sorted order, as determined by the
|
|
duplicate comparison function.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DuplicatesPolicy.UNSORTED">
|
|
<summary>
|
|
Duplicates are allowed and ordered in the database by the order of
|
|
insertion, unless the ordering is otherwise specified by use of a cursor
|
|
operation or a duplicate sort function.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.EncryptionAlgorithm">
|
|
<summary>
|
|
Specifies an algorithm used for encryption and decryption
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.EncryptionAlgorithm.DEFAULT">
|
|
<summary>
|
|
The default algorithm, or the algorithm previously used in an
|
|
existing environment
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.EncryptionAlgorithm.AES">
|
|
<summary>
|
|
The Rijndael/AES algorithm
|
|
</summary>
|
|
<remarks>
|
|
Also known as the Advanced Encryption Standard and Federal
|
|
Information Processing Standard (FIPS) 197
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.EnvironmentFeedbackEvent">
|
|
<summary>
|
|
Specifies the environment operation whose progress is being reported
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.EnvironmentFeedbackEvent.RECOVERY">
|
|
<summary>
|
|
The environment is being recovered.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ForeignKeyDeleteAction">
|
|
<summary>
|
|
Specifies the action to take when deleting a foreign key
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ForeignKeyDeleteAction.ABORT">
|
|
<summary>
|
|
Abort the deletion.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ForeignKeyDeleteAction.CASCADE">
|
|
<summary>
|
|
Delete records that refer to the foreign key
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.ForeignKeyDeleteAction.NULLIFY">
|
|
<summary>
|
|
Nullify records that refer to the foreign key
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.Isolation">
|
|
<summary>
|
|
Specify the degree of isolation for transactional operations
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Isolation.DEGREE_ONE">
|
|
<summary>
|
|
Read operations on the database may request the return of modified
|
|
but not yet committed data.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Isolation.DEGREE_TWO">
|
|
<summary>
|
|
Provide for cursor stability but not repeatable reads. Data items
|
|
which have been previously read by a transaction may be deleted or
|
|
modified by other transactions before the original transaction
|
|
completes.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.Isolation.DEGREE_THREE">
|
|
<summary>
|
|
For the life of the transaction, every time a thread of control
|
|
reads a data item, it will be unchanged from its previous value
|
|
(assuming, of course, the thread of control does not itself modify
|
|
the item). This is Berkeley DB's default degree of isolation.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.NotificationEvent">
|
|
<summary>
|
|
Specify a Berkeley DB event
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.PANIC">
|
|
<summary>
|
|
The database environment has failed.
|
|
</summary>
|
|
<remarks>
|
|
All threads of control in the database environment should exit the
|
|
environment, and recovery should be run.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.REP_CLIENT">
|
|
<summary>
|
|
The local site is now a replication client.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.REP_ELECTED">
|
|
<summary>
|
|
The local replication site has just won an election.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
An application using the Base replication API should arrange for a
|
|
call to
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/> after
|
|
receiving this event, to reconfigure the local environment as a
|
|
replication master.
|
|
</para>
|
|
<para>
|
|
Replication Manager applications may safely ignore this event. The
|
|
Replication Manager calls
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.RepStartMaster"/>
|
|
automatically on behalf of the application when appropriate
|
|
(resulting in firing of the <see cref="F:BerkeleyDB.NotificationEvent.REP_MASTER"/> event).
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.REP_MASTER">
|
|
<summary>
|
|
The local site is now the master site of its replication group. It
|
|
is the application's responsibility to begin acting as the master
|
|
environment.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER">
|
|
<summary>
|
|
The replication group of which this site is a member has just
|
|
established a new master; the local site is not the new master. The
|
|
event_info parameter to the <see cref="T:BerkeleyDB.EventNotifyDelegate"/>
|
|
stores an integer containing the environment ID of the new master.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.REP_PERM_FAILED">
|
|
<summary>
|
|
The replication manager did not receive enough acknowledgements
|
|
(based on the acknowledgement policy configured with
|
|
<see cref="F:BerkeleyDB.ReplicationConfig.RepMgrAckPolicy"/>) to ensure a
|
|
transaction's durability within the replication group. The
|
|
transaction will be flushed to the master's local disk storage for
|
|
durability.
|
|
</summary>
|
|
<remarks>
|
|
This event is provided only to applications configured for the
|
|
replication manager.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.REP_STARTUPDONE">
|
|
<summary>
|
|
The client has completed startup synchronization and is now
|
|
processing live log records received from the master.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.NotificationEvent.WRITE_FAILED">
|
|
<summary>
|
|
A Berkeley DB write to stable storage failed.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DeadlockPolicy">
|
|
<summary>
|
|
A class to represent what lock request(s) should be rejected during
|
|
deadlock resolution.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.DEFAULT">
|
|
<summary>
|
|
If no DeadlockPolicy has yet been specified, use
|
|
<see cref="F:BerkeleyDB.DeadlockPolicy.RANDOM"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.EXPIRE">
|
|
<summary>
|
|
Reject lock requests which have timed out. No other deadlock
|
|
detection is performed.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.MAX_LOCKS">
|
|
<summary>
|
|
Reject the lock request for the locker ID with the most locks.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.MAX_WRITE">
|
|
<summary>
|
|
Reject the lock request for the locker ID with the most write locks.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.MIN_LOCKS">
|
|
<summary>
|
|
Reject the lock request for the locker ID with the fewest locks.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.MIN_WRITE">
|
|
<summary>
|
|
Reject the lock request for the locker ID with the fewest write
|
|
locks.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.OLDEST">
|
|
<summary>
|
|
Reject the lock request for the locker ID with the oldest lock.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.RANDOM">
|
|
<summary>
|
|
Reject the lock request for a random locker ID.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DeadlockPolicy.YOUNGEST">
|
|
<summary>
|
|
Reject the lock request for the locker ID with the youngest lock.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.CacheInfo">
|
|
<summary>
|
|
A class to represent information about the Berkeley DB cache
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CacheInfo.Gigabytes">
|
|
<summary>
|
|
The number of gigabytes in the cache
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CacheInfo.Bytes">
|
|
<summary>
|
|
The number of bytes in the cache
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.CacheInfo.NCaches">
|
|
<summary>
|
|
The number of caches
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.CacheInfo.#ctor(System.UInt32,System.UInt32,System.Int32)">
|
|
<summary>
|
|
Create a new CacheInfo object. The size of the cache is set to
|
|
gbytes gigabytes plus bytes and spread over numCaches separate
|
|
caches.
|
|
</summary>
|
|
<param name="gbytes">The number of gigabytes in the cache</param>
|
|
<param name="bytes">The number of bytes in the cache</param>
|
|
<param name="numCaches">The number of caches</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.Sequence">
|
|
<summary>
|
|
A class that provides an arbitrary number of persistent objects that
|
|
return an increasing or decreasing sequence of integers.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.#ctor(BerkeleyDB.SequenceConfig)">
|
|
<summary>
|
|
Instantiate a new Sequence object.
|
|
</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="cfg">Configuration parameters for the Sequence</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.#ctor(BerkeleyDB.SequenceConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new Sequence object.
|
|
</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="cfg">Configuration parameters for the Sequence</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.Sequence.Close">
|
|
<summary>
|
|
Close the sequence handle. Any unused cached values are lost.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Get(System.Int32)">
|
|
<summary>
|
|
Return the next available element in the sequence and change the
|
|
sequence value by <paramref name="Delta"/>.
|
|
</summary>
|
|
<overloads>
|
|
<para>
|
|
If there are enough cached values in the sequence handle then they
|
|
will be returned. Otherwise the next value will be fetched from the
|
|
database and incremented (decremented) by enough to cover the delta
|
|
and the next batch of cached values.
|
|
</para>
|
|
<para>
|
|
For maximum concurrency a non-zero cache size should be specified
|
|
prior to opening the sequence handle and <paramref name="NoSync"/>
|
|
should be specified for each Get method call.
|
|
</para>
|
|
<para>
|
|
By default, sequence ranges do not wrap; to cause the sequence to
|
|
wrap around the beginning or end of its range, set
|
|
<paramref name="SequenceConfig.Wrap"/> to true.
|
|
</para>
|
|
<para>
|
|
If <paramref name="P:BackingDatabase"/> was opened in a transaction,
|
|
calling Get may result in changes to the sequence object; these
|
|
changes will be automatically committed in a transaction internal to
|
|
the Berkeley DB library. If the thread of control calling Get has an
|
|
active transaction, which holds locks on the same database as the
|
|
one in which the sequence object is stored, it is possible for a
|
|
thread of control calling Get to self-deadlock because the active
|
|
transaction's locks conflict with the internal transaction's locks.
|
|
For this reason, it is often preferable for sequence objects to be
|
|
stored in their own database.
|
|
</para>
|
|
</overloads>
|
|
<param name="Delta">
|
|
The amount by which to increment the sequence value. Must be
|
|
greater than 0.
|
|
</param>
|
|
<returns>The next available element in the sequence.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Get(System.Int32,System.Boolean)">
|
|
<summary>
|
|
Return the next available element in the sequence and change the
|
|
sequence value by <paramref name="Delta"/>.
|
|
</summary>
|
|
<param name="Delta">
|
|
The amount by which to increment the sequence value. Must be
|
|
greater than 0.
|
|
</param>
|
|
<param name="NoSync">
|
|
If true, and if the operation is implicitly transaction protected,
|
|
do not synchronously flush the log when the transaction commits.
|
|
</param>
|
|
<returns>The next available element in the sequence.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Get(System.Int32,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Return the next available element in the sequence and change the
|
|
sequence value by <paramref name="Delta"/>.
|
|
</summary>
|
|
<param name="Delta">
|
|
The amount by which to increment the sequence value. Must be
|
|
greater than 0.
|
|
</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.
|
|
Must be null if the sequence was opened with a non-zero cache size.
|
|
</param>
|
|
<returns>The next available element in the sequence.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.PrintStats">
|
|
<summary>
|
|
Print diagnostic information.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.PrintStats(System.Boolean)">
|
|
<summary>
|
|
Print diagnostic information.
|
|
</summary>
|
|
<overloads>
|
|
The diagnostic information is described by
|
|
<see cref="T:BerkeleyDB.SequenceStats"/>.
|
|
</overloads>
|
|
<param name="ClearStats">
|
|
If true, reset statistics after printing.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Remove">
|
|
<summary>
|
|
Remove the sequence from the database.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Remove(System.Boolean)">
|
|
<summary>
|
|
Remove the sequence from the database.
|
|
</summary>
|
|
<param name="NoSync">
|
|
If true, and if the operation is implicitly transaction protected,
|
|
do not synchronously flush the log when the transaction commits.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Remove(BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Remove the sequence from 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>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Stats">
|
|
<summary>
|
|
Return statistical information for this sequence.
|
|
</summary>
|
|
<returns>Statistical information for this sequence.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Stats(System.Boolean)">
|
|
<summary>
|
|
Return statistical information for this sequence.
|
|
</summary>
|
|
<overloads>
|
|
<para>
|
|
In the presence of multiple threads or processes accessing an active
|
|
sequence, the information returned by DB_SEQUENCE->stat() may be
|
|
out-of-date.
|
|
</para>
|
|
<para>
|
|
The DB_SEQUENCE->stat() method cannot be transaction-protected. For
|
|
this reason, it should be called in a thread of control that has no
|
|
open cursors or active transactions.
|
|
</para>
|
|
</overloads>
|
|
<param name="clear">If true, reset statistics.</param>
|
|
<returns>Statistical information for this sequence.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.Sequence.Dispose">
|
|
<summary>
|
|
Release the resources held by this object, and close the sequence if
|
|
it's still open.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.BackingDatabase">
|
|
<summary>
|
|
The database used by the sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.Key">
|
|
<summary>
|
|
The key for the sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.Cachesize">
|
|
<summary>
|
|
The current cache size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.Min">
|
|
<summary>
|
|
The minimum value in the sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.Max">
|
|
<summary>
|
|
The maximum value in the sequence.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.Wrap">
|
|
<summary>
|
|
If true, the sequence should wrap around when it is incremented
|
|
(decremented) past the specified maximum (minimum) value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.Increment">
|
|
<summary>
|
|
If true, the sequence will be incremented. This is the default.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.Sequence.Decrement">
|
|
<summary>
|
|
If true, the sequence will be decremented.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.KeyRange">
|
|
<summary>
|
|
<para>
|
|
A class representing an estimate of the proportion of keys that are less
|
|
than, equal to, and greater than a given key.
|
|
</para>
|
|
<para>
|
|
Values are in the range of 0 to 1; for example, if the field less is
|
|
0.05, 5% of the keys in the database are less than the key parameter.
|
|
The value for equal will be zero if there is no matching key, and will
|
|
be non-zero otherwise.
|
|
</para>
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.KeyRange.Less">
|
|
<summary>
|
|
A value between 0 and 1, the proportion of keys less than the
|
|
specified key.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.KeyRange.Equal">
|
|
<summary>
|
|
A value between 0 and 1, the proportion of keys equal to the
|
|
specified key.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.KeyRange.Greater">
|
|
<summary>
|
|
A value between 0 and 1, the proportion of keys greater than the
|
|
specified key.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.MutexStats">
|
|
<summary>
|
|
Statistical information about the mutex subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.Alignment">
|
|
<summary>
|
|
Mutex alignment
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.Available">
|
|
<summary>
|
|
Available mutexes
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.Count">
|
|
<summary>
|
|
Mutex count
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.InUse">
|
|
<summary>
|
|
Mutexes in use
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.MaxInUse">
|
|
<summary>
|
|
Maximum mutexes ever in use
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.RegionNoWait">
|
|
<summary>
|
|
Region lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.RegionSize">
|
|
<summary>
|
|
Region size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.RegionWait">
|
|
<summary>
|
|
Region lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MutexStats.TASSpins">
|
|
<summary>
|
|
Mutex test-and-set spins
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.MPoolConfig">
|
|
<summary>
|
|
A class representing configuration parameters for a
|
|
<see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s memory pool subsystem.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.MPoolConfig.CacheSize">
|
|
<summary>
|
|
The size of the shared memory buffer pool — that is, the cache.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The cache should be the size of the normal working data set of the
|
|
application, with some small amount of additional memory for unusual
|
|
situations. (Note: the working set is not the same as the number of
|
|
pages accessed simultaneously, and is usually much larger.)
|
|
</para>
|
|
<para>
|
|
The default cache size is 256KB, and may not be specified as less
|
|
than 20KB. Any cache size less than 500MB is automatically increased
|
|
by 25% to account for buffer pool overhead; cache sizes larger than
|
|
500MB are used as specified. The maximum size of a single cache is
|
|
4GB on 32-bit systems and 10TB on 64-bit systems. (All sizes are in
|
|
powers-of-two, that is, 256KB is 2^18 not 256,000.) For information
|
|
on tuning the Berkeley DB cache size, see Selecting a cache size in
|
|
the Programmer's Reference Guide.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.MPoolConfig.MaxCacheSize">
|
|
<summary>
|
|
The maximum cache size.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The specified size is rounded to the nearest multiple of the cache
|
|
region size, which is the initial cache size divided by
|
|
<see cref="F:BerkeleyDB.CacheInfo.NCaches">CacheSize.NCaches</see>. If no value
|
|
is specified, it defaults to the initial cache size.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.MPoolConfig.SetMaxSequentialWrites(System.Int32,System.UInt32)">
|
|
<summary>
|
|
Limit the number of sequential write operations scheduled by the
|
|
library when flushing dirty pages from the cache.
|
|
</summary>
|
|
<param name="maxWrites">
|
|
The maximum number of sequential write operations scheduled by the
|
|
library when flushing dirty pages from the cache, or 0 if there is
|
|
no limitation on the number of sequential write operations.
|
|
</param>
|
|
<param name="pause">
|
|
The number of microseconds the thread of control should pause before
|
|
scheduling further write operations. It must be specified as an
|
|
unsigned 32-bit number of microseconds, limiting the maximum pause
|
|
to roughly 71 minutes.
|
|
</param>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolConfig.MaxOpenFiles">
|
|
<summary>
|
|
The number of file descriptors the library will open concurrently
|
|
when flushing dirty pages from the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolConfig.SequentialWritePause">
|
|
<summary>
|
|
The number of microseconds the thread of control should pause before
|
|
scheduling further write operations.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolConfig.MaxSequentialWrites">
|
|
<summary>
|
|
The number of sequential write operations scheduled by the library
|
|
when flushing dirty pages from the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.MPoolConfig.MMapSize">
|
|
<summary>
|
|
The maximum file size, in bytes, for a file to be mapped into the
|
|
process address space. If no value is specified, it defaults to
|
|
10MB.
|
|
</summary>
|
|
<remarks>
|
|
Files that are opened read-only in the cache (and that satisfy a few
|
|
other criteria) are, by default, mapped into the process address
|
|
space instead of being copied into the local cache. This can result
|
|
in better-than-usual performance because available virtual memory is
|
|
normally much larger than the local cache, and page faults are
|
|
faster than page copying on many systems. However, it can cause
|
|
resource starvation in the presence of limited virtual memory, and
|
|
it can result in immense process sizes in the presence of large
|
|
databases.
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.LogConfig">
|
|
<summary>
|
|
A class representing configuration parameters for a
|
|
<see cref="T:BerkeleyDB.DatabaseEnvironment"/>'s logging subsystem.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LogConfig.AutoRemove">
|
|
<summary>
|
|
If true, Berkeley DB will automatically remove log files that are no
|
|
longer needed.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Automatic log file removal is likely to make catastrophic recovery
|
|
impossible.
|
|
</para>
|
|
<para>
|
|
Replication applications will rarely want to configure automatic log
|
|
file removal as it increases the likelihood a master will be unable
|
|
to satisfy a client's request for a recent log record.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LogConfig.ForceSync">
|
|
<summary>
|
|
If true, Berkeley DB will flush log writes to the backing disk
|
|
before returning from the write system call, rather than flushing
|
|
log writes explicitly in a separate system call, as necessary.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This is only available on some systems (for example, systems
|
|
supporting the IEEE/ANSI Std 1003.1 (POSIX) standard O_DSYNC flag,
|
|
or systems supporting the Windows FILE_FLAG_WRITE_THROUGH flag).
|
|
This flag may result in inaccurate file modification times and other
|
|
file-level information for Berkeley DB log files. This flag may
|
|
offer a performance increase on some systems and a performance
|
|
decrease on others.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LogConfig.InMemory">
|
|
<summary>
|
|
If true, maintain transaction logs in memory rather than on disk.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This means that transactions exhibit the ACI (atomicity,
|
|
consistency, and isolation) properties, but not D (durability); that
|
|
is, database integrity will be maintained, but if the application or
|
|
system fails, integrity will not persist. All database files must be
|
|
verified and/or restored from a replication group master or archival
|
|
backup after application or system failure.
|
|
</para>
|
|
<para>
|
|
When in-memory logs are configured and no more log buffer space is
|
|
available, Berkeley DB methods may throw
|
|
<see cref="T:BerkeleyDB.FullLogBufferException"/>. When choosing log buffer and
|
|
file sizes for in-memory logs, applications should ensure the
|
|
in-memory log buffer size is large enough that no transaction will
|
|
ever span the entire buffer, and avoid a state where the in-memory
|
|
buffer is full and no space can be freed because a transaction that
|
|
started in the first log "file" is still active.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LogConfig.NoBuffer">
|
|
<summary>
|
|
If true, turn off system buffering of Berkeley DB log files to avoid
|
|
double caching.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LogConfig.ZeroOnCreate">
|
|
<summary>
|
|
If true, zero all pages of a log file when that log file is created.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This has shown to provide greater transaction throughput in some
|
|
environments. The log file will be zeroed by the thread which needs
|
|
to re-create the new log file. Other threads may not write to the
|
|
log file while this is happening.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LogConfig.Dir">
|
|
<summary>
|
|
The path of a directory to be used as the location of logging files.
|
|
Log files created by the Log Manager subsystem will be created in
|
|
this directory.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If no logging directory is specified, log files are created in the
|
|
environment home directory. See Berkeley DB File Naming in the
|
|
Programmer's Reference Guide for more information.
|
|
</para>
|
|
<para>
|
|
For the greatest degree of recoverability from system or application
|
|
failure, database files and log files should be located on separate
|
|
physical devices.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
Dir must be consistent with the existing environment or corruption
|
|
can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogConfig.BufferSize">
|
|
<summary>
|
|
The size of the in-memory log buffer, in bytes.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
When the logging subsystem is configured for on-disk logging, the
|
|
default size of the in-memory log buffer is approximately 32KB. Log
|
|
information is stored in-memory until the storage space fills up or
|
|
transaction commit forces the information to be flushed to stable
|
|
storage. In the presence of long-running transactions or
|
|
transactions producing large amounts of data, larger buffer sizes
|
|
can increase throughput.
|
|
</para>
|
|
<para>
|
|
When the logging subsystem is configured for in-memory logging, the
|
|
default size of the in-memory log buffer is 1MB. Log information is
|
|
stored in-memory until the storage space fills up or transaction
|
|
abort or commit frees up the memory for new transactions. In the
|
|
presence of long-running transactions or transactions producing
|
|
large amounts of data, the buffer size must be sufficient to hold
|
|
all log information that can accumulate during the longest running
|
|
transaction. When choosing log buffer and file sizes for in-memory
|
|
logs, applications should ensure the in-memory log buffer size is
|
|
large enough that no transaction will ever span the entire buffer,
|
|
and avoid a state where the in-memory buffer is full and no space
|
|
can be freed because a transaction that started in the first log
|
|
"file" is still active.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
BufferSize will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogConfig.FileMode">
|
|
<summary>
|
|
The absolute file mode for created log files.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This method is only useful for the rare Berkeley DB application that
|
|
does not control its umask value.
|
|
</para>
|
|
<para>
|
|
Normally, if Berkeley DB applications set their umask appropriately,
|
|
all processes in the application suite will have read permission on
|
|
the log files created by any process in the application suite.
|
|
However, if the Berkeley DB application is a library, a process
|
|
using the library might set its umask to a value preventing other
|
|
processes in the application suite from reading the log files it
|
|
creates. In this rare case, the DB_ENV->set_lg_filemode() method can
|
|
be used to set the mode of created log files to an absolute value.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogConfig.MaxFileSize">
|
|
<summary>
|
|
The maximum size of a single file in the log, in bytes. Because
|
|
<see cref="F:BerkeleyDB.LSN.Offset"/> is an unsigned four-byte value, MaxFileSize
|
|
may not be larger than the maximum unsigned four-byte value.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
When the logging subsystem is configured for on-disk logging, the
|
|
default size of a log file is 10MB.
|
|
</para>
|
|
<para>
|
|
When the logging subsystem is configured for in-memory logging, the
|
|
default size of a log file is 256KB. In addition, the
|
|
<see cref="P:BerkeleyDB.LogConfig.BufferSize">configured log buffer size</see> must be
|
|
larger than the log file size. (The logging subsystem divides memory
|
|
configured for in-memory log records into "files", as database
|
|
environments configured for in-memory log records may exchange log
|
|
records with other members of a replication group, and those members
|
|
may be configured to store log records on-disk.) When choosing log
|
|
buffer and file sizes for in-memory logs, applications should ensure
|
|
the in-memory log buffer size is large enough that no transaction
|
|
will ever span the entire buffer, and avoid a state where the
|
|
in-memory buffer is full and no space can be freed because a
|
|
transaction that started in the first log "file" is still active.
|
|
</para>
|
|
<para>
|
|
See Log File Limits in the Programmer's Reference Guide for more
|
|
information.
|
|
</para>
|
|
<para>
|
|
If no size is specified by the application, the size last specified
|
|
for the database region will be used, or if no database region
|
|
previously existed, the default will be used.
|
|
</para></remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogConfig.RegionSize">
|
|
<summary>
|
|
Te size of the underlying logging area of the Berkeley DB
|
|
environment, in bytes.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
By default, or if the value is set to 0, the default size is
|
|
approximately 60KB. The log region is used to store filenames, and
|
|
so may need to be increased in size if a large number of files will
|
|
be opened and registered with the specified Berkeley DB
|
|
environment's log manager.
|
|
</para>
|
|
<para>
|
|
If the database environment already exists when
|
|
<see cref="M:BerkeleyDB.DatabaseEnvironment.Open(System.String,BerkeleyDB.DatabaseEnvironmentConfig)"/> is called, the value of
|
|
RegionSize will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DatabaseException">
|
|
<summary>
|
|
Represents errors that occur during Berkley DB operations.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseException.ErrorCode">
|
|
<summary>
|
|
The underlying error code from the Berkeley DB C library.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseException.ThrowException(System.Int32)">
|
|
<summary>
|
|
Throw an exception which corresponds to the specified Berkeley DB
|
|
error code.
|
|
</summary>
|
|
<param name="err">The Berkeley DB error code</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseException.#ctor(System.Int32)">
|
|
<summary>
|
|
Create a new DatabaseException, encapsulating a specific error code.
|
|
</summary>
|
|
<param name="err">The error code to encapsulate.</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BadSecondaryException">
|
|
<summary>
|
|
A secondary index has been corrupted. This is likely the result of an
|
|
application operating on related databases without first associating
|
|
them.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BadSecondaryException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the BadSecondaryException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.ForeignConflictException">
|
|
<summary>
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.ForeignConflictException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the ForeignConflictException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.FullLogBufferException">
|
|
<summary>
|
|
In-memory logs are configured and no more log buffer space is available.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.FullLogBufferException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the FullLogBufferException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.KeyEmptyException">
|
|
<summary>
|
|
The requested key/data pair logically exists but was never explicitly
|
|
created by the application, or that the requested key/data pair was
|
|
deleted and never re-created. In addition, the Queue access method will
|
|
throw a KeyEmptyException for records that were created as part of a
|
|
transaction that was later aborted and never re-created.
|
|
</summary>
|
|
<remarks>
|
|
The Recno and Queue access methods will automatically create key/data
|
|
pairs under some circumstances.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.KeyEmptyException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the KeyEmptyException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.KeyExistException">
|
|
<summary>
|
|
A key/data pair was inserted into the database using
|
|
<see cref="M:BerkeleyDB.Database.PutNoOverwrite(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> and the key already
|
|
exists in the database, or using
|
|
<see cref="M:BerkeleyDB.BTreeDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> or
|
|
<see cref="M:BerkeleyDB.HashDatabase.PutNoDuplicate(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry)"/> and the key/data
|
|
pair already exists in the database.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.KeyExistException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the KeyExistException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DeadlockException">
|
|
<summary>
|
|
When multiple threads of control are modifying the database, there is
|
|
normally the potential for deadlock. In Berkeley DB, deadlock is
|
|
signified by a DeadlockException thrown from the Berkeley DB function.
|
|
Whenever a Berkeley DB function throws a DeadlockException, the
|
|
enclosing transaction should be aborted.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DeadlockException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the DeadlockException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.LeaseExpiredException">
|
|
<summary>
|
|
The site's replication master lease has expired.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.LeaseExpiredException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the LeaseExpiredException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.LockNotGrantedException">
|
|
<summary>
|
|
If <see cref="F:BerkeleyDB.DatabaseEnvironmentConfig.TimeNotGranted"/> is true,
|
|
database calls timing out based on lock or transaction timeout values
|
|
will throw a LockNotGrantedException, instead of a DeadlockException.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.LockNotGrantedException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the LockNotGrantedException
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.MemoryException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the MemoryException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.NotFoundException">
|
|
<summary>
|
|
The requested key/data pair did not exist in the database or that
|
|
start-of- or end-of-file has been reached by a cursor.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.NotFoundException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the NotFoundException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.OldVersionException">
|
|
<summary>
|
|
This version of Berkeley DB is unable to upgrade a given database.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.OldVersionException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the OldVersionException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.PageNotFoundException">
|
|
<summary>
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.PageNotFoundException.#ctor">
|
|
<summary>
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RunRecoveryException">
|
|
<summary>
|
|
Berkeley DB has encountered an error it considers fatal to an entire
|
|
environment. Once a RunRecoveryException has been thrown by any
|
|
interface, it will be returned from all subsequent Berkeley DB calls
|
|
made by any threads of control participating in the environment.
|
|
</summary>
|
|
<remarks>
|
|
An example of this type of fatal error is a corrupted database page. The
|
|
only way to recover from this type of error is to have all threads of
|
|
control exit the Berkeley DB environment, run recovery of the
|
|
environment, and re-enter Berkeley DB. (It is not strictly necessary
|
|
that the processes exit, although that is the only way to recover system
|
|
resources, such as file descriptors and memory, allocated by
|
|
Berkeley DB.)
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RunRecoveryException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the RunRecoveryException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.VerificationException">
|
|
<summary>
|
|
Thrown by <see cref="M:BerkeleyDB.Database.Verify(System.String,BerkeleyDB.DatabaseConfig)"/> if a database is
|
|
corrupted, and by <see cref="M:BerkeleyDB.Database.Salvage(System.String,BerkeleyDB.DatabaseConfig)"/> if all
|
|
key/data pairs in the file may not have been successfully output.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.VerificationException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the VerificationException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.VersionMismatchException">
|
|
<summary>
|
|
The version of the Berkeley DB library doesn't match the version that
|
|
created the database environment.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.VersionMismatchException.#ctor">
|
|
<summary>
|
|
Initialize a new instance of the VersionMismatchException
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DbThreadID">
|
|
<summary>
|
|
A class representing a unique identifier for a thread of control in a
|
|
Berkeley DB application.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DbThreadID.processID">
|
|
<summary>
|
|
The Process ID of the thread of control
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DbThreadID.threadID">
|
|
<summary>
|
|
The Thread ID of the thread of control
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DbThreadID.#ctor(System.Int32,System.UInt32)">
|
|
<summary>
|
|
Instantiate a new DbThreadID object
|
|
</summary>
|
|
<param name="pid">The Process ID of the thread of control</param>
|
|
<param name="tid">The Thread ID of the thread of control</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.MultipleKeyDatabaseEntry">
|
|
<summary>
|
|
A class providing access to multiple key/data pairs.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.MultipleKeyDatabaseEntry.GetEnumerator">
|
|
<summary>
|
|
Return an enumerator which iterates over all
|
|
<see cref="T:BerkeleyDB.DatabaseEntry"/> pairs represented by the
|
|
<see cref="T:BerkeleyDB.MultipleKeyDatabaseEntry"/>.
|
|
</summary>
|
|
<returns>
|
|
An enumerator for the <see cref="T:BerkeleyDB.MultipleDatabaseEntry"/>
|
|
</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryBTreeDatabaseConfig">
|
|
<summary>
|
|
A class representing configuration parameters for
|
|
<see cref="T:BerkeleyDB.SecondaryBTreeDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Duplicates">
|
|
<summary>
|
|
Policy for duplicate data items in the database; that is, insertion
|
|
when the key of the key/data pair being inserted already exists in
|
|
the database will be successful.
|
|
</summary>
|
|
<remarks>
|
|
<para>The ordering of duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> is determined by the order
|
|
of insertion, unless the ordering is otherwise specified by use of a
|
|
cursor operation or a duplicate sort function. The ordering of
|
|
duplicates in the database for
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is determined by the
|
|
duplicate comparison function. If the application does not specify a
|
|
comparison function using
|
|
<see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.DuplicateCompare"/>, a default lexical
|
|
comparison will be used.
|
|
</para>
|
|
<para>
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/> is preferred to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> for performance reasons.
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.UNSORTED"/> should only be used by
|
|
applications wanting to order duplicate data items manually.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the value of Duplicates must be the
|
|
same as the existing database or an error will be returned.
|
|
</para>
|
|
<para>
|
|
It is an error to specify <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.UseRecordNumbers"/> and
|
|
anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.NoReverseSplitting">
|
|
<summary>
|
|
Turn reverse splitting in the Btree on or off.
|
|
</summary>
|
|
<remarks>
|
|
As pages are emptied in a database, the Berkeley DB Btree
|
|
implementation attempts to coalesce empty pages into higher-level
|
|
pages in order to keep the database as small as possible and
|
|
minimize search time. This can hurt performance in applications with
|
|
cyclical data demands; that is, applications where the database
|
|
grows and shrinks repeatedly. For example, because Berkeley DB does
|
|
page-level locking, the maximum level of concurrency in a database
|
|
of two pages is far smaller than that in a database of 100 pages, so
|
|
a database that has shrunk to a minimal size can cause severe
|
|
deadlocking when a new cycle of data insertion begins.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.UseRecordNumbers">
|
|
<summary>
|
|
If true, support retrieval from the Btree using record numbers.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
Logical record numbers in Btree databases are mutable in the face of
|
|
record insertion or deletion. See
|
|
<see cref="F:BerkeleyDB.RecnoDatabaseConfig.Renumber"/> for further discussion.
|
|
</para>
|
|
<para>
|
|
Maintaining record counts within a Btree introduces a serious point
|
|
of contention, namely the page locations where the record counts are
|
|
stored. In addition, the entire database must be locked during both
|
|
insertions and deletions, effectively single-threading the database
|
|
for those operations. Specifying UseRecordNumbers can result in
|
|
serious performance degradation for some applications and data sets.
|
|
</para>
|
|
<para>
|
|
It is an error to specify <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.UseRecordNumbers"/> and
|
|
anything other than <see cref="F:BerkeleyDB.DuplicatesPolicy.NONE"/>.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the value of UseRecordNumbers must
|
|
be the same as the existing database or an error will be returned.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Creation">
|
|
<summary>
|
|
The policy for how to handle database creation.
|
|
</summary>
|
|
<remarks>
|
|
If the database does not already exist and
|
|
<see cref="F:BerkeleyDB.CreatePolicy.NEVER"/> is set,
|
|
<see cref="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)"/> will fail.
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Compare">
|
|
<summary>
|
|
The Btree key comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
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.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the keys are compared
|
|
lexically, with shorter keys collating before longer keys.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the comparison function must be the
|
|
same as that historically used to create the database or corruption
|
|
can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.PrefixCompare">
|
|
<summary>
|
|
The Btree prefix function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The prefix function is used to determine the amount by which keys
|
|
stored on the Btree internal pages can be safely truncated without
|
|
losing their uniqueness. See the Btree prefix comparison section of
|
|
the Berkeley DB Reference Guide for more details about how this
|
|
works. The usefulness of this is data-dependent, but can produce
|
|
significantly reduced tree sizes and search times in some data sets.
|
|
</para>
|
|
<para>
|
|
If no prefix function or key comparison function is specified by the
|
|
application, a default lexical comparison function is used as the
|
|
prefix function. If no prefix function is specified and
|
|
<see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Compare"/> is specified, no prefix function is
|
|
used. It is an error to specify a prefix function without also
|
|
specifying <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Compare"/>.
|
|
</para>
|
|
<para>
|
|
If the database already exists, the prefix function must be the
|
|
same as that historically used to create the database or corruption
|
|
can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.DuplicateCompare">
|
|
<summary>
|
|
The duplicate data item comparison function.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The comparison function is called whenever it is necessary to
|
|
compare a data item specified by the application with a data item
|
|
currently stored in the database. Setting DuplicateCompare implies
|
|
setting <see cref="F:BerkeleyDB.SecondaryBTreeDatabaseConfig.Duplicates"/> to
|
|
<see cref="F:BerkeleyDB.DuplicatesPolicy.SORTED"/>.
|
|
</para>
|
|
<para>
|
|
If no comparison function is specified, the data items are compared
|
|
lexically, with shorter data items collating before longer data
|
|
items.
|
|
</para>
|
|
<para>
|
|
If the database already exists when
|
|
<see cref="M:BerkeleyDB.SecondaryBTreeDatabase.Open(System.String,BerkeleyDB.SecondaryBTreeDatabaseConfig)"/> is called, the delegate
|
|
must be the same as that historically used to create the database or
|
|
corruption can occur.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryBTreeDatabaseConfig.#ctor(BerkeleyDB.Database,BerkeleyDB.SecondaryKeyGenDelegate)">
|
|
<summary>
|
|
Create a new SecondaryBTreeDatabaseConfig object
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryBTreeDatabaseConfig.MinKeysPerPage">
|
|
<summary>
|
|
The minimum number of key/data pairs intended to be stored on any
|
|
single Btree leaf page.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
This value is used to determine if key or data items will be stored
|
|
on overflow pages instead of Btree leaf pages. For more information
|
|
on the specific algorithm used, see the Berkeley DB Reference Guide.
|
|
The value specified must be at least 2; if not explicitly set, a
|
|
value of 2 is used.
|
|
</para>
|
|
<para>
|
|
If the database already exists, MinKeysPerPage will be ignored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="T:BerkeleyDB.LogStats">
|
|
<summary>
|
|
Statistical information about the logging subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.BufferSize">
|
|
<summary>
|
|
Log buffer size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.Bytes">
|
|
<summary>
|
|
Bytes to log.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.BytesSinceCheckpoint">
|
|
<summary>
|
|
Bytes to log since checkpoint.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.CurrentFile">
|
|
<summary>
|
|
Current log file number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.CurrentOffset">
|
|
<summary>
|
|
Current log file offset.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.DiskFileNumber">
|
|
<summary>
|
|
Known on disk log file number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.DiskOffset">
|
|
<summary>
|
|
Known on disk log file offset.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.FileSize">
|
|
<summary>
|
|
Log file size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.MBytes">
|
|
<summary>
|
|
Megabytes to log.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.MBytesSinceCheckpoint">
|
|
<summary>
|
|
Megabytes to log since checkpoint.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.MagicNumber">
|
|
<summary>
|
|
Log file magic number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.MaxCommitsPerFlush">
|
|
<summary>
|
|
Max number of commits in a flush.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.MinCommitsPerFlush">
|
|
<summary>
|
|
Min number of commits in a flush.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.OverflowWrites">
|
|
<summary>
|
|
Overflow writes to the log.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.PermissionsMode">
|
|
<summary>
|
|
Log file permissions mode.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.Reads">
|
|
<summary>
|
|
Total I/O reads from the log.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.Records">
|
|
<summary>
|
|
Records entered into the log.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.RegionLockNoWait">
|
|
<summary>
|
|
Region lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.RegionLockWait">
|
|
<summary>
|
|
Region lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.RegionSize">
|
|
<summary>
|
|
Region size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.Syncs">
|
|
<summary>
|
|
Total syncs to the log.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.Writes">
|
|
<summary>
|
|
Total I/O writes to the log.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LogStats.Version">
|
|
<summary>
|
|
Log file version number.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.JoinCursor">
|
|
<summary>
|
|
A class representing a join cursor, for use in performing equality or
|
|
natural joins on secondary indices. For information on how to organize
|
|
your data to use this functionality, see Equality join in the
|
|
Programmer's Reference Guide.
|
|
</summary>
|
|
<remarks>
|
|
JoinCursor does not support many of the operations offered by
|
|
<see cref="T:BerkeleyDB.Cursor"/> and is not a subclass of <see cref="T:BerkeleyDB.Cursor"/>.
|
|
</remarks>
|
|
<seealso cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
|
|
</member>
|
|
<member name="M:BerkeleyDB.JoinCursor.Close">
|
|
<summary>
|
|
<para>
|
|
Discard the cursor.
|
|
</para>
|
|
<para>
|
|
It is possible for the Close() method to throw a
|
|
<see cref="T:BerkeleyDB.DeadlockException"/>, signaling that any enclosing
|
|
transaction should be aborted. If the application is already
|
|
intending to abort the transaction, this error should be ignored,
|
|
and the application should proceed.
|
|
</para>
|
|
<para>
|
|
After Close has been called, regardless of its result, the object
|
|
may not be used again.
|
|
</para>
|
|
</summary>
|
|
<exception cref="T:BerkeleyDB.DeadlockException"></exception>
|
|
</member>
|
|
<member name="M:BerkeleyDB.JoinCursor.Dispose">
|
|
<summary>
|
|
Release the resources held by this object, and close the cursor if
|
|
it's still open.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.JoinCursor.GetEnumerator">
|
|
<summary>
|
|
Returns an enumerator that iterates through the
|
|
<see cref="T:BerkeleyDB.JoinCursor"/>.
|
|
</summary>
|
|
<remarks>
|
|
The enumerator will begin at the cursor's current position (or the
|
|
first record if the cursor has not yet been positioned) and iterate
|
|
forwards (i.e. in the direction of <see cref="M:BerkeleyDB.JoinCursor.MoveNext"/>) over the
|
|
remaining records.
|
|
</remarks>
|
|
<returns>An enumerator for the Cursor.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.JoinCursor.MoveNext">
|
|
<summary>
|
|
Iterate over the values associated with the keys to which each
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
|
|
was initialized. Any data value that appears in all
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/>s is then used as a key into the
|
|
primary, and the key/data pair found in the primary is stored in
|
|
<see cref="P:BerkeleyDB.JoinCursor.Current"/>.
|
|
</summary>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.JoinCursor.MoveNext(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Iterate over the values associated with the keys to which each
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
|
|
was initialized. Any data value that appears in all
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/>s is then used as a key into the
|
|
primary, and the key/data pair found in the primary is stored in
|
|
<see cref="P:BerkeleyDB.JoinCursor.Current"/>.
|
|
</summary>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.JoinCursor.MoveNextItem">
|
|
<summary>
|
|
Iterate over the values associated with the keys to which each
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
|
|
was initialized. Any data value that appears in all
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/>s is then stored in
|
|
<see cref="P:BerkeleyDB.JoinCursor.Current">Current.Key</see>.
|
|
</summary>
|
|
<remarks>
|
|
<see cref="P:BerkeleyDB.JoinCursor.Current">Current.Value</see> will contain an empty
|
|
<see cref="T:BerkeleyDB.DatabaseEntry"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.JoinCursor.MoveNextItem(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Iterate over the values associated with the keys to which each
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/> passed to <see cref="M:BerkeleyDB.Database.Join(BerkeleyDB.SecondaryCursor[],System.Boolean)"/>
|
|
was initialized. Any data value that appears in all
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/>s is then stored in
|
|
<see cref="P:BerkeleyDB.JoinCursor.Current">Current.Key</see>.
|
|
</summary>
|
|
<remarks>
|
|
<see cref="P:BerkeleyDB.JoinCursor.Current">Current.Value</see> will contain an empty
|
|
<see cref="T:BerkeleyDB.DatabaseEntry"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="P:BerkeleyDB.JoinCursor.Current">
|
|
<summary>
|
|
The key/data pair at which the cursor currently points.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.DatabaseType">
|
|
<summary>
|
|
A class representing the supported Berkeley DB access methods.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseType.BTREE">
|
|
<summary>
|
|
BTree access method
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseType.HASH">
|
|
<summary>
|
|
Hash access method
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseType.RECNO">
|
|
<summary>
|
|
Recno access method
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseType.QUEUE">
|
|
<summary>
|
|
Queue access method
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.DatabaseType.UNKNOWN">
|
|
<summary>
|
|
Unknown access method
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.DatabaseType.ToString">
|
|
<summary>
|
|
Convert this instance of DatabaseType to its string representation.
|
|
</summary>
|
|
<returns>A string representation of this instance.</returns>
|
|
</member>
|
|
<member name="T:BerkeleyDB.LockStats">
|
|
<summary>
|
|
Statistical information about the locking subsystem
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LastAllocatedLockerID">
|
|
<summary>
|
|
Last allocated locker ID.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockConflictsWait">
|
|
<summary>
|
|
Lock conflicts w/ subsequent wait
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockConflictsNoWait">
|
|
<summary>
|
|
Lock conflicts w/o subsequent wait
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockDeadlocks">
|
|
<summary>
|
|
Number of lock deadlocks.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockDowngrades">
|
|
<summary>
|
|
Number of lock downgrades.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockModes">
|
|
<summary>
|
|
Number of lock modes.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockPuts">
|
|
<summary>
|
|
Number of lock puts.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockRequests">
|
|
<summary>
|
|
Number of lock gets.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockSteals">
|
|
<summary>
|
|
Number of lock steals so far.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockTimeoutLength">
|
|
<summary>
|
|
Lock timeout.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockTimeouts">
|
|
<summary>
|
|
Number of lock timeouts.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockUpgrades">
|
|
<summary>
|
|
Number of lock upgrades.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockerNoWait">
|
|
<summary>
|
|
Locker lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.LockerWait">
|
|
<summary>
|
|
Locker lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.Lockers">
|
|
<summary>
|
|
Current number of lockers.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.Locks">
|
|
<summary>
|
|
Current number of locks.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxBucketLength">
|
|
<summary>
|
|
Max length of bucket.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxLockSteals">
|
|
<summary>
|
|
Maximum number steals in any partition.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxLockers">
|
|
<summary>
|
|
Maximum number of lockers so far.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxLockersInTable">
|
|
<summary>
|
|
Maximum num of lockers in table.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxLocks">
|
|
<summary>
|
|
Maximum number of locks so far.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxLocksInBucket">
|
|
<summary>
|
|
Maximum number of locks in any bucket.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxLocksInTable">
|
|
<summary>
|
|
Maximum number of locks in table.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxObjectSteals">
|
|
<summary>
|
|
Maximum number of steals in any partition.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxObjects">
|
|
<summary>
|
|
Maximum number of objects so far.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxObjectsInBucket">
|
|
<summary>
|
|
Maximum number of objectsin any bucket.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxPartitionLockNoWait">
|
|
<summary>
|
|
Max partition lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxPartitionLockWait">
|
|
<summary>
|
|
Max partition lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxUnusedID">
|
|
<summary>
|
|
Current maximum unused ID.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.MaxObjectsInTable">
|
|
<summary>
|
|
Maximum num of objects in table.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.nPartitions">
|
|
<summary>
|
|
number of partitions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.ObjectNoWait">
|
|
<summary>
|
|
Object lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.ObjectSteals">
|
|
<summary>
|
|
Number of objects steals so far.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.ObjectWait">
|
|
<summary>
|
|
Object lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.Objects">
|
|
<summary>
|
|
Current number of objects.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.PartitionLockNoWait">
|
|
<summary>
|
|
Partition lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.PartitionLockWait">
|
|
<summary>
|
|
Partition lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.RegionNoWait">
|
|
<summary>
|
|
Region lock granted without wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.RegionSize">
|
|
<summary>
|
|
Region size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.RegionWait">
|
|
<summary>
|
|
Region lock granted after wait.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.TxnTimeoutLength">
|
|
<summary>
|
|
Transaction timeout.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.LockStats.TxnTimeouts">
|
|
<summary>
|
|
Number of transaction timeouts.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.VerboseMessages">
|
|
<summary>
|
|
Enable specific additional informational and debugging messages.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.Deadlock">
|
|
<summary>
|
|
Display additional information when doing deadlock detection.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.FileOps">
|
|
<summary>
|
|
Display additional information when performing filesystem operations
|
|
such as open, close or rename. May not be available on all
|
|
platforms.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.AllFileOps">
|
|
<summary>
|
|
Display additional information when performing all filesystem
|
|
operations, including read and write. May not be available on all
|
|
platforms.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.Recovery">
|
|
<summary>
|
|
Display additional information when performing recovery.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.Register">
|
|
<summary>
|
|
Display additional information concerning support for
|
|
<see cref="P:BerkeleyDB.DatabaseEnvironment.Register"/>
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.Replication">
|
|
<summary>
|
|
Display all detailed information about replication. This includes
|
|
the information displayed by all of the other Replication* and
|
|
RepMgr* values.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.RepMgrConnectionFailure">
|
|
<summary>
|
|
Display detailed information about Replication Manager connection
|
|
failures.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.RepMgrMisc">
|
|
<summary>
|
|
Display detailed information about general Replication Manager
|
|
processing.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.ReplicationElection">
|
|
<summary>
|
|
Display detailed information about replication elections.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.ReplicationLease">
|
|
<summary>
|
|
Display detailed information about replication master leases.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.ReplicationMisc">
|
|
<summary>
|
|
Display detailed information about general replication processing
|
|
not covered by the other Replication* values.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.ReplicationMessages">
|
|
<summary>
|
|
Display detailed information about replication message processing.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.ReplicationSync">
|
|
<summary>
|
|
Display detailed information about replication client
|
|
synchronization.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.ReplicationTest">
|
|
<summary>
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.VerboseMessages.WaitsForTable">
|
|
<summary>
|
|
Display the waits-for table when doing deadlock detection.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.SecondaryCursor">
|
|
<summary>
|
|
A class representing database cursors over secondary indexes, which
|
|
allow for traversal of database records.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.PGet(BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry,System.UInt32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Protected method wrapping DBC->pget()
|
|
</summary>
|
|
<param name="key">The secondary key</param>
|
|
<param name="pkey">The primary key</param>
|
|
<param name="data">The primary data</param>
|
|
<param name="flags">Flags to pass to DBC->pget</param>
|
|
<param name="info">Locking parameters</param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Delete">
|
|
<summary>
|
|
Delete the key/data pair to which the cursor refers from the primary
|
|
database and all secondary indices.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
The cursor position is unchanged after a delete, and subsequent
|
|
calls to cursor functions expecting the cursor to refer to an
|
|
existing key will fail.
|
|
</para>
|
|
</remarks>
|
|
<exception cref="T:BerkeleyDB.KeyEmptyException">
|
|
The element has already been deleted.
|
|
</exception>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Duplicate(System.Boolean)">
|
|
<summary>
|
|
Create a new cursor that uses the same transaction and locker ID as
|
|
the original cursor.
|
|
</summary>
|
|
<remarks>
|
|
This is useful when an application is using locking and requires two
|
|
or more cursors in the same thread of control.
|
|
</remarks>
|
|
<param name="keepPosition">
|
|
If true, the newly created cursor is initialized to refer to the
|
|
same position in the database as the original cursor (if any) and
|
|
hold the same locks (if any). If false, or the original cursor does
|
|
not hold a database position and locks, the created cursor is
|
|
uninitialized and will behave like a cursor newly created by
|
|
<see cref="M:BerkeleyDB.BaseDatabase.Cursor"/>.</param>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.GetEnumerator">
|
|
<summary>
|
|
Returns an enumerator that iterates through the
|
|
<see cref="T:BerkeleyDB.SecondaryCursor"/>.
|
|
</summary>
|
|
<remarks>
|
|
The enumerator will begin at the cursor's current position (or the
|
|
first record if the cursor has not yet been positioned) and iterate
|
|
forwards (i.e. in the direction of <see cref="M:BerkeleyDB.SecondaryCursor.MoveNext"/>) over the
|
|
remaining records.
|
|
</remarks>
|
|
<returns>An enumerator for the SecondaryCursor.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveFirst">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store the secondary key along with the corresponding primary
|
|
key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the first key has
|
|
duplicate values, the first data item in the set of duplicates is
|
|
stored in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveFirst(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the first key/data pair of the database,
|
|
and store the secondary key along with the corresponding primary
|
|
key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the first key has
|
|
duplicate values, the first data item in the set of duplicates is
|
|
stored in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store the
|
|
primary key/data pair associated with the given secondary key in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of duplicate key values, the
|
|
first data item in the set of duplicates is stored in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Move(BerkeleyDB.DatabaseEntry,System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to <paramref name="key"/>, and store the
|
|
primary key/data pair associated with the given secondary key in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of duplicate key values, the
|
|
first data item in the set of duplicates is stored in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="key">The key at which to position the cursor</param>
|
|
<param name="exact">
|
|
If true, require the given key to match the key in the database
|
|
exactly. If false, position the cursor at the smallest key greater
|
|
than or equal to the specified key, permitting partial key matches
|
|
and range searches.
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry}},System.Boolean)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database. The
|
|
cursor is positioned to a key/data pair if both the key and data
|
|
match the values provided on the key and data parameters.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</para>
|
|
<para>
|
|
If this flag is specified on a database configured without sorted
|
|
duplicate support, the value of <paramref name="exact"/> is ignored.
|
|
</para>
|
|
</remarks>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Move(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry}},System.Boolean,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Move the cursor to the specified key/data pair of the database. The
|
|
cursor is positioned to a key/data pair if both the key and data
|
|
match the values provided on the key and data parameters.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</para>
|
|
<para>
|
|
If this flag is specified on a database configured without sorted
|
|
duplicate support, the value of <paramref name="exact"/> is ignored.
|
|
</para>
|
|
</remarks>
|
|
<param name="pair">
|
|
The key/data pair at which to position the cursor.
|
|
</param>
|
|
<param name="exact">
|
|
If true, require the given key and data to match the key and data
|
|
in the database exactly. If false, position the cursor at the
|
|
smallest data value which is greater than or equal to the value
|
|
provided by <paramref name="pair.Value"/> (as determined by the
|
|
comparison function).
|
|
</param>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveLast">
|
|
<summary>
|
|
Set the cursor to refer to the last key/data pair of the database,
|
|
and store the secondary key and primary key/data pair in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the last key has duplicate values, the
|
|
last data item in the set of duplicates is stored in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveLast(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Set the cursor to refer to the last key/data pair of the database,
|
|
and store the secondary key and primary key/data pair in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. If the last key has duplicate values, the
|
|
last data item in the set of duplicates is stored in
|
|
<see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveNext">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNext is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
|
|
key/data pair of the database, and store the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of
|
|
duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">Current.Key
|
|
</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveNext(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNext is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
|
|
key/data pair of the database, and store the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of
|
|
duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">Current.Key
|
|
</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveNextDuplicate">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store the secondary key and primary
|
|
key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextDuplicate will
|
|
return false if the next key/data pair of the database is not a
|
|
duplicate data record for the current key/data pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveNextDuplicate(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the next key/data pair of the database is a duplicate data record
|
|
for the current key/data pair, move the cursor to the next key/data
|
|
pair in the database, and store the secondary key and primary
|
|
key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextDuplicate will
|
|
return false if the next key/data pair of the database is not a
|
|
duplicate data record for the current key/data pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveNextUnique">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUnique is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
|
|
non-duplicate key in the database, and store the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextUnique will
|
|
return false if no non-duplicate key/data pairs exist after the
|
|
cursor position in the database.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MoveNextUnique(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MoveNextUnique is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveFirst"/>. Otherwise, move the cursor to the next
|
|
non-duplicate key in the database, and store the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MoveNextUnique will
|
|
return false if no non-duplicate key/data pairs exist after the
|
|
cursor position in the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If the database is a Queue or Recno database, MoveNextUnique will
|
|
ignore any keys that exist but were never explicitly created by the
|
|
application, or those that were created and later deleted.
|
|
</para>
|
|
<para>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</para>
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MovePrev">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrev is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveLast"/>. Otherwise, move the cursor to the previous
|
|
key/data pair of the database, and store the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the presence of
|
|
duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">Current.Key
|
|
</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MovePrev(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrev is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
|
|
the previous key/data pair of the database, and store the secondary
|
|
key and primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. In the
|
|
presence of duplicate key values, the value of <see cref="P:BerkeleyDB.SecondaryCursor.Current">
|
|
Current.Key</see> may not change.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MovePrevDuplicate">
|
|
<summary>
|
|
If the previous key/data pair of the database is a duplicate data
|
|
record for the current key/data pair, the cursor is moved to the
|
|
previous key/data pair of the database, and the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MovePrevDuplicate
|
|
will return false if the previous key/data pair of the database is
|
|
not a duplicate data record for the current key/data pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MovePrevDuplicate(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the previous key/data pair of the database is a duplicate data
|
|
record for the current key/data pair, the cursor is moved to the
|
|
previous key/data pair of the database, and the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MovePrevDuplicate
|
|
will return false if the previous key/data pair of the database is
|
|
not a duplicate data record for the current key/data pair.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MovePrevUnique">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrevUnique is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveLast"/>. Otherwise, move the cursor to the previous
|
|
non-duplicate key in the database, and store the secondary key and
|
|
primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>. MovePrevUnique will
|
|
return false if no non-duplicate key/data pairs exist after the
|
|
cursor position in the database.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.MovePrevUnique(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
If the cursor is not yet initialized, MovePrevUnique is identical to
|
|
<see cref="M:BerkeleyDB.SecondaryCursor.MoveLast(BerkeleyDB.LockingInfo)"/>. Otherwise, move the cursor to
|
|
the previous non-duplicate key in the database, and store the
|
|
secondary key and primary key/data pair in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
MovePrevUnique will return false if no non-duplicate key/data pairs
|
|
exist after the cursor position in the database.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Refresh">
|
|
<summary>
|
|
Store the secondary key and primary key/data pair to which the
|
|
cursor refers in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.SecondaryCursor.Refresh(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Store the secondary key and primary key/data pair to which the
|
|
cursor refers in <see cref="P:BerkeleyDB.SecondaryCursor.Current"/>.
|
|
</summary>
|
|
<remarks>
|
|
If positioning the cursor fails, <see cref="P:BerkeleyDB.SecondaryCursor.Current"/> will contain
|
|
an empty <see cref="T:System.Collections.Generic.KeyValuePair`2"/>.
|
|
</remarks>
|
|
<param name="info">The locking behavior to use.</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="P:BerkeleyDB.SecondaryCursor.Current">
|
|
<summary>
|
|
The secondary key and primary key/data pair at which the cursor
|
|
currently points.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RecnoStats">
|
|
<summary>
|
|
Statistical information about a RecnoDatabase
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.MagicNumber">
|
|
<summary>
|
|
Magic number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.Version">
|
|
<summary>
|
|
Version number.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.MetadataFlags">
|
|
<summary>
|
|
Metadata flags.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.nKeys">
|
|
<summary>
|
|
Number of unique keys.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.nData">
|
|
<summary>
|
|
Number of data items.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.nPages">
|
|
<summary>
|
|
Page count.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.PageSize">
|
|
<summary>
|
|
Page size.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.MinKey">
|
|
<summary>
|
|
Minkey value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.nBlobRecords">
|
|
<summary>
|
|
Number of blobs.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.RecordLength">
|
|
<summary>
|
|
Fixed-length record length.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.RecordPadByte">
|
|
<summary>
|
|
Fixed-length record pad.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.Levels">
|
|
<summary>
|
|
Tree levels.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.InternalPages">
|
|
<summary>
|
|
Internal pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.LeafPages">
|
|
<summary>
|
|
Leaf pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.DuplicatePages">
|
|
<summary>
|
|
Duplicate pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.OverflowPages">
|
|
<summary>
|
|
Overflow pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.EmptyPages">
|
|
<summary>
|
|
Empty pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.FreePages">
|
|
<summary>
|
|
Pages on the free list.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.InternalPagesFreeBytes">
|
|
<summary>
|
|
Bytes free in internal pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.LeafPagesFreeBytes">
|
|
<summary>
|
|
Bytes free in leaf pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.DuplicatePagesFreeBytes">
|
|
<summary>
|
|
Bytes free in duplicate pages.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoStats.OverflowPagesFreeBytes">
|
|
<summary>
|
|
Bytes free in overflow pages.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.BTreeCursor">
|
|
<summary>
|
|
A class for traversing the records of a <see cref="T:BerkeleyDB.BTreeDatabase"/>
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.Duplicate(System.Boolean)">
|
|
<summary>
|
|
Create a new cursor that uses the same transaction and locker ID as
|
|
the original cursor.
|
|
</summary>
|
|
<remarks>
|
|
This is useful when an application is using locking and requires two
|
|
or more cursors in the same thread of control.
|
|
</remarks>
|
|
<param name="keepPosition">
|
|
If true, the newly created cursor is initialized to refer to the
|
|
same position in the database as the original cursor (if any) and
|
|
hold the same locks (if any). If false, or the original cursor does
|
|
not hold a database position and locks, the created cursor is
|
|
uninitialized and will behave like a cursor newly created by
|
|
<see cref="M:BerkeleyDB.BTreeDatabase.Cursor"/>.</param>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.Move(System.UInt32)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.Move(System.UInt32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair in <see cref="P:BerkeleyDB.Cursor.Current"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<param name="info">The locking behavior to use</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many duplicate data items that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32,System.Int32)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many duplicate data items that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many duplicate data items that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<param name="info">The locking behavior to use</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultiple(System.UInt32,System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many duplicate data items that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultiple"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with duplicate data items. Must be at
|
|
least the page size of the underlying database and be a multiple of
|
|
1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32,System.Int32)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<param name="info">The locking behavior to use</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.MoveMultipleKey(System.UInt32,System.Int32,BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Position the cursor at a specific key/data pair in the database, and
|
|
store the key/data pair and as many ensuing key/data pairs that can
|
|
fit in a buffer the size of one database page in
|
|
<see cref="P:BerkeleyDB.Cursor.CurrentMultipleKey"/>.
|
|
</summary>
|
|
<param name="recno">
|
|
The specific numbered record of the database at which to position
|
|
the cursor.
|
|
</param>
|
|
<param name="BufferSize">
|
|
The size of a buffer to fill with key/data pairs. Must be at least
|
|
the page size of the underlying database and be a multiple of 1024.
|
|
</param>
|
|
<param name="info">The locking behavior to use</param>
|
|
<returns>
|
|
True if the cursor was positioned successfully, false otherwise.
|
|
</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.Recno">
|
|
<summary>
|
|
Return the record number associated with the cursor's current
|
|
position.
|
|
</summary>
|
|
<returns>The record number associated with the cursor.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.Recno(BerkeleyDB.LockingInfo)">
|
|
<summary>
|
|
Return the record number associated with the cursor's current
|
|
position.
|
|
</summary>
|
|
<param name="info">The locking behavior to use</param>
|
|
<returns>The record number associated with the cursor.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.Insert(BerkeleyDB.DatabaseEntry,BerkeleyDB.Cursor.InsertLocation)">
|
|
<summary>
|
|
Insert the data element as a duplicate element of the key to which
|
|
the cursor refers.
|
|
</summary>
|
|
<param name="data">The data element to insert</param>
|
|
<param name="loc">
|
|
Specify whether to insert the data item immediately before or
|
|
immediately after the cursor's current position.
|
|
</param>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.AddUnique(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry})">
|
|
<summary>
|
|
Insert the specified key/data pair into the database, unless a
|
|
key/data pair comparing equally to it already exists in the
|
|
database.
|
|
</summary>
|
|
<param name="pair">The key/data pair to be inserted</param>
|
|
<exception cref="T:BerkeleyDB.KeyExistException">
|
|
Thrown if a matching key/data pair already exists in the database.
|
|
</exception>
|
|
</member>
|
|
<member name="M:BerkeleyDB.BTreeCursor.Add(System.Collections.Generic.KeyValuePair{BerkeleyDB.DatabaseEntry,BerkeleyDB.DatabaseEntry},BerkeleyDB.Cursor.InsertLocation)">
|
|
<summary>
|
|
Insert the specified key/data pair into the database.
|
|
</summary>
|
|
<param name="pair">The key/data pair to be inserted</param>
|
|
<param name="loc">
|
|
If the key already exists in the database and no duplicate sort
|
|
function has been specified, specify whether the inserted data item
|
|
is added as the first or the last of the data items for that key.
|
|
</param>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RecnoDatabase">
|
|
<summary>
|
|
A class representing a RecnoDatabase. The Recno format supports fixed-
|
|
or variable-length records, accessed sequentially or by logical record
|
|
number, and optionally backed by a flat text file.
|
|
</summary>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new RecnoDatabase 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.RecnoDatabase.Open(System.String,System.String,BerkeleyDB.RecnoDatabaseConfig)">
|
|
<summary>
|
|
Instantiate a new RecnoDatabase 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.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new RecnoDatabase 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.RecnoDatabase.Open(System.String,System.String,BerkeleyDB.RecnoDatabaseConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Instantiate a new RecnoDatabase 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.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)">
|
|
<summary>
|
|
Append the data item to the end of the database.
|
|
</summary>
|
|
<param name="data">The data item to store in the database</param>
|
|
<returns>The record number allocated to the record</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Append the data item to the end of the database.
|
|
</summary>
|
|
<remarks>
|
|
There is a minor behavioral difference between
|
|
<see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> and
|
|
<see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>. If a transaction enclosing an
|
|
Append operation aborts, the record number may be reallocated in a
|
|
subsequent <see cref="M:BerkeleyDB.RecnoDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation, but it will
|
|
not be reallocated in a subsequent
|
|
<see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/> operation.
|
|
</remarks>
|
|
<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>
|
|
<returns>The record number allocated to the record</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig)">
|
|
<summary>
|
|
Compact the database, and optionally return unused database pages to
|
|
the underlying filesystem.
|
|
</summary>
|
|
<remarks>
|
|
If the operation occurs in a transactional database, the operation
|
|
will be implicitly transaction protected using multiple
|
|
transactions. These transactions will be periodically committed to
|
|
avoid locking large sections of the tree. Any deadlocks encountered
|
|
cause the compaction operation to be retried from the point of the
|
|
last transaction commit.
|
|
</remarks>
|
|
<param name="cdata">Compact configuration parameters</param>
|
|
<returns>Compact operation statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabase.Compact(BerkeleyDB.CompactConfig,BerkeleyDB.Transaction)">
|
|
<summary>
|
|
Compact the database, and optionally return unused database pages to
|
|
the underlying filesystem.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
If <paramref name="txn"/> is non-null, then the operation is
|
|
performed using that transaction. In this event, large sections of
|
|
the tree may be locked during the course of the transaction.
|
|
</para>
|
|
<para>
|
|
If <paramref name="txn"/> is null, but the operation occurs in a
|
|
transactional database, the operation will be implicitly transaction
|
|
protected using multiple transactions. These transactions will be
|
|
periodically committed to avoid locking large sections of the tree.
|
|
Any deadlocks encountered cause the compaction operation to be
|
|
retried from the point of the last transaction commit.
|
|
</para>
|
|
</remarks>
|
|
<param name="cdata">Compact configuration parameters</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>Compact operation statistics</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabase.Cursor">
|
|
<summary>
|
|
Create a database cursor.
|
|
</summary>
|
|
<returns>A newly created cursor</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabase.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.RecnoDatabase.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.RecnoDatabase.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.RecnoDatabase.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.RecnoDatabase.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.RecnoDatabase.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.RecnoDatabase.Stats">
|
|
<summary>
|
|
Return the database statistical information for this database.
|
|
</summary>
|
|
<returns>Database statistical information.</returns>
|
|
</member>
|
|
<member name="M:BerkeleyDB.RecnoDatabase.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.RecnoDatabase.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="M:BerkeleyDB.RecnoDatabase.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.RecnoDatabase.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="P:BerkeleyDB.RecnoDatabase.AppendCallback">
|
|
<summary>
|
|
A function to call after the record number has been selected but
|
|
before the data has been stored into the database.
|
|
</summary>
|
|
<remarks>
|
|
<para>
|
|
When using <see cref="M:BerkeleyDB.QueueDatabase.Append(BerkeleyDB.DatabaseEntry)"/>, it may be useful to
|
|
modify the stored data based on the generated key. If a delegate is
|
|
specified, it will be called after the record number has been
|
|
selected, but before the data has been stored.
|
|
</para>
|
|
</remarks>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabase.RecordDelimiter">
|
|
<summary>
|
|
The delimiting byte used to mark the end of a record in
|
|
<see cref="P:BerkeleyDB.RecnoDatabase.SourceFile"/>.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabase.RecordLength">
|
|
<summary>
|
|
If using fixed-length, not byte-delimited records, the length of the
|
|
records.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabase.RecordPad">
|
|
<summary>
|
|
The padding character for short, fixed-length records.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabase.Renumber">
|
|
<summary>
|
|
If true, the logical record numbers are mutable, and change as
|
|
records are added to and deleted from the database.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabase.Snapshot">
|
|
<summary>
|
|
If true, any <see cref="P:BerkeleyDB.RecnoDatabase.SourceFile"/> file will be read in its
|
|
entirety when <see cref="M:BerkeleyDB.RecnoDatabase.Open(System.String,BerkeleyDB.RecnoDatabaseConfig)"/> is called. If false,
|
|
<see cref="P:BerkeleyDB.RecnoDatabase.SourceFile"/> may be read lazily.
|
|
</summary>
|
|
</member>
|
|
<member name="P:BerkeleyDB.RecnoDatabase.SourceFile">
|
|
<summary>
|
|
The underlying source file for the Recno access method.
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.LockingInfo">
|
|
<summary>
|
|
A class representing the locking options for Berkeley DB operations.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LockingInfo.IsolationDegree">
|
|
<summary>
|
|
The isolation degree of the operation.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.LockingInfo.ReadModifyWrite">
|
|
<summary>
|
|
If true, acquire write locks instead of read locks when doing a
|
|
read, if locking is configured.
|
|
</summary>
|
|
<remarks>
|
|
Setting ReadModifyWrite can eliminate deadlock during a
|
|
read-modify-write cycle by acquiring the write lock during the read
|
|
part of the cycle so that another thread of control acquiring a read
|
|
lock for the same item, in its own read-modify-write cycle, will not
|
|
result in deadlock.
|
|
</remarks>
|
|
</member>
|
|
<member name="M:BerkeleyDB.LockingInfo.#ctor">
|
|
<summary>
|
|
Instantiate a new LockingInfo object
|
|
</summary>
|
|
</member>
|
|
<member name="T:BerkeleyDB.RepMgrSite">
|
|
<summary>
|
|
A class representing a replication site used by Replication Manager
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepMgrSite.EId">
|
|
<summary>
|
|
Environment ID assigned by the replication manager. This is the same
|
|
value that is passed to
|
|
<see cref="P:BerkeleyDB.DatabaseEnvironment.EventNotify"/> for the
|
|
<see cref="F:BerkeleyDB.NotificationEvent.REP_NEWMASTER"/> event.
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepMgrSite.Address">
|
|
<summary>
|
|
The address of the site
|
|
</summary>
|
|
</member>
|
|
<member name="F:BerkeleyDB.RepMgrSite.isConnected">
|
|
<summary>
|
|
If true, the site is connected.
|
|
</summary>
|
|
</member>
|
|
</members>
|
|
</doc>
|