public void TestDeleteMultiple()
{
testName = "TestDeleteMultiple";
SetUpTest(true);
QueueDatabaseConfig dbConfig = new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.ExtentSize = 1024;
dbConfig.Length = 270;
QueueDatabase db = QueueDatabase.Open(testHome + "/" +
testName + ".db", dbConfig);
List <uint> rList = new List <uint>();
List <DatabaseEntry> kList = new List <DatabaseEntry>();
List <DatabaseEntry> vList = new List <DatabaseEntry>();
DatabaseEntry key, data;
for (uint i = 1; i <= 100; i++)
{
key = new DatabaseEntry(BitConverter.GetBytes(i));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes(
"data" + i.ToString() +
Configuration.RandomString(256)));
rList.Add(i);
kList.Add(key);
vList.Add(data);
db.Put(key, data);
}
// Bulk delete all records with recno in rList.
db.Delete(new MultipleDatabaseEntry(rList));
Cursor cursor = db.Cursor();
Assert.IsFalse(cursor.MoveFirst());
/*
* Bulk insert records whose key bulk buffer is
* constructed by recno lists, then delete all.
*/
db.Put(new MultipleDatabaseEntry(rList),
new MultipleDatabaseEntry(vList, false));
Assert.IsTrue(cursor.MoveFirst());
db.Delete(new MultipleDatabaseEntry(kList, true));
Assert.IsFalse(cursor.MoveFirst());
/*
* Bulk insert records whose key bulk buffer is
* constructed by DatabaseEntry lists, then delete all.
*/
db.Put(new MultipleDatabaseEntry(kList, true),
new MultipleDatabaseEntry(vList, false));
Assert.IsTrue(cursor.MoveFirst());
db.Delete(new MultipleDatabaseEntry(kList, true));
Assert.IsFalse(cursor.MoveFirst());
cursor.Close();
db.Close();
}
public void TestAppendWithoutTxn()
{
testName = "TestAppendWithoutTxn";
SetUpTest(true);
string queueDBFileName = testHome + "/" + testName + ".db";
QueueDatabaseConfig queueConfig = new QueueDatabaseConfig();
queueConfig.Creation = CreatePolicy.ALWAYS;
queueConfig.Length = 1000;
QueueDatabase queueDB = QueueDatabase.Open(
queueDBFileName, queueConfig);
byte[] byteArr = new byte[4];
byteArr = BitConverter.GetBytes((int)1);
DatabaseEntry data = new DatabaseEntry(byteArr);
uint recno = queueDB.Append(data);
// Confirm that the recno is larger than 0.
Assert.AreNotEqual(0, recno);
// Confirm that the record exists in the database.
byteArr = BitConverter.GetBytes(recno);
DatabaseEntry key = new DatabaseEntry();
key.Data = byteArr;
Assert.IsTrue(queueDB.Exists(key));
queueDB.Close();
}
public void TestStats()
{
testName = "TestStats";
SetUpTest(true);
string dbFileName = testHome + "/" +
testName + ".db";
QueueDatabaseConfig dbConfig =
new QueueDatabaseConfig();
ConfigCase1(dbConfig);
QueueDatabase db = QueueDatabase.Open(dbFileName, dbConfig);
QueueStats stats = db.Stats();
ConfirmStatsPart1Case1(stats);
db.Msgfile = testHome + "/" + testName + ".log";
db.PrintFastStats(true);
// Put 500 records into the database.
PutRecordCase1(db, null);
stats = db.Stats();
ConfirmStatsPart2Case1(stats);
db.PrintFastStats();
db.Close();
}
public void GetCursur(string dbFileName, bool ifConfig)
{
QueueDatabaseConfig dbConfig = new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Length = 100;
QueueDatabase db = QueueDatabase.Open(dbFileName, dbConfig);
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(BitConverter.GetBytes((int)1)),
new DatabaseEntry(BitConverter.GetBytes((int)1))));
Cursor dupCursor = cursor.Duplicate(false);
Assert.IsNull(dupCursor.Current.Key);
Assert.AreEqual(CachePriority.HIGH, dupCursor.Priority);
dupCursor.Close();
cursor.Close();
db.Close();
}
public void TestConfig()
{
testName = "TestConfig";
testHome = testFixtureHome + "/" + testName;
string dbFileName = testHome + "/" + testName + ".db";
Configuration.ClearDir(testHome);
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
// Open a primary btree database.
QueueDatabaseConfig queueDBConfig =
new QueueDatabaseConfig();
queueDBConfig.Creation = CreatePolicy.IF_NEEDED;
QueueDatabase queueDB = QueueDatabase.Open(
dbFileName, queueDBConfig);
SecondaryQueueDatabaseConfig secDBConfig =
new SecondaryQueueDatabaseConfig(queueDB, null);
Config(xmlElem, ref secDBConfig, true);
Confirm(xmlElem, secDBConfig, true);
// Close the primary btree database.
queueDB.Close();
}
private void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
db?.Close(true);
db?.Dispose();
}
public void TestMessageFile()
{
testName = "TestMessageFile";
SetUpTest(true);
// Configure and open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
// Configure and open a database.
QueueDatabaseConfig DBConfig =
new QueueDatabaseConfig();
DBConfig.Env = env;
DBConfig.Creation = CreatePolicy.IF_NEEDED;
string DBFileName = testName + ".db";
QueueDatabase db = QueueDatabase.Open(
DBFileName, DBConfig);
// Confirm message file does not exist.
string messageFile = testHome + "/" + "msgfile";
Assert.AreEqual(false, File.Exists(messageFile));
// Call set_msgfile() of db.
db.Msgfile = messageFile;
// Print db statistic to message file.
db.PrintStats(true);
// Confirm message file exists now.
Assert.AreEqual(true, File.Exists(messageFile));
db.Msgfile = "";
string line = null;
// Read the third line of message file.
System.IO.StreamReader file = new System.IO.StreamReader(@"" + messageFile);
line = file.ReadLine();
line = file.ReadLine();
line = file.ReadLine();
// Confirm the message file is not empty.
Assert.AreEqual(line, "DB handle information:");
file.Close();
// Close database and environment.
db.Close();
env.Close();
}
public void TestAppendWithTxn()
{
testName = "TestAppendWithTxn";
testHome = testFixtureHome + "/" + testName;
string queueDBFileName = testHome + "/" + testName + ".db";
string queueDBName =
Path.GetFileNameWithoutExtension(queueDBFileName);
Configuration.ClearDir(testHome);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
Transaction txn = env.BeginTransaction();
QueueDatabaseConfig queueConfig = new QueueDatabaseConfig();
queueConfig.Creation = CreatePolicy.ALWAYS;
queueConfig.Env = env;
queueConfig.Length = 1000;
/* If environmnet home is set, the file name in
* Open() is the relative path.
*/
QueueDatabase queueDB = QueueDatabase.Open(
queueDBName, queueConfig, txn);
DatabaseEntry data;
int i = 1000;
try
{
while (i > 0)
{
data = new DatabaseEntry(
BitConverter.GetBytes(i));
queueDB.Append(data, txn);
i--;
}
txn.Commit();
}
catch
{
txn.Abort();
}
finally
{
queueDB.Close();
env.Close();
}
}
public void StatsInTxn(string home, string name, bool ifIsolation)
{
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
EnvConfigCase1(envConfig);
DatabaseEnvironment env = DatabaseEnvironment.Open(
home, envConfig);
Transaction openTxn = env.BeginTransaction();
QueueDatabaseConfig dbConfig =
new QueueDatabaseConfig();
ConfigCase1(dbConfig);
dbConfig.Env = env;
QueueDatabase db = QueueDatabase.Open(name + ".db",
dbConfig, openTxn);
openTxn.Commit();
Transaction statsTxn = env.BeginTransaction();
QueueStats stats;
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_ONE);
}
ConfirmStatsPart1Case1(stats);
db.Msgfile = home + "/" + name + ".log";
db.PrintStats(true);
// Put 500 records into the database.
PutRecordCase1(db, statsTxn);
if (ifIsolation == false)
{
stats = db.Stats(statsTxn);
}
else
{
stats = db.Stats(statsTxn, Isolation.DEGREE_TWO);
}
ConfirmStatsPart2Case1(stats);
db.PrintStats();
statsTxn.Commit();
db.Close();
env.Close();
}
public void TestOpenExistingQueueDB()
{
testName = "TestOpenExistingQueueDB";
SetUpTest(true);
string queueDBFileName = testHome + "/" + testName + ".db";
QueueDatabaseConfig queueConfig = new QueueDatabaseConfig();
queueConfig.Creation = CreatePolicy.ALWAYS;
QueueDatabase queueDB = QueueDatabase.Open(
queueDBFileName, queueConfig);
queueDB.Close();
DatabaseConfig dbConfig = new DatabaseConfig();
Database db = Database.Open(queueDBFileName, dbConfig);
Assert.AreEqual(db.Type, DatabaseType.QUEUE);
db.Close();
}
public void GetCursur(string dbFileName, bool ifConfig)
{
QueueDatabaseConfig dbConfig = new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Length = 100;
QueueDatabase db = QueueDatabase.Open(dbFileName, dbConfig);
Cursor cursor;
if (ifConfig == false)
{
cursor = db.Cursor();
}
else
{
cursor = db.Cursor(new CursorConfig());
}
cursor.Close();
db.Close();
}
public void TestConsumeWithoutTxn()
{
testName = "TestConsumeWithoutTxn";
testHome = testFixtureHome + "/" + testName;
string queueDBFileName = testHome + "/" +
testName + ".db";
Configuration.ClearDir(testHome);
QueueDatabaseConfig queueConfig =
new QueueDatabaseConfig();
queueConfig.Creation = CreatePolicy.ALWAYS;
queueConfig.ErrorPrefix = testName;
queueConfig.Length = 1000;
QueueDatabase queueDB = QueueDatabase.Open(
queueDBFileName, queueConfig);
DatabaseEntry data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("data"));
queueDB.Append(data);
DatabaseEntry consumeData = new DatabaseEntry();
KeyValuePair <uint, DatabaseEntry> pair = queueDB.Consume(false);
try
{
DatabaseEntry key =
new DatabaseEntry(BitConverter.GetBytes(pair.Key));
queueDB.Get(key);
}
catch (NotFoundException)
{
throw new ExpectedTestException();
}
finally
{
queueDB.Close();
}
}
public void TestOpenNewQueueDB()
{
testName = "TestOpenNewQueueDB";
SetUpTest(true);
string queueDBFileName = testHome + "/" + testName + ".db";
// Configure all fields/properties in queue database.
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
QueueDatabaseConfig queueConfig = new QueueDatabaseConfig();
QueueDatabaseConfigTest.Config(xmlElem, ref queueConfig, true);
queueConfig.Feedback = new DatabaseFeedbackDelegate(DbFeedback);
// Open the queue database with above configuration.
QueueDatabase queueDB = QueueDatabase.Open(
queueDBFileName, queueConfig);
// Check the fields/properties in opened queue database.
Confirm(xmlElem, queueDB, true);
queueDB.Close();
}
public void TestDeleteMultipleKey()
{
testName = "TestDeleteMultipleKey";
SetUpTest(true);
QueueDatabaseConfig dbConfig = new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.ExtentSize = 1024;
dbConfig.Length = 520;
QueueDatabase db = QueueDatabase.Open(testHome + "/" +
testName + ".db", dbConfig);
List <KeyValuePair <DatabaseEntry, DatabaseEntry> > pList =
new List <KeyValuePair <DatabaseEntry, DatabaseEntry> >();
DatabaseEntry key, data;
for (uint i = 1; i <= 100; i++)
{
key = new DatabaseEntry(
BitConverter.GetBytes(i));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes(
"data" + i.ToString() +
Configuration.RandomString(512)));
pList.Add(new KeyValuePair <
DatabaseEntry, DatabaseEntry>(key, data));
db.Put(key, data);
}
// Create key/value pair bulk buffer and delete all.
db.Delete(new MultipleKeyDatabaseEntry(pList, true));
// Verify that the database is empty.
Assert.AreEqual(0, db.Truncate());
db.Close();
}
public void OpenSecQueueDBWithinTxn(string className,
string funName, string home, string dbFileName,
string dbSecFileName)
{
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 queue database.
Transaction openDBTxn = env.BeginTransaction();
QueueDatabaseConfig dbConfig =
new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
QueueDatabase db = QueueDatabase.Open(
dbFileName, dbConfig, openDBTxn);
openDBTxn.Commit();
// Open a secondary queue database.
Transaction openSecTxn = env.BeginTransaction();
SecondaryQueueDatabaseConfig secDBConfig =
new SecondaryQueueDatabaseConfig(db,
new SecondaryKeyGenDelegate(SecondaryKeyGen));
SecondaryQueueDatabaseConfigTest.Config(xmlElem,
ref secDBConfig, true);
secDBConfig.Env = env;
SecondaryQueueDatabase secDB;
secDB = SecondaryQueueDatabase.Open(
dbSecFileName, 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;
secExDB = SecondaryQueueDatabase.Open(
dbSecFileName, secConfig, secTxn);
secExDB.Close();
secTxn.Commit();
db.Close();
env.Close();
}
public void TestConsumeWithTxn()
{
testName = "TestConsumeWithTxn";
testHome = testFixtureHome + "/" + testName;
string queueDBFileName = testHome + "/" + testName + ".db";
string queueDBName = Path.GetFileName(queueDBFileName);
Configuration.ClearDir(testHome);
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
DatabaseEnvironment env = DatabaseEnvironment.Open(
testHome, envConfig);
Transaction txn = env.BeginTransaction();
QueueDatabaseConfig queueConfig =
new QueueDatabaseConfig();
queueConfig.Creation = CreatePolicy.ALWAYS;
queueConfig.Env = env;
queueConfig.Length = 1000;
QueueDatabase queueDB = QueueDatabase.Open(
queueDBName, queueConfig, txn);
int i = 1;
DatabaseEntry data;
DatabaseEntry getData = new DatabaseEntry();
while (i <= 10)
{
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes(i.ToString()));
queueDB.Append(data, txn);
if (i == 5)
{
getData = data;
}
i++;
}
KeyValuePair <uint, DatabaseEntry> pair = queueDB.Consume(false, txn);
queueDB.Close();
txn.Commit();
env.Close();
Database db = Database.Open(queueDBFileName,
new QueueDatabaseConfig());
try
{
DatabaseEntry key =
new DatabaseEntry(BitConverter.GetBytes(pair.Key));
db.Get(key);
}
catch (NotFoundException)
{
throw new ExpectedTestException();
}
finally
{
db.Close();
}
}
public void TestPutMultiple()
{
testName = "TestPutMultiple";
SetUpTest(true);
QueueDatabaseConfig dbConfig = new QueueDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.ExtentSize = 1024;
dbConfig.Length = 520;
dbConfig.PadByte = 0;
QueueDatabase db = QueueDatabase.Open(testHome + "/" +
testName + ".db", dbConfig);
List <uint> kList = new List <uint>();
List <DatabaseEntry> vList = new List <DatabaseEntry>();
DatabaseEntry key, data;
for (uint i = 1; i <= 9; i++)
{
key = new DatabaseEntry(BitConverter.GetBytes(i));
data = new DatabaseEntry(
ASCIIEncoding.ASCII.GetBytes("data" + i +
Configuration.RandomString(512)));
kList.Add(i);
vList.Add(data);
}
// Create bulk buffer for recno based keys.
MultipleDatabaseEntry kBuff =
new MultipleDatabaseEntry(kList);
Assert.IsTrue(kBuff.Recno);
int val = 0;
foreach (DatabaseEntry dbt in kBuff)
{
Assert.AreEqual(
BitConverter.GetBytes(kList[val]),
dbt.Data);
val++;
}
Assert.AreEqual(9, val);
// Create bulk buffer for data.
MultipleDatabaseEntry vBuff =
new MultipleDatabaseEntry(vList, false);
/*
* Create recno bulk buffer from another recno bulk
* buffer.
*/
MultipleDatabaseEntry kBuff1 =
new MultipleDatabaseEntry(kBuff.Data, kBuff.Recno);
val = 0;
foreach (DatabaseEntry dbt in kBuff1)
{
Assert.AreEqual(
BitConverter.GetBytes(kList[val]),
dbt.Data);
val++;
}
Assert.AreEqual(9, val);
// Bulk insert to database with key and value buffers.
db.Put(kBuff, vBuff);
Cursor cursor = db.Cursor();
KeyValuePair <DatabaseEntry, DatabaseEntry> pair;
val = 0;
while (cursor.MoveNext())
{
pair = cursor.Current;
Assert.AreEqual(
BitConverter.GetBytes(kList[val]),
pair.Key.Data);
for (int i = 0; i < 520; i++)
{
if (i < vList[val].Data.Length)
{
Assert.AreEqual(vList[val].Data[i],
pair.Value.Data[i]);
}
else
{
// The pad byte is 0.
Assert.AreEqual(0, pair.Value.Data[i]);
}
}
Assert.IsFalse(cursor.MoveNextDuplicate());
val++;
}
Assert.AreEqual(9, val);
cursor.Close();
db.Close();
}