public void GetCursur(string dbFileName, bool ifConfig)
{
HeapDatabaseConfig dbConfig = new HeapDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
HeapDatabase db = HeapDatabase.Open(dbFileName, dbConfig);
HeapRecordId rid = db.Append(
new DatabaseEntry(BitConverter.GetBytes((int)1)));
Cursor cursor;
CursorConfig cursorConfig = new CursorConfig();
cursorConfig.Priority = CachePriority.HIGH;
if (ifConfig == false)
cursor = db.Cursor();
else
cursor = db.Cursor(cursorConfig);
cursor.Add(new KeyValuePair<DatabaseEntry, DatabaseEntry>(
new DatabaseEntry(rid.toArray()),
new DatabaseEntry(BitConverter.GetBytes((int)2))));
Cursor dupCursor = cursor.Duplicate(false);
Assert.IsNull(dupCursor.Current.Key);
if (ifConfig)
Assert.AreEqual(CachePriority.HIGH, dupCursor.Priority);
dupCursor.Close();
cursor.Close();
db.Close();
}
// Get a cursor in CDS.
public static void GetCursorInBtreeDBInCDS(
string home, string name,
CursorConfig cursorConfig,
out DatabaseEnvironment env, out BTreeDatabase db,
out BTreeCursor cursor)
{
string dbFileName = name + ".db";
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseCDB = true;
envConfig.UseMPool = true;
env = DatabaseEnvironment.Open(home, envConfig);
/*
* Open an btree database. The underlying database
* should be opened with ReadUncommitted if the
* cursor's isolation degree will be set to be 1.
*/
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
if (cursorConfig.IsolationDegree == Isolation.DEGREE_ONE)
dbConfig.ReadUncommitted = true;
db = BTreeDatabase.Open(dbFileName, dbConfig);
// Get a cursor in the transaction.
cursor = db.Cursor(cursorConfig);
}
/// <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>
public new BTreeCursor Cursor(CursorConfig cfg, Transaction txn)
{
if (cfg.Priority == CachePriority.DEFAULT)
{
return(new BTreeCursor(db.cursor(
Transaction.getDB_TXN(txn), cfg.flags), Pagesize));
}
else
{
return(new BTreeCursor(db.cursor(Transaction.getDB_TXN(txn),
cfg.flags), Pagesize, cfg.Priority));
}
}
public void GetSecondaryCursurWithTxn(string home,
string name, bool ifCfg)
{
string dbFileName = name + ".db";
SecondaryCursor cursor;
// Open env.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(home,
envConfig);
// Open primary/secondary database.
Transaction txn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
BTreeDatabase db = BTreeDatabase.Open(dbFileName,
dbConfig, txn);
SecondaryBTreeDatabaseConfig secDBConfig = new
SecondaryBTreeDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
secDBConfig.Env = env;
SecondaryBTreeDatabase secDB =
SecondaryBTreeDatabase.Open(dbFileName,
secDBConfig, txn);
for (int i = 0; i < 10; i++)
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes((int)i)), txn);
// Create secondary cursor.
if (ifCfg == false)
secDB.SecondaryCursor(txn);
else if (ifCfg == true)
{
CursorConfig cursorConfig = new CursorConfig();
cursorConfig.WriteCursor = false;
cursor = secDB.SecondaryCursor(cursorConfig, txn);
cursor.Close();
}
secDB.Close();
db.Close();
txn.Commit();
env.Close();
}
public void TestConfig()
{
testName = "TestConfig";
SetUpTest(false);
/*
* Configure the fields/properties and see if
* they are updated successfully.
*/
CursorConfig cursorConfig = new CursorConfig();
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
Config(xmlElem, ref cursorConfig, true);
Confirm(xmlElem, cursorConfig, true);
}
public static void Config(XmlElement xmlElement,
ref CursorConfig cursorConfig, bool compulsory)
{
Configuration.ConfigIsolation(xmlElement,
"IsolationDegree", ref cursorConfig.IsolationDegree,
compulsory);
Configuration.ConfigCachePriority(xmlElement,
"Priority", ref cursorConfig.Priority, compulsory);
Configuration.ConfigBool(xmlElement,
"SnapshotIsolation", ref cursorConfig.SnapshotIsolation,
compulsory);
Configuration.ConfigBool(xmlElement,
"WriteCursor", ref cursorConfig.WriteCursor,
compulsory);
}
/// <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>
public SecondaryCursor SecondaryCursor(CursorConfig cfg)
{
return(SecondaryCursor(cfg, null));
}
public void ReadTxn()
{
// Get a new transaction for reading the db.
TransactionConfig txnConfig =
new TransactionConfig();
txnConfig.Snapshot = true;
readTxn = paramEnv.BeginTransaction(
txnConfig);
// Get a new cursor for putting record into db.
CursorConfig cursorConfig = new CursorConfig();
cursorConfig.WriteCursor = false;
BTreeCursor cursor = paramDB.Cursor(
cursorConfig, readTxn);
// Continually reading record from db.
try
{
Assert.IsTrue(cursor.MoveFirst());
int i = 0;
do
{
Assert.AreEqual(
BitConverter.ToInt32(
cursor.Current.Key.Data, 0),
BitConverter.ToInt32(
cursor.Current.Value.Data, 0));
} while (i <= 1000 && cursor.MoveNext());
}
catch (DeadlockException)
{
}
finally
{
cursor.Close();
}
}
public void TestWriteCursor()
{
BTreeCursor cursor;
BTreeDatabase db;
CursorConfig cursorConfig;
DatabaseEnvironment env;
testName = "TestWriteCursor";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
cursorConfig = new CursorConfig();
cursorConfig.WriteCursor = true;
GetCursorInBtreeDBInCDS(testHome, testName,
cursorConfig, out env, out db, out cursor);
/*
* Add a record by cursor to the database. If the
* WriteCursor doesn't work, exception will be
* throwed in the environment which is configured
* with DB_INIT_CDB.
*/
try
{
AddOneByCursor(db, cursor);
}
catch (DatabaseException)
{
throw new TestException();
}
finally
{
cursor.Close();
db.Close();
env.Close();
}
}
/*
* This simply counts the number of records contained in the
* database and returns the result. You can use this method
* in three ways:
*
* First call it with an active txn handle.
* Secondly, configure the cursor for dirty reads
* Third, call countRecords AFTER the writer has committed
* its transaction.
*
* If you do none of these things, the writer thread will
* self-deadlock.
*
* Note that this method exists only for illustrative purposes.
* A more straight-forward way to count the number of records in
* a database is to use the Database.getStats() method.
*/
private int CountRecords(Transaction txn)
{
int count = 0;
Cursor cursor = null;
try {
// Get the cursor.
CursorConfig cc = new CursorConfig();
/*
* Isolation degree one is ignored if the
* database was not opened for uncommitted
* read support. TxnGuide opens its database
* in this way and TxnGuideInMemory does not.
*/
cc.IsolationDegree = Isolation.DEGREE_ONE;
cursor = db.Cursor(cc, txn);
while (cursor.MoveNext())
count++;
} finally {
if (cursor != null)
cursor.Close();
}
return count;
}
/// <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>
public new RecnoCursor Cursor(CursorConfig cfg)
{
return Cursor(cfg, null);
}
/// <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>
public Cursor Cursor(CursorConfig cfg)
{
return Cursor(cfg, null);
}
/// <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>
public new HashCursor Cursor(CursorConfig cfg, Transaction txn)
{
return new HashCursor(
db.cursor(Transaction.getDB_TXN(txn), cfg.flags), Pagesize);
}
/// <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>
public new HashCursor Cursor(CursorConfig cfg)
{
return Cursor(cfg, null);
}
/// <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>
public new HashCursor Cursor(CursorConfig cfg)
{
return(Cursor(cfg, null));
}
/// <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>
public SecondaryCursor SecondaryCursor(
CursorConfig cfg, Transaction txn)
{
return(new SecondaryCursor(
db.cursor(Transaction.getDB_TXN(txn), cfg.flags)));
}
/// <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>
public new RecnoCursor Cursor(CursorConfig cfg)
{
return(Cursor(cfg, null));
}
public static void GetCursorInBtreeDBInTDS(
string home, string name,
CursorConfig cursorConfig,
out DatabaseEnvironment env, out BTreeDatabase db,
out BTreeCursor cursor, out Transaction txn)
{
string dbFileName = name + ".db";
Configuration.ClearDir(home);
// Open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
envConfig.NoMMap = false;
envConfig.UseLocking = true;
env = DatabaseEnvironment.Open(home, envConfig);
// Begin a transaction.
txn = env.BeginTransaction();
/*
* Open an btree database. The underlying database
* should be opened with ReadUncommitted if the
* cursor's isolation degree will be set to be 1.
*/
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
if (cursorConfig != null &&
cursorConfig.IsolationDegree == Isolation.DEGREE_ONE)
dbConfig.ReadUncommitted = true;
db = BTreeDatabase.Open(dbFileName, dbConfig, txn);
// Get a cursor in the transaction.
if (cursorConfig != null)
cursor = db.Cursor(cursorConfig, txn);
else
cursor = db.Cursor(txn);
}
/// <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>
public new RecnoCursor Cursor(CursorConfig cfg, Transaction txn)
{
return(new RecnoCursor(
db.cursor(Transaction.getDB_TXN(txn), cfg.flags), Pagesize));
}
public void TestPriority()
{
CachePriority[] priorities;
CursorConfig cursorConfig;
testName = "TestPriority";
SetUpTest(true);
cursorConfig = new CursorConfig();
priorities = new CachePriority[6];
priorities[0] = CachePriority.DEFAULT;
priorities[1] = CachePriority.HIGH;
priorities[2] = CachePriority.LOW;
priorities[3] = CachePriority.VERY_HIGH;
priorities[4] = CachePriority.VERY_LOW;
priorities[5] = null;
for (int i = 0; i < 6; i++) {
if (priorities[i] != null) {
cursorConfig.Priority = priorities[i];
Assert.AreEqual(priorities[i], cursorConfig.Priority);
}
GetCursorWithConfig(testHome + "/" + testName + ".db",
DatabaseType.BTREE.ToString(), cursorConfig, DatabaseType.BTREE);
GetCursorWithConfig(testHome + "/" + testName + ".db",
DatabaseType.HASH.ToString(), cursorConfig, DatabaseType.HASH);
GetCursorWithConfig(testHome + "/" + testName + ".db",
DatabaseType.QUEUE.ToString(), cursorConfig, DatabaseType.QUEUE);
GetCursorWithConfig(testHome + "/" + testName + ".db",
DatabaseType.RECNO.ToString(), cursorConfig, DatabaseType.RECNO);
}
}
/// <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>
public new RecnoCursor Cursor(CursorConfig cfg, Transaction txn)
{
if (cfg.Priority == CachePriority.DEFAULT)
return new RecnoCursor(
db.cursor(Transaction.getDB_TXN(txn), cfg.flags), Pagesize);
else
return new RecnoCursor(db.cursor(Transaction.getDB_TXN(txn),
cfg.flags), Pagesize, cfg.Priority);
}
private void GetCursorWithConfig(string dbFile, string dbName,
CursorConfig cfg, DatabaseType type)
{
Database db;
Cursor cursor;
Configuration.ClearDir(testHome);
if (type == DatabaseType.BTREE) {
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
db = BTreeDatabase.Open(dbFile, dbName, dbConfig);
cursor = ((BTreeDatabase)db).Cursor(cfg);
} else if (type == DatabaseType.HASH) {
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
db = (HashDatabase)HashDatabase.Open(dbFile, dbName, dbConfig);
cursor = ((HashDatabase)db).Cursor(cfg);
} else if (type == DatabaseType.QUEUE) {
QueueDatabaseConfig dbConfig = new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Length = 100;
db = QueueDatabase.Open(dbFile, dbConfig);
cursor = ((QueueDatabase)db).Cursor(cfg);
} else if (type == DatabaseType.RECNO) {
RecnoDatabaseConfig dbConfig = new RecnoDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
db = RecnoDatabase.Open(dbFile, dbName, dbConfig);
cursor = ((RecnoDatabase)db).Cursor(cfg);
} else
throw new TestException();
if (cfg.Priority != null)
Assert.AreEqual(cursor.Priority, cfg.Priority);
else
Assert.AreEqual(CachePriority.DEFAULT, cursor.Priority);
Cursor dupCursor = cursor.Duplicate(false);
Assert.AreEqual(cursor.Priority, dupCursor.Priority);
cursor.Close();
db.Close();
}
public void TestPriority()
{
BTreeCursor cursor;
BTreeDatabase db;
CachePriority[] priorities;
CursorConfig cursorConfig;
DatabaseEnvironment env;
cursorConfig = new CursorConfig();
priorities = new CachePriority[5];
priorities[0] = CachePriority.DEFAULT;
priorities[1] = CachePriority.HIGH;
priorities[2] = CachePriority.LOW;
priorities[3] = CachePriority.VERY_HIGH;
priorities[4] = CachePriority.VERY_LOW;
testName = "TestPriority";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
for (int i = 0; i < 5; i++)
{
// Configure the cursor priority.
cursorConfig.Priority = priorities[i];
// Open a database to test a specified priority.
GetCursorInBtreeDBInCDS(testHome, testName,
cursorConfig, out env, out db, out cursor);
Assert.AreEqual(priorities[i], cursorConfig.Priority);
cursor.Close();
db.Close();
env.Close();
}
}
/// <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>
public new BTreeCursor Cursor(CursorConfig cfg)
{
return Cursor(cfg, null);
}
void TestCloseResmgr_int(bool havetxn)
{
BTreeDatabase db;
BTreeCursor cursor, csr;
CursorConfig cursorConfig;
DatabaseEnvironment env;
Transaction txn;
DatabaseEntry key, data;
KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
txn = null;
testName = "TestCloseResmgr";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
cursorConfig = new CursorConfig();
// Open an environment, a database and a cursor.
if (havetxn)
GetCursorInBtreeDBInTDS(testHome, testName,
cursorConfig, out env, out db,
out cursor, out txn);
else
GetCursorInBtreeDB(testHome, testName,
cursorConfig, out env, out db,
out cursor);
// Add a record to db via cursor.
key = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("key"));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("data"));
pair = new KeyValuePair<DatabaseEntry,DatabaseEntry>
(key, data);
byte []kbytes;
byte []dbytes;
for (int i = 0; i < 100; i++) {
kbytes = ASCIIEncoding.ASCII.
GetBytes("key" + i);
dbytes = ASCIIEncoding.ASCII.
GetBytes("data" + i);
key.Data = kbytes;
data.Data = dbytes;
cursor.Add(pair);
}
// Do not close cursor.
csr = db.Cursor(cursorConfig, txn);
while (csr.MoveNext()) {
// Do nothing for now.
}
// Do not close csr.
if (havetxn && txn != null)
txn.Commit();
env.CloseForceSync();
}
/// <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>
public SecondaryCursor SecondaryCursor(CursorConfig cfg) {
return SecondaryCursor(cfg, null);
}
public void TestIsolationDegree()
{
BTreeDatabase db;
BTreeCursor cursor;
CursorConfig cursorConfig;
DatabaseEnvironment env;
Transaction txn;
testName = "TestIsolationDegree";
testHome = testFixtureHome + "/" + testName;
Isolation[] isolationDegrees = new Isolation[3];
isolationDegrees[0] = Isolation.DEGREE_ONE;
isolationDegrees[1] = Isolation.DEGREE_TWO;
isolationDegrees[2] = Isolation.DEGREE_THREE;
IsolationDelegate[] delegates = {
new IsolationDelegate(CursorReadUncommited),
new IsolationDelegate(CursorReadCommited),
new IsolationDelegate(CursorRead)};
cursorConfig = new CursorConfig();
for (int i = 0; i < 3; i++)
{
cursorConfig.IsolationDegree = isolationDegrees[i];
GetCursorInBtreeDBInTDS(testHome + "/" + i.ToString(),
testName, cursorConfig, out env, out db,
out cursor, out txn);
cursor.Close();
db.Close();
txn.Commit();
env.Close();
}
}
private void GetMultipleDB(string dbFileName,
BTreeDatabaseConfig dbConfig, Transaction txn,
out BTreeDatabase db, out BTreeCursor cursor)
{
if (txn == null) {
db = BTreeDatabase.Open(dbFileName, dbConfig);
cursor = db.Cursor();
} else {
db = BTreeDatabase.Open(
dbFileName, dbConfig, txn);
CursorConfig cursorConfig = new CursorConfig();
cursor = db.Cursor(cursorConfig, txn);
}
KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
DatabaseEntry key, data;
for (int i = 1; i < 100; i++) {
key = new DatabaseEntry(BitConverter.GetBytes(i));
data = new DatabaseEntry(BitConverter.GetBytes(i));
pair = new KeyValuePair<DatabaseEntry, DatabaseEntry>(key, data);
cursor.Add(pair);
}
if (dbConfig.UseRecordNumbers == true) {
byte[] bytes = new byte[512];
for (int i = 0; i < 512; i++)
bytes[i] = (byte)i;
key = new DatabaseEntry(BitConverter.GetBytes(100));
data = new DatabaseEntry(bytes);
pair = new KeyValuePair<DatabaseEntry, DatabaseEntry>(key, data);
cursor.Add(pair);
} else {
if (dbConfig.Duplicates == DuplicatesPolicy.UNSORTED ||
dbConfig.Duplicates == DuplicatesPolicy.SORTED) {
key = new DatabaseEntry(BitConverter.GetBytes(99));
data = new DatabaseEntry(BitConverter.GetBytes(100));
pair = new KeyValuePair<DatabaseEntry, DatabaseEntry>(key, data);
cursor.Add(pair);
}
key = new DatabaseEntry(BitConverter.GetBytes(101));
data = new DatabaseEntry(BitConverter.GetBytes(101));
pair = new KeyValuePair<DatabaseEntry, DatabaseEntry>(key, data);
cursor.Add(pair);
}
}
public void TestSecondaryCursorWithConfig()
{
testName = "TestSecondaryCursorWithConfig";
SetUpTest(true);
string dbFileName = testHome + "/" + testName + ".db";
BTreeDatabase db;
SecondaryBTreeDatabase secDB;
OpenPrimaryAndSecondaryDB(dbFileName, out db, out secDB);
for (int i = 0; i < 10; i++)
db.Put(new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(BitConverter.GetBytes((int)i)));
CursorConfig cursorConfig = new CursorConfig();
cursorConfig.WriteCursor = false;
SecondaryCursor cursor =
secDB.SecondaryCursor(cursorConfig);
cursor.Move(new DatabaseEntry(
BitConverter.GetBytes((int)5)), true);
Assert.AreEqual(1, cursor.Count());
// Close the cursor.
cursor.Close();
// Close secondary database.
secDB.Close();
// Close primary database.
db.Close();
}
/*
* Test the blob database with or without environment.
* 1. Config and open the environment;
* 2. Verify the environment blob configs;
* 3. Config and open the database;
* 4. Verify the database blob configs;
* 5. Insert and verify some blob data by database methods;
* 6. Insert some blob data by cursor, update it and verify
* the update by database stream and cursor;
* 7. Verify the stats;
* 8. Close all handles.
* If "blobdbt" is true, set the data DatabaseEntry.Blob as
* true, otherwise make the data DatabaseEntry reach the blob
* threshold in size.
*/
void TestBlobHashDatabase(uint env_threshold, string env_blobdir,
uint db_threshold, string db_blobdir, bool blobdbt)
{
if (env_threshold == 0 && db_threshold == 0)
return;
string hashDBName =
testHome + "/" + testName + ".db";
Configuration.ClearDir(testHome);
HashDatabaseConfig cfg = new HashDatabaseConfig();
cfg.Creation = CreatePolicy.ALWAYS;
string blrootdir = "__db_bl";
// Open the environment and verify the blob config.
if (env_threshold > 0)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.AutoCommit = true;
envConfig.Create = true;
envConfig.UseMPool = true;
envConfig.UseLogging = true;
envConfig.UseTxns = true;
envConfig.UseLocking = true;
envConfig.BlobThreshold = env_threshold;
if (env_blobdir != null)
{
envConfig.BlobDir = env_blobdir;
blrootdir = env_blobdir;
}
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
if (env_blobdir == null)
Assert.IsNull(env.BlobDir);
else
Assert.AreEqual(0,
env.BlobDir.CompareTo(env_blobdir));
Assert.AreEqual(env_threshold, env.BlobThreshold);
cfg.Env = env;
hashDBName = testName + ".db";
}
// Open the database and verify the blob config.
if (db_threshold > 0)
cfg.BlobThreshold = db_threshold;
if (db_blobdir != null)
{
cfg.BlobDir = db_blobdir;
/*
* The blob directory setting in the database
* is effective only when it is opened without
* an environment.
*/
if (cfg.Env == null)
blrootdir = db_blobdir;
}
HashDatabase db = HashDatabase.Open(hashDBName, cfg);
Assert.AreEqual(
db_threshold > 0 ? db_threshold : env_threshold,
db.BlobThreshold);
if (db_blobdir == null && cfg.Env == null)
Assert.IsNull(db.BlobDir);
else
Assert.AreEqual(0,
db.BlobDir.CompareTo(blrootdir));
// Insert and verify some blob data by database methods.
string[] records = {"a", "b", "c", "d", "e", "f", "g", "h",
"i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
"t", "u", "v", "w", "x", "y", "z"};
DatabaseEntry kdbt = new DatabaseEntry();
DatabaseEntry ddbt = new DatabaseEntry();
byte[] kdata, ddata;
string str;
KeyValuePair<DatabaseEntry, DatabaseEntry> pair;
ddbt.Blob = blobdbt;
Assert.AreEqual(blobdbt, ddbt.Blob);
for (int i = 0; i < records.Length; i++)
{
kdata = BitConverter.GetBytes(i);
str = records[i];
if (!blobdbt)
{
for (int j = 0; j < db_threshold; j++)
str = str + records[i];
}
ddata = Encoding.ASCII.GetBytes(str);
kdbt.Data = kdata;
ddbt.Data = ddata;
db.Put(kdbt, ddbt);
try
{
pair = db.Get(kdbt);
}
catch (DatabaseException)
{
db.Close();
if (cfg.Env != null)
cfg.Env.Close();
throw new TestException();
}
Assert.AreEqual(ddata, pair.Value.Data);
}
/*
* Insert some blob data by cursor, update it and verify
* the update by database stream.
*/
kdata = BitConverter.GetBytes(records.Length);
ddata = Encoding.ASCII.GetBytes("abc");
kdbt.Data = kdata;
ddbt.Data = ddata;
ddbt.Blob = true;
Assert.IsTrue(ddbt.Blob);
pair =
new KeyValuePair<DatabaseEntry, DatabaseEntry>(kdbt, ddbt);
CursorConfig dbcConfig = new CursorConfig();
Transaction txn = null;
if (cfg.Env != null)
txn = cfg.Env.BeginTransaction();
HashCursor cursor = db.Cursor(dbcConfig, txn);
cursor.Add(pair);
DatabaseStreamConfig dbsc = new DatabaseStreamConfig();
dbsc.SyncPerWrite = true;
DatabaseStream dbs = cursor.DbStream(dbsc);
Assert.AreNotEqual(null, dbs);
Assert.IsFalse(dbs.GetConfig.ReadOnly);
Assert.IsTrue(dbs.GetConfig.SyncPerWrite);
Assert.AreEqual(3, dbs.Size());
DatabaseEntry sdbt = dbs.Read(0, 3);
Assert.IsNotNull(sdbt);
Assert.AreEqual(ddata, sdbt.Data);
sdbt = new DatabaseEntry(Encoding.ASCII.GetBytes("defg"));
Assert.IsTrue(dbs.Write(sdbt, 3));
Assert.AreEqual(7, dbs.Size());
sdbt = dbs.Read(0, 7);
Assert.IsNotNull(sdbt);
Assert.AreEqual(Encoding.ASCII.GetBytes("abcdefg"), sdbt.Data);
dbs.Close();
/*
* Verify the database stream can not write when it is
* configured to be read-only.
*/
dbsc.ReadOnly = true;
dbs = cursor.DbStream(dbsc);
Assert.IsTrue(dbs.GetConfig.ReadOnly);
try
{
Assert.IsFalse(dbs.Write(sdbt, 7));
throw new TestException();
}
catch (DatabaseException)
{
}
dbs.Close();
// Verify the update by cursor.
Assert.IsTrue(cursor.Move(kdbt, true));
pair = cursor.Current;
Assert.AreEqual(Encoding.ASCII.GetBytes("abcdefg"),
pair.Value.Data);
cursor.Close();
if (cfg.Env != null)
txn.Commit();
/*
* Verify the blob files are created in the expected location.
* This part of test is disabled since BTreeDatabase.BlobSubDir
* is not exposed to users.
*/
//if (cfg.Env != null)
// blrootdir = testHome + "/" + blrootdir;
//string blobdir = blrootdir + "/" + db.BlobSubDir;
//Assert.AreEqual(records.Length + 1,
// Directory.GetFiles(blobdir, "__db.bl*").Length);
//Assert.AreEqual(1,
// Directory.GetFiles(blobdir, "__db_blob_meta.db").Length);
// Verify the stats.
HashStats st = db.Stats();
Assert.AreEqual(records.Length + 1, st.nBlobRecords);
// Close all handles.
db.Close();
if (cfg.Env != null)
cfg.Env.Close();
/*
* Remove the default blob directory
* when it is not under the test home.
*/
if (db_blobdir == null && cfg.Env == null)
Directory.Delete("__db_bl", true);
}
/// <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>
public SecondaryCursor SecondaryCursor(
CursorConfig cfg, Transaction txn) {
return new SecondaryCursor(
db.cursor(Transaction.getDB_TXN(txn), cfg.flags));
}
/// <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>
public new BTreeCursor Cursor(CursorConfig cfg)
{
return(Cursor(cfg, null));
}
