public void TestInsertNoSplit()
{
using (var pageStore = TestUtils.CreateEmptyPageStore("TestInsertNoSplit.data"))
{
var tree = new BPlusTree(pageStore);
tree.Insert(0, 5ul, TestUtils.StringToByteArray("five"));
tree.Insert(0, 3ul, TestUtils.StringToByteArray("three"));
var valueBuffer = new byte[_config.ValueSize];
Assert.IsTrue(tree.Search(5ul, valueBuffer, null), "Expected search for key 5 to return true");
TestUtils.AssertBuffersEqual(TestUtils.StringToByteArray("five"), valueBuffer);
Assert.IsTrue(tree.Search(3ul, valueBuffer, null), "Expected search for key 3 to return true");
TestUtils.AssertBuffersEqual(TestUtils.StringToByteArray("three"), valueBuffer);
Assert.IsFalse(tree.Search(2ul, valueBuffer, null), "Expected search for key 2 to return false");
tree.Save(0, null);
var root = tree.RootId;
pageStore.Commit((ulong)DateTime.Now.Ticks, null);
tree = new BPlusTree(pageStore, root);
Assert.IsTrue(tree.Search(5ul, valueBuffer, null), "Expected search for key 5 to return true");
TestUtils.AssertBuffersEqual(TestUtils.StringToByteArray("five"), valueBuffer);
Assert.IsTrue(tree.Search(3ul, valueBuffer, null), "Expected search for key 3 to return true");
TestUtils.AssertBuffersEqual(TestUtils.StringToByteArray("three"), valueBuffer);
Assert.IsFalse(tree.Search(2ul, valueBuffer, null), "Expected search for key 2 to return false");
}
}
public void Delete_BiggestKeyInTheOnlyLeafNodeOfTree_ExpectsToReduceBy1Key()
{
var tree = new BPlusTree <int, string>(3);
tree.Insert(new KeyValuePair <int, string>(10, "A"));
tree.Insert(new KeyValuePair <int, string>(100, "B"));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 3, 2, 3);
/* Deleting 1 out of 2 keys in the only leaf node of the tree. */
Assert.IsTrue(tree.Delete(100));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 2, 1, 2);
}
public void Delete_TheOnlyKeyInLeafNode_ExpectsToTriggerLeftRotateAndReduceBy1Key()
{
var tree = new BPlusTree <int, string>(3);
tree.Insert(new KeyValuePair <int, string>(10, "A"));
tree.Insert(new KeyValuePair <int, string>(20, "B"));
tree.Insert(new KeyValuePair <int, string>(30, "C"));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 4, 3, 3);
Assert.IsTrue(tree.Delete(10));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 3, 2, 3);
}
public void Delete_NonExistingKey_ExpectsFailure()
{
var tree = new BPlusTree <int, string>(3);
tree.Insert(new KeyValuePair <int, string>(10, "A"));
tree.Insert(new KeyValuePair <int, string>(100, "B"));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 3, 2, 3);
/* Deleting a non-existing key. */
Assert.IsFalse(tree.Delete(50));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 3, 2, 3);
}
public void Delete_TheOnlyKeyInLeafNodeWithMinOneFullSibling_ExpectsToTriggerLeftRotate()
{
var tree = new BPlusTree <int, string>(3);
tree.Insert(new KeyValuePair <int, string>(10, "A"));
tree.Insert(new KeyValuePair <int, string>(20, "B"));
tree.Insert(new KeyValuePair <int, string>(30, "C"));
tree.Insert(new KeyValuePair <int, string>(40, "D"));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 6, 4, 4);
Assert.IsTrue(tree.Delete(10));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 5, 3, 4);
}
public void Delete_KeyInFullLeaf_ExpectsToReduceBy1Key()
{
var tree = new BPlusTree <int, string>(3);
tree.Insert(new KeyValuePair <int, string>(10, "A"));
tree.Insert(new KeyValuePair <int, string>(20, "B"));
tree.Insert(new KeyValuePair <int, string>(30, "C"));
tree.Insert(new KeyValuePair <int, string>(40, "D"));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 6, 4, 4);
Assert.IsTrue(tree.Delete(30));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 5, 3, 4);
}
public void TestBatchInsert()
{
const int target = 40000000;
const int batchSize = 50000;
const int batchCount = target / batchSize;
// Tests insert of 40 million unique keys in batches of 50,000
// Reports time for each batch to console.
#if SILVERLIGHT
var persistenceManager = new IsolatedStoragePersistanceManager();
#else
var persistenceManager = new FilePersistenceManager();
#endif
// Create a test batch
if (!File.Exists("C:\\brightstar\\testdata.dat"))
{
MakeTestData();
}
var testList = ReadTestData("c:\\brightstar\\testdata.dat");
// Create empty store
if (File.Exists("40m_batch.data"))
{
File.Delete("40m_batch.data");
}
var pageStore = new AppendOnlyFilePageStore(persistenceManager, "40m_batch.data", 4096, false, false);
var tree = new BPlusTree(0, pageStore);
ulong lastRoot = tree.RootId;
tree.Save(0, null);
pageStore.Commit(0ul, null);
byte[] testBuffer = Encoding.UTF8.GetBytes("Test Buffer");
var batchTimer = Stopwatch.StartNew();
int insertedCount = 0;
var txnId = 1ul;
for (int i = 0; i < batchCount; i++)
{
tree = new BPlusTree(pageStore, lastRoot);
foreach (var item in testList)
{
var insertKey = (ulong)((item * batchCount) + i);
try
{
tree.Insert(txnId, insertKey, testBuffer);
insertedCount++;
}
catch (Exception e)
{
Assert.Fail("Failed to add key {0}. Cause: {1}", insertKey, e);
}
}
long beforeSave = batchTimer.ElapsedMilliseconds;
tree.Save(txnId, null);
lastRoot = tree.RootId;
pageStore.Commit(txnId, null);
Console.WriteLine("{0},{1},{2}", insertedCount, beforeSave, batchTimer.ElapsedMilliseconds);
txnId++;
}
}
public void TestValuelessBTree()
{
var insertedValues = new List <Guid>();
ulong treeRoot;
var txnId = 0ul;
using (var pageStore = TestUtils.CreateEmptyPageStore("TestValuelessBTree.data"))
{
var tree = new BPlusTree(pageStore, 16, 0);
for (int i = 0; i < 1000; i++)
{
var g = Guid.NewGuid();
tree.Insert(txnId, g.ToByteArray(), null);
insertedValues.Add(g);
}
tree.Save(0, null);
treeRoot = tree.RootId;
pageStore.Commit(0ul, null);
}
using (var pageStore = TestUtils.OpenPageStore("TestValuelessBTree.data", false))
{
var tree = new BPlusTree(pageStore, treeRoot, 16, 0);
var buff = new byte[0];
foreach (var g in insertedValues)
{
Assert.IsTrue(tree.Search(g.ToByteArray(), buff, null));
}
}
}
public void TestBorrowLeft()
{
using (var pageStore = TestUtils.CreateEmptyPageStore("TestBorrowLeft.data"))
{
var tree = new BPlusTree(pageStore);
var buff = new byte[_config.ValueSize];
var txnId = 0ul;
for (int j = _config.LeafLoadFactor; j >= 0; j--)
{
tree.Insert(txnId, (ulong)j, BitConverter.GetBytes((ulong)j));
}
tree.Delete(txnId, (ulong)(_config.LeafLoadFactor - 1), null);
tree.Delete(txnId, (ulong)(_config.LeafLoadFactor - 2), null);
// This should force a borrow from the left node
for (int i = 0; i <= _config.LeafLoadFactor; i++)
{
Assert.IsTrue(
i == (_config.LeafLoadFactor - 1) ^ i == (_config.LeafLoadFactor - 2) ^
tree.Search((ulong)i, buff, null),
"Could not find entry for key {0}", i);
}
}
}
public void TestBatchedInserts()
{
var rng = new Random();
var keyBuff = new byte[8];
var value = new byte[64];
ulong key = 0;
var txnId = 0ul;
var inserted = new HashSet <ulong>();
inserted.Add(0); // Not using enumerable initializer because its not supported in the mobile build
using (var pageStore = TestUtils.CreateEmptyPageStore("TestBatchedInserts.data"))
{
var tree = new BPlusTree(pageStore);
for (int i = 1; i <= 10000; i++)
{
while (inserted.Contains(key))
{
rng.NextBytes(keyBuff);
key = BitConverter.ToUInt64(keyBuff, 0);
}
inserted.Add(key);
tree.Insert(txnId, key, value);
if (i % 250 == 0)
{
tree.Save((ulong)i / 250, null);
pageStore.Commit((ulong)i / 250, null);
Assert.AreEqual(i, tree.Scan(0, ulong.MaxValue, null).Count());
Console.WriteLine("Dump tree @ commit after {0}", i);
tree.DumpStructure();
}
}
}
}
public void TestInsertAndDeleteInReverseOrder()
{
const string pageStoreName = "TestInsertAndDeleteInReverseOrder.data";
var value = new byte[64];
ulong rootPageId;
const int keyCount = 20000;
using (var pageStore = TestUtils.CreateEmptyPageStore(pageStoreName))
{
var tree = new BPlusTree(pageStore);
for (int i = 0; i < keyCount; i++)
{
tree.Insert(0, (ulong)i, value);
}
rootPageId = tree.Save(0, null);
pageStore.Commit(0, null);
}
using (var pageStore = TestUtils.OpenPageStore(pageStoreName, false))
{
var tree = new BPlusTree(pageStore, rootPageId);
for (int i = keyCount - 1; i >= 0; i--)
{
tree.Delete(1, (ulong)i, null);
}
rootPageId = tree.Save(1, null);
pageStore.Commit(0, null);
}
using (var pageStore = TestUtils.OpenPageStore(pageStoreName, false))
{
var tree = new BPlusTree(pageStore, rootPageId);
Assert.AreEqual(0, tree.Scan(null).Count(), "Expected and empty tree after all deletes");
}
}
private static long TestInIncreasingOrder(int maxDegree)
{
long memBefore = GC.GetTotalMemory(false);
Stopwatch sw = Stopwatch.StartNew();
BPlusTree <long, Measurement> bPlusTree = new BPlusTree <long, Measurement>(maxDegree);
for (int i = 1; i <= NUMBER_OF_INSERTION; i++)
{
bPlusTree.Insert(i, new Measurement());
}
sw.Stop();
long memAfter = GC.GetTotalMemory(false);
Console.WriteLine("Increasing order. Insert {0} elements: {1} ms", NUMBER_OF_INSERTION, sw.ElapsedMilliseconds);
Console.WriteLine("Memory: {0} MBytes", (memAfter - memBefore) / 1024 / 1024);
Console.WriteLine("Height: {0} ", bPlusTree.GetHeight());
HashSet <long> allWrittenNumbers = new HashSet <long>();
for (int i = 1; i <= NUMBER_OF_INSERTION; i++)
{
allWrittenNumbers.Add(i);
}
CheckCorrectness(bPlusTree, allWrittenNumbers);
return(sw.ElapsedMilliseconds);
}
public void TestMergeLeft()
{
using (var pageStore = TestUtils.CreateEmptyPageStore("TestMergeLeft.data"))
{
var tree = new BPlusTree(pageStore);
var testBytes = new byte[] { 1, 2, 3, 4 };
var buff = new byte[_config.ValueSize];
var txnId = 0ul;
for (int i = 0; i < _config.LeafLoadFactor * _config.InternalBranchFactor; i++)
{
tree.Insert(txnId, (ulong)i, testBytes);
}
ulong delFrom = (ulong)(_config.LeafLoadFactor * _config.InternalBranchFactor) - 1;
ulong delRange = ((ulong)_config.LeafLoadFactor / 2) + 2;
for (ulong i = 0; i < delRange; i++)
{
tree.Delete(txnId, delFrom - i, null); // Should be enough to force a left merge
}
for (ulong i = 0; i < delFrom; i++)
{
Assert.IsTrue((delFrom - i < delRange) ^ tree.Search(i, buff, null),
"Failed to find key {0} after deletes", i);
}
}
}
public void TestBorrowRight()
{
using (var pageStore = TestUtils.CreateEmptyPageStore("TestBorrowRight.data"))
{
var txnId = 0ul;
var tree = new BPlusTree(txnId, pageStore);
var config = tree.Configuration;
var buff = new byte[config.ValueSize];
for (int i = 0; i <= config.LeafLoadFactor; i++)
{
tree.Insert(txnId, (ulong)i, BitConverter.GetBytes((ulong)i));
}
//Console.WriteLine("Before deletes:");
//tree.DumpStructure();
tree.Delete(txnId, 13ul, null);
tree.Delete(txnId, 12ul, null); // Should force a borrow frrom the right node
//Console.WriteLine("After Deletes");
//tree.DumpStructure();
for (int i = 0; i <= config.LeafLoadFactor; i++)
{
Assert.IsTrue(i == 12 ^ i == 13 ^ tree.Search((ulong)i, buff, null),
"Could not find entry for key {0}", i);
}
}
}
private static void TestInRandomOrder2()
{
Random rnd = new Random(Environment.TickCount);
HashSet <long> allWrittenNumbers = new HashSet <long>();
for (int i = 1; i <= 87; i++)
{
int value = rnd.Next();
while (allWrittenNumbers.Contains(value))
{
value = rnd.Next();
}
allWrittenNumbers.Add(value);
}
long memBefore = GC.GetTotalMemory(false);
Stopwatch sw = Stopwatch.StartNew();
BPlusTree <long, Measurement> bPlusTree = new BPlusTree <long, Measurement>(12);
foreach (var value in allWrittenNumbers)
{
bPlusTree.Insert(value, new Measurement());
}
sw.Stop();
long memAfter = GC.GetTotalMemory(false);
Console.WriteLine("Random order. Insert {0} elements: {1} ms", NUMBER_OF_INSERTION, sw.ElapsedMilliseconds);
Console.WriteLine("Memory: {0} MBytes", (memAfter - memBefore) / 1024 / 1024);
Console.WriteLine("Height: {0} ", bPlusTree.GetHeight());
CheckCorrectness(bPlusTree, allWrittenNumbers);
}
public void TestInsertInRandomOrder()
{
ulong treeRootId;
using (var pageStore = TestUtils.CreateEmptyPageStore("TestInsertInRandomOrder.data"))
{
var tree = new BPlusTree(pageStore);
var txnId = 0ul;
foreach (var insertValue in TestUtils.MakeRandomInsertList(100000))
{
tree.Insert(txnId, (ulong)insertValue, BitConverter.GetBytes(insertValue));
}
treeRootId = tree.Save(txnId, null);
pageStore.Commit(txnId, null);
}
using (var pageStore = TestUtils.OpenPageStore("TestInsertInRandomOrder.data", true))
{
var tree = new BPlusTree(pageStore, treeRootId);
var buff = new byte[_config.ValueSize];
for (int i = 0; i < 100000; i++)
{
Assert.IsTrue(tree.Search((ulong)i, buff, null), "Could not find key {0} in tree", i);
TestUtils.AssertBuffersEqual(BitConverter.GetBytes(i), buff);
}
}
}
public void InsertTest()
{
var bTree = new BPlusTree <int>();
foreach (var item in TestData1)
{
bTree.Insert(item);
}
}
public void TestDeleteFromLeafRoot()
{
using (var pageStore = TestUtils.CreateEmptyPageStore("TestDeleteFromLeafRoot.data"))
{
var tree = new BPlusTree(pageStore);
var txnId = 0ul;
var buff = new byte[_config.ValueSize];
tree.Insert(txnId, 1ul, TestUtils.StringToByteArray("one"));
tree.Insert(txnId, 2ul, TestUtils.StringToByteArray("two"));
tree.Insert(txnId, 3ul, TestUtils.StringToByteArray("three"));
tree.Delete(txnId, 2ul, null);
Assert.IsTrue(tree.Search(1ul, buff, null));
TestUtils.AssertBuffersEqual(TestUtils.StringToByteArray("one"), buff);
Assert.IsTrue(tree.Search(3ul, buff, null));
TestUtils.AssertBuffersEqual(TestUtils.StringToByteArray("three"), buff);
Assert.IsFalse(tree.Search(2ul, buff, null));
}
}
public void Execute(uint stage, SharpMedia.Database.Physical.Journalling.IService service)
{
// 1) We create the object.
BlockStream stream = service.AllocationContext.CreateBlockStream((ulong)objectData.LongLength);
stream.Write(objectData);
// 2) We insert to B+ tree.
tree.Insert(service, before, new ObjectInfo(index, (ulong)objectData.LongLength, stream.BaseAddress));
}
public static void BPlusTreeTest()
{
BPlusTree tree = new BPlusTree(3);
int[] datas = { 8, 11, 12, 16, 17, 22, 23, 31, 41, 52, 58, 59, 61 };
foreach (int num in datas)
{
tree.Insert(num);
}
}
public void Delete_TheOnlyKeyInTree_ExpectsNoNodeAndNoKeyAfter()
{
var tree = new BPlusTree <int, string>(3);
tree.Insert(new KeyValuePair <int, string>(10, "A"));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 2, 1, 2);
/* Deleting the only key in the only leaf node of the tree. */
Assert.IsTrue(tree.Delete(10));
BTreeTestsUtils.HasBPlusTreeProperties(tree, 0, 0, 0);
}
public void TestInsertSingleRootSplit()
{
ulong rootId;
using (var pageStore = TestUtils.CreateEmptyPageStore("TestInsertSingleRootSplit.data"))
{
var txnId = 0ul;
var tree = new BPlusTree(txnId, pageStore);
var config = tree.Configuration;
var buff = new byte[config.ValueSize];
for (int i = 0; i < config.LeafLoadFactor; i++)
{
tree.Insert(txnId, (ulong)i, BitConverter.GetBytes((ulong)i));
}
tree.Insert(txnId, (ulong)config.LeafLoadFactor, BitConverter.GetBytes((ulong)config.LeafLoadFactor));
Assert.IsTrue(tree.Search(14, buff, null));
// Check we can find all the values inserted so far
for (int i = 0; i <= config.LeafLoadFactor; i++)
{
Assert.IsTrue(tree.Search((ulong)i, buff, null));
}
tree.Save(txnId, null);
pageStore.Commit(txnId, null);
rootId = tree.RootId;
}
using (var pageStore = TestUtils.OpenPageStore("TestInsertSingleRootSplit.data", true))
{
var tree = new BPlusTree(pageStore, rootId);
var config = tree.Configuration;
var buff = new byte[config.ValueSize];
for (int i = 0; i <= config.LeafLoadFactor; i++)
{
Assert.IsTrue(tree.Search((ulong)i, buff, null), "Could not find entry for key {0}", i);
var value = BitConverter.ToUInt64(buff, 0);
Assert.AreEqual((ulong)i, value);
}
}
}
public BPlusTree <string> CreateAlphabetTree()
{
var bTree = new BPlusTree <string>();
bTree.MinLimit = 3;
foreach (var item in Alphabet)
{
bTree.Insert(item);
}
;
return(bTree);
}
public void TryFindExact_ContainsKey()
{
BPlusTree <long, long> bPlusTree = new BPlusTree <long, long>(3);
bPlusTree.Insert(1, 1);
bPlusTree.Insert(2, 2);
bPlusTree.Insert(3, 3);
bPlusTree.Insert(4, 4);
bPlusTree.Insert(5, 5);
bPlusTree.Insert(6, 6);
long value;
Assert.IsTrue(bPlusTree.TryFindExact(1, out value));
Assert.AreEqual(1, value);
Assert.IsTrue(bPlusTree.TryFindExact(2, out value));
Assert.AreEqual(2, value);
Assert.IsTrue(bPlusTree.TryFindExact(3, out value));
Assert.AreEqual(3, value);
Assert.IsTrue(bPlusTree.TryFindExact(4, out value));
Assert.AreEqual(4, value);
Assert.IsTrue(bPlusTree.TryFindExact(5, out value));
Assert.AreEqual(5, value);
Assert.IsTrue(bPlusTree.TryFindExact(6, out value));
Assert.AreEqual(6, value);
}
public void TestMergeRight()
{
using (var pageStore = TestUtils.CreateEmptyPageStore("TestMergeRight.data"))
{
var tree = new BPlusTree(pageStore);
var testBytes = new byte[] { 1, 2, 3, 4 };
var buff = new byte[_config.ValueSize];
var txnId = 0ul;
for (int i = 0; i < _config.LeafLoadFactor * _config.InternalBranchFactor; i++)
{
try
{
tree.Insert(txnId, (ulong)i, testBytes);
}
catch (Exception ex)
{
Assert.Fail("Insert failed for key {0} with exception {1}", i, ex);
}
}
var rootNode = tree.GetNode(tree.RootId, null);
var childId = (rootNode as InternalNode).GetChildNodeId(rootNode.RightmostKey);
var child = tree.GetNode(childId, null) as InternalNode;
var childLeftmostKey = BitConverter.ToUInt64(child.LeftmostKey, 0);
var grandchild =
tree.GetNode(child.GetChildNodeId(BitConverter.GetBytes(childLeftmostKey - 1)), null) as LeafNode;
var deleteFrom = BitConverter.ToUInt64(grandchild.LeftmostKey, 0);
var findChildId = (rootNode as InternalNode).GetChildNodeId(BitConverter.GetBytes(deleteFrom));
Assert.AreEqual(child.PageId, findChildId, "Incorrect node id returned for key {0}", deleteFrom);
for (ulong i = 0; i < 4; i++)
{
var deleteKey = deleteFrom + i;
tree.Delete(txnId, deleteKey, null); // Should be enough to force a right merge
}
for (ulong i = 0; i < (ulong)(_config.LeafLoadFactor * _config.InternalBranchFactor); i++)
{
Assert.IsTrue(tree.Search(i, buff, null) ^ (i - deleteFrom >= 0 && i - deleteFrom < 4),
"Could not find key {0}. deleteFrom={1}", i, deleteFrom);
}
deleteFrom = (ulong)(_config.LeafLoadFactor * _config.InternalBranchFactor) - 5;
for (ulong i = 0; i < 4; i++)
{
var deleteKey = deleteFrom + i;
tree.Delete(txnId, deleteKey, null);
}
}
}
public void TestCoalesceRootLeafNode()
{
const string storeName = "Coalesce.RootLeafNode.data";
ulong srcRootId, targetRootId;
var txnId = 0ul;
using (var store = TestUtils.CreateEmptyPageStore(storeName))
{
var sourceTree = new BPlusTree(0, store);
var config = sourceTree.Configuration;
for (int i = 0; i < config.LeafLoadFactor; i++)
{
sourceTree.Insert(txnId, (ulong)i, BitConverter.GetBytes((ulong)i));
}
sourceTree.DumpStructure();
srcRootId = sourceTree.Save(txnId, null);
store.Commit(txnId, null);
}
using (var store = TestUtils.OpenPageStore(storeName, false))
{
var sourceTree = new BPlusTree(store, srcRootId);
var config = sourceTree.Configuration;
var builder = new BPlusTreeBuilder(store, config);
targetRootId = builder.Build(1, sourceTree.Scan(null));
var targetTree = new BPlusTree(store, targetRootId);
targetTree.DumpStructure();
byte[] valueBuff = new byte[64];
for (int i = 0; i < config.LeafLoadFactor; i++)
{
Assert.IsTrue(targetTree.Search((ulong)i, valueBuff, null));
Assert.AreEqual((ulong)i, BitConverter.ToUInt64(valueBuff, 0));
}
store.Commit(1, null);
}
using (var store = TestUtils.OpenPageStore(storeName, true))
{
var targetTree = new BPlusTree(store, targetRootId);
var config = targetTree.Configuration;
targetTree.DumpStructure();
byte[] valueBuff = new byte[64];
for (int i = 0; i < config.LeafLoadFactor; i++)
{
Assert.IsTrue(targetTree.Search((ulong)i, valueBuff, null));
Assert.AreEqual((ulong)i, BitConverter.ToUInt64(valueBuff, 0));
}
}
}
private BPlusTree <int> CreateTree(IEnumerable <int> datas)
{
var bTree = new BPlusTree <int>();
var insertedDatas = new List <int>();
foreach (var item in datas)
{
bTree.Insert(item);
insertedDatas.Add(item);
}
return(bTree);
}
public void InsertDelete(IList <int> datas)
{
var bTree = new BPlusTree <int>();
Console.WriteLine();
TestHepler.PrintList(datas, "InsertDeleteTestStartData");
for (int i = 0; i < datas.Count; i++)
{
var data = datas[i];
Console.Write("{0} ", data);
if (data % 3 == 0)
{
bTree.Delete(data);
var preData = int.MinValue;
Console.WriteLine();
Console.WriteLine("InsertDeleteTest delete order start");
bTree.Order(bTree.Root, (d) =>
{
Console.Write("{0}, ", d);
Assert.IsTrue(preData <= d);
preData = d;
});
Console.WriteLine();
Console.WriteLine("InsertDeleteTest delete order end");
}
else
{
bTree.Insert(data);
var preData = int.MinValue;
Console.WriteLine();
Console.WriteLine("InsertDeleteTest insert order start");
bTree.Order(bTree.Root, (d) =>
{
Console.Write("{0}, ", d);
Assert.IsTrue(preData <= d);
preData = d;
});
Console.WriteLine();
Console.WriteLine("InsertDeleteTest insert order end");
}
}
Console.WriteLine();
}
public void Insert_IncreasingOrder()
{
for (int maxDegree = 3; maxDegree <= 101; maxDegree++)
{
BPlusTree <long, long> bPlusTree = new BPlusTree <long, long>(maxDegree);
var itemsToInsert = GetIncreasingCollection(NUMBER_OF_INSERTION);
foreach (var item in itemsToInsert)
{
var k = (long)item;
var v = (long)item;
bPlusTree.Insert(k, v);
}
Assert.IsTrue(Helpers.CheckNodes(bPlusTree.Root));
Assert.AreEqual(NUMBER_OF_INSERTION, bPlusTree.Count);
CollectionAssert.AreEqual(itemsToInsert, DumpKeysOnLeafNodes(bPlusTree));
}
}
public void TestBorrowRight()
{
using (var pageStore = TestUtils.CreateEmptyPageStore("TestBorrowRight.data"))
{
var tree = new BPlusTree(pageStore);
var buff = new byte[_config.ValueSize];
var txnId = 0ul;
for (int i = 0; i <= _config.LeafLoadFactor; i++)
{
tree.Insert(txnId, (ulong)i, BitConverter.GetBytes((ulong)i));
}
tree.Delete(txnId, 13ul, null);
tree.Delete(txnId, 12ul, null); // Should force a borrow frrom the right node
for (int i = 0; i <= _config.LeafLoadFactor; i++)
{
Assert.IsTrue(i == 12 ^ i == 13 ^ tree.Search((ulong)i, buff, null));
}
}
}
