/// <summary>
/// Protected method to configure the DB. Only valid before DB->open.
/// </summary>
/// <param name="cfg">Configuration parameters.</param>
protected void Config(SecondaryDatabaseConfig cfg) {
base.Config(cfg);
KeyGen = cfg.KeyGen;
Nullifier = cfg.ForeignKeyNullfier;
db.set_flags(cfg.flags);
}
/// <summary>
/// Protected method to configure the DB. Only valid before DB->open.
/// </summary>
/// <param name="cfg">Configuration parameters.</param>
protected void Config(SecondaryDatabaseConfig cfg)
{
base.Config(cfg);
KeyGen = cfg.KeyGen;
Nullifier = cfg.ForeignKeyNullfier;
db.set_flags(cfg.flags);
}
public static void Confirm(XmlElement xmlElement,
SecondaryDatabaseConfig secDBConfig,
bool compulsory)
{
Configuration.ConfirmBool(xmlElement, "ImmutableKey",
secDBConfig.ImmutableKey, compulsory);
Configuration.ConfirmBool(xmlElement, "Populate",
secDBConfig.Populate, compulsory);
}
public virtual void TestConfig()
{
testName = "TestConfig";
SetUpTest(true);
string dbFileName = testHome + "/" + testName;
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
// Open a primary btree database.
BTreeDatabaseConfig btreeDBConfig =
new BTreeDatabaseConfig();
btreeDBConfig.Creation = CreatePolicy.IF_NEEDED;
BTreeDatabase btreeDB = BTreeDatabase.Open(
dbFileName, btreeDBConfig);
SecondaryDatabaseConfig secDBConfig =
new SecondaryDatabaseConfig(btreeDB, null);
Config(xmlElem, ref secDBConfig, true);
Confirm(xmlElem, secDBConfig, true);
btreeDB.Close();
}
/// <summary>
/// Instantiate a new SecondaryDatabase object, open the database
/// represented by <paramref name="Filename"/> and associate the
/// database with the <see cref="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="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.
/// </para>
/// </remarks>
/// <param name="Filename">
/// The name of an underlying file 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="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 SecondaryDatabase Open(string Filename,
string DatabaseName, SecondaryDatabaseConfig cfg, Transaction txn)
{
if (cfg.DbType == DatabaseType.BTREE)
{
return(SecondaryBTreeDatabase.Open(Filename,
DatabaseName, (SecondaryBTreeDatabaseConfig)cfg, txn));
}
else if (cfg.DbType == DatabaseType.HASH)
{
return(SecondaryHashDatabase.Open(Filename,
DatabaseName, (SecondaryHashDatabaseConfig)cfg, txn));
}
SecondaryDatabase ret = new SecondaryDatabase(cfg.Env, 0);
ret.Config(cfg);
ret.db.open(Transaction.getDB_TXN(txn), Filename,
DatabaseName, cfg.DbType.getDBTYPE(), cfg.openFlags, 0);
ret.doAssocRef = new BDB_AssociateDelegate(doAssociate);
cfg.Primary.db.associate(Transaction.getDB_TXN(txn),
ret.db, ret.doAssocRef, cfg.assocFlags);
if (cfg.ForeignKeyDatabase != null)
{
if (cfg.OnForeignKeyDelete == ForeignKeyDeleteAction.NULLIFY)
{
ret.doNullifyRef =
new BDB_AssociateForeignDelegate(doNullify);
}
else
{
ret.doNullifyRef = null;
}
cfg.ForeignKeyDatabase.db.associate_foreign(ret.db,
ret.doNullifyRef, cfg.foreignFlags);
}
return(ret);
}
/// <summary>
/// Instantiate a new SecondaryDatabase object, open the database
/// represented by <paramref name="Filename"/> and associate the
/// database with the <see cref="SecondaryDatabaseConfig.Primary">
/// primary index</see>. The file specified by
/// <paramref name="Filename"/> must exist.
/// </summary>
/// <remarks>
/// <para>
/// If <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.
/// </para>
/// </remarks>
/// <param name="Filename">
/// The name of an underlying file used to back the
/// database.
/// </param>
/// <param name="cfg">The database's configuration</param>
/// <returns>A new, open database object</returns>
public static SecondaryDatabase Open(
string Filename, SecondaryDatabaseConfig cfg) {
return Open(Filename, null, cfg, null);
}
/// <summary>
/// Instantiate a new SecondaryDatabase object, open the database
/// represented by <paramref name="Filename"/> and associate the
/// database with the <see cref="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="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.
/// </para>
/// </remarks>
/// <param name="Filename">
/// The name of an underlying file 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="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 SecondaryDatabase Open(string Filename,
string DatabaseName, SecondaryDatabaseConfig cfg, Transaction txn) {
if (cfg.DbType == DatabaseType.BTREE) {
return SecondaryBTreeDatabase.Open(Filename,
DatabaseName, (SecondaryBTreeDatabaseConfig)cfg, txn);
} else if (cfg.DbType == DatabaseType.HASH) {
return SecondaryHashDatabase.Open(Filename,
DatabaseName, (SecondaryHashDatabaseConfig)cfg, txn);
}
SecondaryDatabase ret = new SecondaryDatabase(cfg.Env, 0);
ret.Config(cfg);
ret.db.open(Transaction.getDB_TXN(txn), Filename,
DatabaseName, cfg.DbType.getDBTYPE(), cfg.openFlags, 0);
ret.doAssocRef = new BDB_AssociateDelegate(doAssociate);
cfg.Primary.db.associate(Transaction.getDB_TXN(txn),
ret.db, ret.doAssocRef, cfg.assocFlags);
if (cfg.ForeignKeyDatabase != null) {
if (cfg.OnForeignKeyDelete == ForeignKeyDeleteAction.NULLIFY)
ret.doNullifyRef =
new BDB_AssociateForeignDelegate(doNullify);
else
ret.doNullifyRef = null;
cfg.ForeignKeyDatabase.db.associate_foreign(ret.db,
ret.doNullifyRef, cfg.foreignFlags);
}
return ret;
}
/// <summary>
/// Instantiate a new SecondaryDatabase object, open the database
/// represented by <paramref name="Filename"/> and associate the
/// database with the <see cref="SecondaryDatabaseConfig.Primary">
/// primary index</see>. The file specified by
/// <paramref name="Filename"/> must exist.
/// </summary>
/// <remarks>
/// <para>
/// If <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.
/// </para>
/// </remarks>
/// <param name="Filename">
/// The name of an underlying file 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="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 SecondaryDatabase Open(string Filename,
SecondaryDatabaseConfig cfg, Transaction txn) {
return Open(Filename, null, cfg, txn);
}
public void OpenSecQueueDB(string dbFileName,
string dbSecFileName, bool ifDBName)
{
// Open a primary btree database.
BTreeDatabaseConfig primaryDBConfig =
new BTreeDatabaseConfig();
primaryDBConfig.Creation = CreatePolicy.IF_NEEDED;
BTreeDatabase primaryDB;
/*
* If secondary database name is given, the primary
* database is also opened with database name.
*/
if (ifDBName == false)
primaryDB = BTreeDatabase.Open(dbFileName,
primaryDBConfig);
else
primaryDB = BTreeDatabase.Open(dbFileName,
"primary", primaryDBConfig);
try
{
// Open a new secondary database.
SecondaryBTreeDatabaseConfig secBTDBConfig =
new SecondaryBTreeDatabaseConfig(
primaryDB, null);
secBTDBConfig.Creation =
CreatePolicy.IF_NEEDED;
SecondaryBTreeDatabase secBTDB;
if (ifDBName == false)
secBTDB = SecondaryBTreeDatabase.Open(
dbSecFileName, secBTDBConfig);
else
secBTDB = SecondaryBTreeDatabase.Open(
dbSecFileName, "secondary",
secBTDBConfig);
// Close the secondary database.
secBTDB.Close();
// Open the existing secondary database.
SecondaryDatabaseConfig secDBConfig =
new SecondaryDatabaseConfig(
primaryDB, null);
SecondaryDatabase secDB;
if (ifDBName == false)
secDB = SecondaryBTreeDatabase.Open(
dbSecFileName, secDBConfig);
else
secDB = SecondaryBTreeDatabase.Open(
dbSecFileName, "secondary", secDBConfig);
// Close secondary database.
secDB.Close();
}
catch (DatabaseException)
{
throw new TestException();
}
finally
{
// Close primary database.
primaryDB.Close();
}
}
public void OpenSecDBWithinTxn(string home,
string dbFileName, string dbSecFileName, bool ifDbName)
{
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.UseLogging = true;
envConfig.UseLocking = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
// Open a primary btree database.
Transaction openDBTxn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig =
new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
BTreeDatabase db = BTreeDatabase.Open(
dbFileName, dbConfig, openDBTxn);
// Open a secondary btree database.
SecondaryBTreeDatabaseConfig secDBConfig =
new SecondaryBTreeDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secDBConfig.Env = env;
secDBConfig.Creation = CreatePolicy.IF_NEEDED;
SecondaryBTreeDatabase secDB;
if (ifDbName == false)
secDB = SecondaryBTreeDatabase.Open(
dbSecFileName, secDBConfig, openDBTxn);
else
secDB = SecondaryBTreeDatabase.Open(
dbSecFileName, "secondary", secDBConfig,
openDBTxn);
openDBTxn.Commit();
secDB.Close();
// Open the existing secondary database.
Transaction secTxn = env.BeginTransaction();
SecondaryDatabaseConfig secConfig =
new SecondaryDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secConfig.Env = env;
SecondaryDatabase secExDB;
if (ifDbName == false)
secExDB = SecondaryBTreeDatabase.Open(
dbSecFileName, secConfig, secTxn);
else
secExDB = SecondaryBTreeDatabase.Open(
dbSecFileName, "secondary", secConfig,
secTxn);
secExDB.Close();
secTxn.Commit();
db.Close();
env.Close();
}
public void OpenSecRecnoDB(string className,
string funName, string dbFileName, string dbSecFileName,
bool ifDBName)
{
XmlElement xmlElem = Configuration.TestSetUp(
className, funName);
// Open a primary recno database.
RecnoDatabaseConfig primaryDBConfig =
new RecnoDatabaseConfig();
primaryDBConfig.Creation = CreatePolicy.IF_NEEDED;
RecnoDatabase primaryDB;
/*
* If secondary database name is given, the primary
* database is also opened with database name.
*/
if (ifDBName == false)
primaryDB = RecnoDatabase.Open(dbFileName,
primaryDBConfig);
else
primaryDB = RecnoDatabase.Open(dbFileName,
"primary", primaryDBConfig);
try
{
// Open a new secondary database.
SecondaryRecnoDatabaseConfig secRecnoDBConfig =
new SecondaryRecnoDatabaseConfig(
primaryDB, null);
SecondaryRecnoDatabaseConfigTest.Config(
xmlElem, ref secRecnoDBConfig, false);
secRecnoDBConfig.Creation =
CreatePolicy.IF_NEEDED;
SecondaryRecnoDatabase secRecnoDB;
if (ifDBName == false)
secRecnoDB = SecondaryRecnoDatabase.Open(
dbSecFileName, secRecnoDBConfig);
else
secRecnoDB = SecondaryRecnoDatabase.Open(
dbSecFileName, "secondary",
secRecnoDBConfig);
// Close the secondary database.
secRecnoDB.Close();
// Open the existing secondary database.
SecondaryDatabaseConfig secDBConfig =
new SecondaryDatabaseConfig(
primaryDB, null);
SecondaryDatabase secDB;
if (ifDBName == false)
secDB = SecondaryRecnoDatabase.Open(
dbSecFileName, secDBConfig);
else
secDB = SecondaryRecnoDatabase.Open(
dbSecFileName, "secondary", secDBConfig);
// Close secondary database.
secDB.Close();
}
catch (DatabaseException)
{
throw new TestException();
}
finally
{
// Close primary database.
primaryDB.Close();
}
}
public void OpenSecRecnoDBWithinTxn(string className,
string funName, string home, string dbFileName,
string dbSecFileName, bool ifDbName)
{
XmlElement xmlElem = Configuration.TestSetUp(
className, funName);
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.UseLogging = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
// Open a primary recno database.
Transaction openDBTxn = env.BeginTransaction();
RecnoDatabaseConfig dbConfig =
new RecnoDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
RecnoDatabase db = RecnoDatabase.Open(
dbFileName, dbConfig, openDBTxn);
openDBTxn.Commit();
// Open a secondary recno database.
Transaction openSecTxn = env.BeginTransaction();
SecondaryRecnoDatabaseConfig secDBConfig =
new SecondaryRecnoDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
SecondaryRecnoDatabaseConfigTest.Config(xmlElem,
ref secDBConfig, false);
secDBConfig.Env = env;
SecondaryRecnoDatabase secDB;
if (ifDbName == false)
secDB = SecondaryRecnoDatabase.Open(
dbSecFileName, secDBConfig, openSecTxn);
else
secDB = SecondaryRecnoDatabase.Open(
dbSecFileName, "secondary", secDBConfig,
openSecTxn);
openSecTxn.Commit();
// Confirm its flags configured in secDBConfig.
Confirm(xmlElem, secDB, true);
secDB.Close();
// Open the existing secondary database.
Transaction secTxn = env.BeginTransaction();
SecondaryDatabaseConfig secConfig =
new SecondaryDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secConfig.Env = env;
SecondaryDatabase secExDB;
if (ifDbName == false)
secExDB = SecondaryRecnoDatabase.Open(
dbSecFileName, secConfig, secTxn);
else
secExDB = SecondaryRecnoDatabase.Open(
dbSecFileName, "secondary", secConfig,
secTxn);
secExDB.Close();
secTxn.Commit();
db.Close();
env.Close();
}
/// <summary>
/// Instantiate a new SecondaryDatabase object, open the database
/// represented by <paramref name="Filename"/> and associate the
/// database with the <see cref="SecondaryDatabaseConfig.Primary">
/// primary index</see>. The file specified by
/// <paramref name="Filename"/> must exist.
/// </summary>
/// <remarks>
/// <para>
/// If <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.
/// </para>
/// </remarks>
/// <param name="Filename">
/// The name of an underlying file used to back the
/// database.
/// </param>
/// <param name="cfg">The database's configuration</param>
/// <returns>A new, open database object</returns>
public static SecondaryDatabase Open(
string Filename, SecondaryDatabaseConfig cfg)
{
return(Open(Filename, null, cfg, null));
}
/// <summary>
/// Instantiate a new SecondaryDatabase object, open the database
/// represented by <paramref name="Filename"/> and associate the
/// database with the <see cref="SecondaryDatabaseConfig.Primary">
/// primary index</see>. The file specified by
/// <paramref name="Filename"/> must exist.
/// </summary>
/// <remarks>
/// <para>
/// If <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.
/// </para>
/// </remarks>
/// <param name="Filename">
/// The name of an underlying file 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="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 SecondaryDatabase Open(string Filename,
SecondaryDatabaseConfig cfg, Transaction txn)
{
return(Open(Filename, null, cfg, txn));
}