mirror of
https://github.com/yasuhirokimura/db18
synced 2026-06-08 18:29:23 +00:00
Yasuhiro KIMURA
803 lines
23 KiB
C#
803 lines
23 KiB
C#
/*-
|
|
* Copyright (c) 2009, 2020 Oracle and/or its affiliates. All rights reserved.
|
|
*
|
|
* See the file LICENSE for license information.
|
|
*
|
|
*/
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using NUnit.Framework;
|
|
using BerkeleyDB;
|
|
|
|
namespace CsharpAPITest
|
|
{
|
|
[TestFixture]
|
|
public class HashDatabaseTest : CSharpTestFixture
|
|
{
|
|
|
|
[TestFixtureSetUp]
|
|
public void SetUpTestFixture()
|
|
{
|
|
testFixtureName = "HashDatabaseTest";
|
|
base.SetUpTestfixture();
|
|
}
|
|
|
|
[Test]
|
|
public void TestBlob() {
|
|
testName = "TestBlob";
|
|
SetUpTest(false);
|
|
// Test opening the external file database without environment.
|
|
TestBlobHashDatabase(0, null, 6, null, false);
|
|
|
|
/*
|
|
* Test opening the external file database without environment
|
|
* but specifying external file directory.
|
|
*/
|
|
TestBlobHashDatabase(0, null, 6, testHome + "/DBBLOB", true);
|
|
|
|
// Test opening the external file database with environment.
|
|
TestBlobHashDatabase(3, "ENVBLOB", 6, null, false);
|
|
|
|
/*
|
|
* Test opening the external file database with environment
|
|
* and specifying external file directory.
|
|
*/
|
|
TestBlobHashDatabase(3, null, 6, "/DBBLOB", true);
|
|
}
|
|
|
|
/*
|
|
* Test the external file database with or without environment.
|
|
* 1. Config and open the environment;
|
|
* 2. Verify the environment external file configs;
|
|
* 3. Config and open the database;
|
|
* 4. Verify the database external file configs;
|
|
* 5. Insert and verify some external file data by database methods;
|
|
* 6. Insert some external file 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.ExternalFile as
|
|
* true, otherwise make the data DatabaseEntry reach the external file
|
|
* 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 external file 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.ExternalFileThreshold = env_threshold;
|
|
if (env_blobdir != null)
|
|
{
|
|
envConfig.ExternalFileDir = env_blobdir;
|
|
blrootdir = env_blobdir;
|
|
}
|
|
DatabaseEnvironment env = DatabaseEnvironment.Open(
|
|
testHome, envConfig);
|
|
if (env_blobdir == null)
|
|
Assert.IsNull(env.ExternalFileDir);
|
|
else
|
|
Assert.AreEqual(0,
|
|
env.ExternalFileDir.CompareTo(env_blobdir));
|
|
Assert.AreEqual(env_threshold,
|
|
env.ExternalFileThreshold);
|
|
cfg.Env = env;
|
|
hashDBName = testName + ".db";
|
|
}
|
|
|
|
// Open the database and verify the external file config.
|
|
if (db_threshold > 0)
|
|
cfg.ExternalFileThreshold = db_threshold;
|
|
if (db_blobdir != null)
|
|
{
|
|
cfg.ExternalFileDir = db_blobdir;
|
|
/*
|
|
* The external file 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.ExternalFileThreshold);
|
|
if (db_blobdir == null && cfg.Env == null)
|
|
Assert.IsNull(db.ExternalFileDir);
|
|
else
|
|
Assert.AreEqual(0,
|
|
db.ExternalFileDir.CompareTo(blrootdir));
|
|
|
|
// Insert and verify some external file 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.ExternalFile = blobdbt;
|
|
Assert.AreEqual(blobdbt, ddbt.ExternalFile);
|
|
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 external file 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.ExternalFile = true;
|
|
Assert.IsTrue(ddbt.ExternalFile);
|
|
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 external 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.nExternalFiles);
|
|
|
|
// Close all handles.
|
|
db.Close();
|
|
if (cfg.Env != null)
|
|
cfg.Env.Close();
|
|
|
|
/*
|
|
* Remove the default external file directory
|
|
* when it is not under the test home.
|
|
*/
|
|
if (db_blobdir == null && cfg.Env == null)
|
|
Directory.Delete("__db_bl", true);
|
|
}
|
|
|
|
[Test]
|
|
public void TestCompactWithoutTxn() {
|
|
int i, nRecs;
|
|
nRecs = 10000;
|
|
testName = "TestCompactWithoutTxn";
|
|
SetUpTest(true);
|
|
string hashDBFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig hashDBConfig = new HashDatabaseConfig();
|
|
hashDBConfig.Creation = CreatePolicy.ALWAYS;
|
|
// The minimum page size
|
|
hashDBConfig.PageSize = 512;
|
|
hashDBConfig.HashComparison =
|
|
new EntryComparisonDelegate(dbIntCompare);
|
|
using (HashDatabase hashDB = HashDatabase.Open(
|
|
hashDBFileName, hashDBConfig)) {
|
|
DatabaseEntry key;
|
|
DatabaseEntry data;
|
|
|
|
// Fill the database with entries from 0 to 9999
|
|
for (i = 0; i < nRecs; i++) {
|
|
key = new DatabaseEntry(BitConverter.GetBytes(i));
|
|
data = new DatabaseEntry(BitConverter.GetBytes(i));
|
|
hashDB.Put(key, data);
|
|
}
|
|
|
|
/*
|
|
* Delete entries below 500, between 3000 and
|
|
* 5000 and above 7000
|
|
*/
|
|
for (i = 0; i < nRecs; i++)
|
|
if (i < 500 || i > 7000 || (i < 5000 && i > 3000)) {
|
|
key = new DatabaseEntry(BitConverter.GetBytes(i));
|
|
hashDB.Delete(key);
|
|
}
|
|
|
|
hashDB.Sync();
|
|
long fileSize = new FileInfo(hashDBFileName).Length;
|
|
|
|
// Compact database
|
|
CompactConfig cCfg = new CompactConfig();
|
|
cCfg.FillPercentage = 30;
|
|
cCfg.Pages = 10;
|
|
cCfg.Timeout = 1000;
|
|
cCfg.TruncatePages = true;
|
|
cCfg.start = new DatabaseEntry(BitConverter.GetBytes(1));
|
|
cCfg.stop = new DatabaseEntry(BitConverter.GetBytes(7000));
|
|
CompactData compactData = hashDB.Compact(cCfg);
|
|
Assert.IsFalse((compactData.Deadlocks == 0) &&
|
|
(compactData.Levels == 0) &&
|
|
(compactData.PagesExamined == 0) &&
|
|
(compactData.PagesFreed == 0) &&
|
|
(compactData.PagesTruncated == 0));
|
|
|
|
hashDB.Sync();
|
|
long compactedFileSize = new FileInfo(hashDBFileName).Length;
|
|
Assert.Less(compactedFileSize, fileSize);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestHashComparison()
|
|
{
|
|
testName = "TestHashComparison";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
|
|
dbConfig.Creation = CreatePolicy.IF_NEEDED;
|
|
dbConfig.HashComparison = new EntryComparisonDelegate(EntryComparison);
|
|
HashDatabase db = HashDatabase.Open(dbFileName,dbConfig);
|
|
int ret;
|
|
|
|
/*
|
|
* Comparison gets the value that lowest byte of the
|
|
* former dbt minus that of the latter one.
|
|
*/
|
|
ret = db.Compare(new DatabaseEntry(BitConverter.GetBytes(2)),
|
|
new DatabaseEntry(BitConverter.GetBytes(2)));
|
|
Assert.AreEqual(0, ret);
|
|
|
|
ret = db.Compare(new DatabaseEntry(BitConverter.GetBytes(256)),
|
|
new DatabaseEntry(BitConverter.GetBytes(1)));
|
|
Assert.Greater(0, ret);
|
|
|
|
db.Close();
|
|
}
|
|
|
|
public int EntryComparison(DatabaseEntry dbt1,
|
|
DatabaseEntry dbt2)
|
|
{
|
|
return dbt1.Data[0] - dbt2.Data[0];
|
|
}
|
|
|
|
[Test]
|
|
public void TestHashFunction()
|
|
{
|
|
testName = "TestHashFunction";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
|
|
dbConfig.Creation = CreatePolicy.IF_NEEDED;
|
|
dbConfig.HashFunction = new HashFunctionDelegate(HashFunction);
|
|
HashDatabase db = HashDatabase.Open(dbFileName, dbConfig);
|
|
|
|
// Hash function will change the lowest byte to 0;
|
|
uint data = db.HashFunction(BitConverter.GetBytes(1));
|
|
Assert.AreEqual(0, data);
|
|
db.Close();
|
|
}
|
|
|
|
public uint HashFunction(byte[] data)
|
|
{
|
|
data[0] = 0;
|
|
return BitConverter.ToUInt32(data, 0);
|
|
}
|
|
|
|
[Test]
|
|
public void TestOpenExistingHashDB()
|
|
{
|
|
testName = "TestOpenExistingHashDB";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig hashConfig =
|
|
new HashDatabaseConfig();
|
|
hashConfig.Creation = CreatePolicy.ALWAYS;
|
|
HashDatabase hashDB = HashDatabase.Open(dbFileName, hashConfig);
|
|
hashDB.Close();
|
|
|
|
DatabaseConfig dbConfig = new DatabaseConfig();
|
|
Database db = Database.Open(dbFileName, dbConfig);
|
|
Assert.AreEqual(db.Type, DatabaseType.HASH);
|
|
db.Close();
|
|
}
|
|
|
|
[Test]
|
|
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.
|
|
HashDatabaseConfig DBConfig =
|
|
new HashDatabaseConfig();
|
|
DBConfig.Env = env;
|
|
DBConfig.Creation = CreatePolicy.IF_NEEDED;
|
|
|
|
string DBFileName = testName + ".db";
|
|
HashDatabase db = HashDatabase.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();
|
|
}
|
|
|
|
[Test]
|
|
public void TestOpenNewHashDB()
|
|
{
|
|
testName = "TestOpenNewHashDB";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
XmlElement xmlElem = Configuration.TestSetUp(testFixtureName, testName);
|
|
HashDatabaseConfig hashConfig = new HashDatabaseConfig();
|
|
HashDatabaseConfigTest.Config(xmlElem, ref hashConfig, true);
|
|
HashDatabase hashDB = HashDatabase.Open(dbFileName, hashConfig);
|
|
Confirm(xmlElem, hashDB, true);
|
|
hashDB.Close();
|
|
}
|
|
|
|
[Test, ExpectedException(typeof(ExpectedTestException))]
|
|
public void TestPutNoDuplicateWithUnsortedDuplicate()
|
|
{
|
|
testName = "TestPutNoDuplicateWithUnsortedDuplicate";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig hashConfig = new HashDatabaseConfig();
|
|
hashConfig.Creation = CreatePolicy.ALWAYS;
|
|
hashConfig.Duplicates = DuplicatesPolicy.UNSORTED;
|
|
hashConfig.ErrorPrefix = testName;
|
|
|
|
HashDatabase hashDB = HashDatabase.Open(dbFileName, hashConfig);
|
|
DatabaseEntry key, data;
|
|
key = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("1"));
|
|
data = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("1"));
|
|
|
|
try
|
|
{
|
|
hashDB.PutNoDuplicate(key, data);
|
|
}
|
|
catch (DatabaseException)
|
|
{
|
|
throw new ExpectedTestException();
|
|
}
|
|
finally
|
|
{
|
|
hashDB.Close();
|
|
}
|
|
}
|
|
|
|
[Test, ExpectedException(typeof(ExpectedTestException))]
|
|
public void TestKeyExistException()
|
|
{
|
|
testName = "TestKeyExistException";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig hashConfig = new HashDatabaseConfig();
|
|
hashConfig.Creation = CreatePolicy.ALWAYS;
|
|
hashConfig.Duplicates = DuplicatesPolicy.SORTED;
|
|
HashDatabase hashDB = HashDatabase.Open(dbFileName, hashConfig);
|
|
|
|
// Put the same record into db twice.
|
|
DatabaseEntry key, data;
|
|
key = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("1"));
|
|
data = new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes("1"));
|
|
try
|
|
{
|
|
hashDB.PutNoDuplicate(key, data);
|
|
hashDB.PutNoDuplicate(key, data);
|
|
}
|
|
catch (KeyExistException)
|
|
{
|
|
throw new ExpectedTestException();
|
|
}
|
|
finally
|
|
{
|
|
hashDB.Close();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestPutNoDuplicate()
|
|
{
|
|
testName = "TestPutNoDuplicate";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig hashConfig =
|
|
new HashDatabaseConfig();
|
|
hashConfig.Creation = CreatePolicy.ALWAYS;
|
|
hashConfig.Duplicates = DuplicatesPolicy.SORTED;
|
|
hashConfig.TableSize = 20;
|
|
HashDatabase hashDB = HashDatabase.Open(dbFileName, hashConfig);
|
|
|
|
DatabaseEntry key, data;
|
|
for (int i = 1; i <= 10; i++)
|
|
{
|
|
key = new DatabaseEntry(BitConverter.GetBytes(i));
|
|
data = new DatabaseEntry(BitConverter.GetBytes(i));
|
|
hashDB.PutNoDuplicate(key, data);
|
|
}
|
|
|
|
Assert.IsTrue(hashDB.Exists(
|
|
new DatabaseEntry(BitConverter.GetBytes((int)5))));
|
|
|
|
hashDB.Close();
|
|
}
|
|
|
|
[Test, ExpectedException(typeof(ExpectedTestException))]
|
|
public void TestPutNoDuplicateWithTxn()
|
|
{
|
|
testName = "TestPutNoDuplicateWithTxn";
|
|
SetUpTest(true);
|
|
|
|
// Open an environment.
|
|
DatabaseEnvironmentConfig envConfig =
|
|
new DatabaseEnvironmentConfig();
|
|
envConfig.Create = true;
|
|
envConfig.UseLogging = true;
|
|
envConfig.UseMPool = true;
|
|
envConfig.UseTxns = true;
|
|
DatabaseEnvironment env = DatabaseEnvironment.Open(
|
|
testHome, envConfig);
|
|
|
|
// Open a hash database within a transaction.
|
|
Transaction txn = env.BeginTransaction();
|
|
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
|
|
dbConfig.Creation = CreatePolicy.IF_NEEDED;
|
|
dbConfig.Duplicates = DuplicatesPolicy.SORTED;
|
|
dbConfig.Env = env;
|
|
HashDatabase db = HashDatabase.Open(testName + ".db", dbConfig, txn);
|
|
|
|
DatabaseEntry dbt = new DatabaseEntry(BitConverter.GetBytes((int)100));
|
|
db.PutNoDuplicate(dbt, dbt, txn);
|
|
try
|
|
{
|
|
db.PutNoDuplicate(dbt, dbt, txn);
|
|
}
|
|
catch (KeyExistException)
|
|
{
|
|
throw new ExpectedTestException();
|
|
}
|
|
finally
|
|
{
|
|
// Close all.
|
|
db.Close();
|
|
txn.Commit();
|
|
env.Close();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestStats()
|
|
{
|
|
testName = "TestStats";
|
|
SetUpTest(true);
|
|
string dbFileName = testHome + "/" + testName + ".db";
|
|
|
|
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
|
|
ConfigCase1(dbConfig);
|
|
HashDatabase db = HashDatabase.Open(dbFileName, dbConfig);
|
|
|
|
HashStats stats = db.Stats();
|
|
HashStats fastStats = db.FastStats();
|
|
ConfirmStatsPart1Case1(stats);
|
|
ConfirmStatsPart1Case1(fastStats);
|
|
|
|
// Put 100 records into the database.
|
|
PutRecordCase1(db, null);
|
|
|
|
stats = db.Stats();
|
|
ConfirmStatsPart2Case1(stats);
|
|
|
|
// Delete some data to get some free pages.
|
|
byte[] bigArray = new byte[262144];
|
|
db.Delete(new DatabaseEntry(bigArray));
|
|
stats = db.Stats();
|
|
ConfirmStatsPart3Case1(stats);
|
|
|
|
db.Close();
|
|
}
|
|
|
|
[Test]
|
|
public void TestStatsInTxn()
|
|
{
|
|
testName = "TestStatsInTxn";
|
|
SetUpTest(true);
|
|
|
|
StatsInTxn(testHome, testName, false);
|
|
}
|
|
|
|
[Test]
|
|
public void TestStatsWithIsolation()
|
|
{
|
|
testName = "TestStatsWithIsolation";
|
|
SetUpTest(true);
|
|
|
|
StatsInTxn(testHome, testName, true);
|
|
}
|
|
|
|
private int dbIntCompare(DatabaseEntry dbt1, DatabaseEntry dbt2) {
|
|
int a, b;
|
|
a = BitConverter.ToInt32(dbt1.Data, 0);
|
|
b = BitConverter.ToInt32(dbt2.Data, 0);
|
|
return a - b;
|
|
}
|
|
|
|
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();
|
|
HashDatabaseConfig dbConfig = new HashDatabaseConfig();
|
|
ConfigCase1(dbConfig);
|
|
dbConfig.Env = env;
|
|
HashDatabase db = HashDatabase.Open(name + ".db", dbConfig, openTxn);
|
|
openTxn.Commit();
|
|
|
|
Transaction statsTxn = env.BeginTransaction();
|
|
HashStats stats;
|
|
HashStats fastStats;
|
|
if (ifIsolation == false)
|
|
{
|
|
stats = db.Stats(statsTxn);
|
|
fastStats = db.Stats(statsTxn);
|
|
}
|
|
else
|
|
{
|
|
stats = db.Stats(statsTxn, Isolation.DEGREE_ONE);
|
|
fastStats = db.Stats(statsTxn, Isolation.DEGREE_ONE);
|
|
}
|
|
|
|
ConfirmStatsPart1Case1(stats);
|
|
|
|
// Put 100 records into the database.
|
|
PutRecordCase1(db, statsTxn);
|
|
|
|
if (ifIsolation == false)
|
|
stats = db.Stats(statsTxn);
|
|
else
|
|
stats = db.Stats(statsTxn, Isolation.DEGREE_TWO);
|
|
ConfirmStatsPart2Case1(stats);
|
|
|
|
// Delete some data to get some free pages.
|
|
byte[] bigArray = new byte[262144];
|
|
db.Delete(new DatabaseEntry(bigArray), statsTxn);
|
|
if (ifIsolation == false)
|
|
stats = db.Stats(statsTxn);
|
|
else
|
|
stats = db.Stats(statsTxn, Isolation.DEGREE_THREE);
|
|
ConfirmStatsPart3Case1(stats);
|
|
|
|
statsTxn.Commit();
|
|
db.Close();
|
|
env.Close();
|
|
}
|
|
|
|
public void EnvConfigCase1(DatabaseEnvironmentConfig cfg)
|
|
{
|
|
cfg.Create = true;
|
|
cfg.UseTxns = true;
|
|
cfg.UseMPool = true;
|
|
cfg.UseLogging = true;
|
|
}
|
|
|
|
public void ConfigCase1(HashDatabaseConfig dbConfig)
|
|
{
|
|
dbConfig.Creation = CreatePolicy.IF_NEEDED;
|
|
dbConfig.Duplicates = DuplicatesPolicy.UNSORTED;
|
|
dbConfig.FillFactor = 10;
|
|
dbConfig.TableSize = 20;
|
|
dbConfig.PageSize = 4096;
|
|
}
|
|
|
|
public void PutRecordCase1(HashDatabase db, Transaction txn)
|
|
{
|
|
byte[] bigArray = new byte[262144];
|
|
for (int i = 0; i < 50; 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);
|
|
}
|
|
for (int i = 50; i < 100; i++)
|
|
{
|
|
if (txn == null)
|
|
db.Put(new DatabaseEntry(bigArray),
|
|
new DatabaseEntry(bigArray));
|
|
else
|
|
db.Put(new DatabaseEntry(bigArray),
|
|
new DatabaseEntry(bigArray), txn);
|
|
}
|
|
}
|
|
|
|
public void ConfirmStatsPart1Case1(HashStats stats)
|
|
{
|
|
Assert.AreEqual(10, stats.FillFactor);
|
|
Assert.AreEqual(4096, stats.PageSize);
|
|
Assert.AreEqual(10, stats.Version);
|
|
}
|
|
|
|
public void ConfirmStatsPart2Case1(HashStats stats)
|
|
{
|
|
Assert.AreNotEqual(0, stats.BigPages);
|
|
Assert.AreNotEqual(0, stats.BigPagesFreeBytes);
|
|
Assert.AreNotEqual(0, stats.BucketPagesFreeBytes);
|
|
Assert.AreNotEqual(0, stats.DuplicatePages);
|
|
Assert.AreNotEqual(0, stats.DuplicatePagesFreeBytes);
|
|
Assert.AreNotEqual(0, stats.MagicNumber);
|
|
Assert.AreNotEqual(0, stats.MetadataFlags);
|
|
Assert.AreEqual(100, stats.nData);
|
|
Assert.AreNotEqual(0, stats.nHashBuckets);
|
|
Assert.AreEqual(51, stats.nKeys);
|
|
Assert.AreNotEqual(0, stats.nPages);
|
|
Assert.AreEqual(0, stats.OverflowPages);
|
|
Assert.AreEqual(0, stats.OverflowPagesFreeBytes);
|
|
}
|
|
|
|
public void ConfirmStatsPart3Case1(HashStats stats)
|
|
{
|
|
Assert.AreNotEqual(0, stats.FreePages);
|
|
}
|
|
|
|
public static void Confirm(XmlElement xmlElem,
|
|
HashDatabase hashDB, bool compulsory)
|
|
{
|
|
DatabaseTest.Confirm(xmlElem, hashDB, compulsory);
|
|
Configuration.ConfirmCreatePolicy(xmlElem,
|
|
"Creation", hashDB.Creation, compulsory);
|
|
Configuration.ConfirmDuplicatesPolicy(xmlElem,
|
|
"Duplicates", hashDB.Duplicates, compulsory);
|
|
Configuration.ConfirmUint(xmlElem,
|
|
"FillFactor", hashDB.FillFactor, compulsory);
|
|
Configuration.ConfirmUint(xmlElem,
|
|
"NumElements", hashDB.TableSize,
|
|
compulsory);
|
|
Assert.AreEqual(DatabaseType.HASH, hashDB.Type);
|
|
string type = hashDB.Type.ToString();
|
|
Assert.IsNotNull(type);
|
|
}
|
|
}
|
|
}
|