/// <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="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="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="DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
/// </param>
/// <returns>A new, open database object</returns>
public static new Database Open(string Filename,
string DatabaseName, DatabaseConfig cfg, Transaction txn)
{
Database ret;
BaseDatabase db = BaseDatabase.Open(
Filename, DatabaseName, cfg, txn);
switch (db.Type.getDBTYPE())
{
case DBTYPE.DB_BTREE:
ret = new BTreeDatabase(db);
break;
case DBTYPE.DB_HASH:
ret = new HashDatabase(db);
break;
case DBTYPE.DB_QUEUE:
ret = new QueueDatabase(db);
break;
case DBTYPE.DB_RECNO:
ret = new RecnoDatabase(db);
break;
default:
throw new DatabaseException(0);
}
db.Dispose();
ret.isOpen = true;
return(ret);
}
/// <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="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="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="DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
/// </param>
/// <returns>A new, open database object</returns>
public static QueueDatabase Open(
string Filename, QueueDatabaseConfig cfg, Transaction txn)
{
QueueDatabase ret = new QueueDatabase(cfg.Env, 0);
ret.Config(cfg);
ret.db.open(Transaction.getDB_TXN(txn),
Filename, null, DBTYPE.DB_QUEUE, cfg.openFlags, 0);
ret.isOpen = true;
return(ret);
}
public static void Confirm(XmlElement xmlElem,
QueueDatabase queueDB, bool compulsory)
{
DatabaseTest.Confirm(xmlElem, queueDB, compulsory);
// Confirm queue database specific field/property
Configuration.ConfirmUint(xmlElem, "ExtentSize",
queueDB.ExtentSize, compulsory);
Configuration.ConfirmBool(xmlElem, "ConsumeInOrder",
queueDB.InOrder, compulsory);
Configuration.ConfirmInt(xmlElem, "PadByte",
queueDB.PadByte, compulsory);
Assert.AreEqual(DatabaseType.QUEUE, queueDB.Type);
string type = queueDB.Type.ToString();
Assert.IsNotNull(type);
}
/// <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 be replicated to client
/// sites in any replication group.
/// </para>
/// <para>
/// If <paramref name="txn"/> is null, but
/// <see cref="DatabaseConfig.AutoCommit"/> is set, the operation
/// is implicitly transaction protected. Transactionally
/// protected operations on a database object requires the object itself
/// be transactionally protected during its open. The
/// transaction must be committed before the object is closed.
/// </para>
/// </remarks>
/// <param name="Filename">
/// The name of an underlying file 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="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="DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
/// </param>
/// <returns>A new, open database object</returns>
public static new Database Open(string Filename,
string DatabaseName, DatabaseConfig cfg, Transaction txn)
{
Database ret;
BaseDatabase db = BaseDatabase.Open(
Filename, DatabaseName, cfg, txn);
switch (db.Type.getDBTYPE()) {
case DBTYPE.DB_BTREE:
ret = new BTreeDatabase(db);
break;
case DBTYPE.DB_HASH:
ret = new HashDatabase(db);
break;
case DBTYPE.DB_HEAP:
ret = new HeapDatabase(db);
break;
case DBTYPE.DB_QUEUE:
ret = new QueueDatabase(db);
break;
case DBTYPE.DB_RECNO:
ret = new RecnoDatabase(db);
break;
default:
throw new DatabaseException(0);
}
db.Dispose();
ret.isOpen = true;
return ret;
}
public void PutRecordCase1(QueueDatabase db, Transaction txn)
{
byte[] bigArray = new byte[4000];
for (int i = 1; i <= 100; i++)
{
if (txn == null)
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes(i)));
else
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes(i)), txn);
}
DatabaseEntry key = new DatabaseEntry(BitConverter.GetBytes((int)100));
for (int i = 100; i <= 500; i++)
{
if (txn == null)
db.Put(key, new DatabaseEntry(bigArray));
else
db.Put(key, new DatabaseEntry(bigArray), txn);
}
}
/// <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="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="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="DatabaseEnvironment.BeginCDSGroup"/>; otherwise null.
/// </param>
/// <returns>A new, open database object</returns>
public static QueueDatabase Open(
string Filename, QueueDatabaseConfig cfg, Transaction txn)
{
QueueDatabase ret = new QueueDatabase(cfg.Env, 0);
ret.Config(cfg);
ret.db.open(Transaction.getDB_TXN(txn),
Filename, null, DBTYPE.DB_QUEUE, cfg.openFlags, 0);
ret.isOpen = true;
return ret;
}
