public void HeaderPage_Savepoint()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 1);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new header page
var header = new HeaderPage(buffer, 0);
header.InsertCollection("my-col1", 1);
header.InsertCollection("my-col2", 2);
header.GetCollections().Count().Should().Be(2);
// savepoint alse execute UpdateBuffer
var sp = header.Savepoint();
header.DeleteCollection("my-col1");
header.DeleteCollection("my-col2");
header.UpdateBuffer();
header.GetCollections().Count().Should().Be(0);
// now, restore header
header.Restore(sp);
header.GetCollections().Count().Should().Be(2);
buffer.ShareCounter = 0;
}
public void BasePage_Insert_Full_Items_Page()
{
// create new memory area
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 1);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new base page
var page = new BasePage(buffer, 1, PageType.Empty);
// create 255 page segments
for (byte i = 0; i < byte.MaxValue; i++)
{
page.Insert(10, out var index).Fill(i);
}
Assert.AreEqual(255, page.ItemsCount);
Assert.AreEqual(2550, page.UsedBytes);
Assert.AreEqual(0, page.FreeBytes);
Assert.AreEqual(32 + 2550, page.NextFreePosition);
buffer.ShareCounter = 0;
}
public void HeaderPage_Collections()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 1);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new header page
var header = new HeaderPage(buffer, 0);
header.InsertCollection("my-col1", 1);
header.InsertCollection("my-col2", 2);
header.GetCollections().Count().Should().Be(2);
((int)header.GetCollectionPageID("my-col1")).Should().Be(1);
((int)header.GetCollectionPageID("my-col2")).Should().Be(2);
header.GetAvaiableCollectionSpace().Should().Be(7981);
header.UpdateBuffer();
// read header
var h2 = new HeaderPage(buffer);
h2.GetCollections().Count().Should().Be(2);
((int)h2.GetCollectionPageID("my-col1")).Should().Be(1);
((int)h2.GetCollectionPageID("my-col2")).Should().Be(2);
h2.GetAvaiableCollectionSpace().Should().Be(7981);
buffer.ShareCounter = 0;
}
public void Pragma_RunTests()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 1);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new header page
var header = new HeaderPage(buffer, 0);
this.Invoking(x => header.Pragmas.Get("INEXISTENT_PRAGMA")).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set("USER_VERSION", "invalid value", true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set("USER_VERSION", 1, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set("COLLATION", "en-US/IgnoreCase", true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set("TIMEOUT", -1, true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set("TIMEOUT", 1, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set("LIMIT_SIZE", 1000, true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set("LIMIT_SIZE", (Convert.ToInt32(header.LastPageID)) * Constants.PAGE_SIZE - 1, true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set("LIMIT_SIZE", 1024L * 1024L * 1024L * 1024L, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set("UTC_DATE", true, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set("CHECKPOINT", -1, true)).Should().Throw <Exception>();
}
public void Pragma_RunTests()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 1);
// create new header page
var header = new HeaderPage(buffer, 0);
this.Invoking(x => header.Pragmas.Get("INEXISTENT_PRAGMA")).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set(Pragmas.USER_VERSION, "invalid value", true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set(Pragmas.USER_VERSION, 1, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set(Pragmas.COLLATION, "en-US/IgnoreCase", true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set(Pragmas.TIMEOUT, -1, true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set(Pragmas.TIMEOUT, 1, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set(Pragmas.LIMIT_SIZE, 1000, true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set(Pragmas.LIMIT_SIZE, (Convert.ToInt32(header.LastPageID)) * Constants.PAGE_SIZE - 1, true)).Should().Throw <Exception>();
this.Invoking(x => header.Pragmas.Set(Pragmas.LIMIT_SIZE, 1024L * 1024L * 1024L * 1024L, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set(Pragmas.UTC_DATE, true, true)).Should().NotThrow();
this.Invoking(x => header.Pragmas.Set(Pragmas.CHECKPOINT, -1, true)).Should().Throw <Exception>();
}
public void BasePage_Delete()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 0);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new base page
var page = new BasePage(buffer, 1, PageType.Empty);
var seg0 = page.Insert(100, out var index0);
var seg1 = page.Insert(200, out var index1);
var seg2 = page.Insert(300, out var index2);
Assert.AreEqual(2, page.HighestIndex);
Assert.AreEqual(3, page.ItemsCount);
Assert.AreEqual(600, page.UsedBytes);
Assert.AreEqual(32 + 600, page.NextFreePosition);
Assert.AreEqual(8192 - 32 - 12 - 600, page.FreeBytes); // page size - header - footer - used
Assert.AreEqual(0, page.FragmentedBytes);
// deleting 300b (end of page)
page.Delete(index2);
Assert.AreEqual(1, page.HighestIndex);
Assert.AreEqual(2, page.ItemsCount);
Assert.AreEqual(300, page.UsedBytes);
Assert.AreEqual(32 + 300, page.NextFreePosition);
Assert.AreEqual(8192 - 32 - 8 - 300, page.FreeBytes);
Assert.AreEqual(0, page.FragmentedBytes);
// deleting 100b (middle of page) - create data fragment
page.Delete(index0);
Assert.AreEqual(1, page.HighestIndex);
Assert.AreEqual(1, page.ItemsCount);
Assert.AreEqual(200, page.UsedBytes);
Assert.AreEqual(32 + 300, page.NextFreePosition); // 200 + 100 (fragmented)
Assert.AreEqual(8192 - 32 - 8 - 200, page.FreeBytes);
Assert.AreEqual(100, page.FragmentedBytes);
// delete 200b - last item
page.Delete(index1);
// after delete last item page will be defrag
Assert.AreEqual(byte.MaxValue, page.HighestIndex);
Assert.AreEqual(0, page.ItemsCount);
Assert.AreEqual(0, page.UsedBytes);
Assert.AreEqual(32, page.NextFreePosition);
Assert.AreEqual(8192 - 32, page.FreeBytes);
Assert.AreEqual(0, page.FragmentedBytes);
buffer.ShareCounter = 0;
}
private void ConsumeNewPages(int[] segmentSizes)
{
var m = new MemoryCache(segmentSizes);
// Test some additional segments using last segment size more than once
var totalSegments = segmentSizes.Sum() + 10;
for (int i = 1; i <= totalSegments; i++)
{
PageBuffer p = m.NewPage();
p.UniqueID.Should().Be(i);
// Set ShareCounter to 0 to proper disposal (not needed in this test)
p.ShareCounter = 0;
}
}
public void BasePage_Insert()
{
// create new memory area with 10 bytes offset (just for fun)
var data = new byte[Constants.PAGE_SIZE + 10];
var buffer = new PageBuffer(data, 10, 1);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new base page
var page = new BasePage(buffer, 1, PageType.Empty);
page.Insert(10, out var index0).Fill(1);
page.Insert(20, out var index1).Fill(2);
page.Insert(30, out var index2).Fill(3);
page.Insert(40, out var index3).Fill(4);
Assert.AreEqual(0, page.FragmentedBytes);
Assert.AreEqual(100, page.UsedBytes);
Assert.AreEqual(32 + 100, page.NextFreePosition);
Assert.AreEqual(4 * 4, page.FooterSize);
Assert.AreEqual(8192 - 32 - 100 - (4 * 4), page.FreeBytes);
Assert.IsTrue(page.Get(index0).All(1));
Assert.IsTrue(page.Get(index1).All(2));
Assert.IsTrue(page.Get(index2).All(3));
Assert.IsTrue(page.Get(index3).All(4));
// update header buffer
page.UpdateBuffer();
// let's create another page instance based on same page buffer
var page2 = new BasePage(buffer);
Assert.AreEqual(1, (int)page.PageID);
Assert.AreEqual(PageType.Empty, page.PageType);
Assert.IsTrue(page.Get(index0).All(1));
Assert.IsTrue(page.Get(index1).All(2));
Assert.IsTrue(page.Get(index2).All(3));
Assert.IsTrue(page.Get(index3).All(4));
buffer.ShareCounter = 0;
}
public void BasePage_Defrag()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 0);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
var page = new BasePage(buffer, 1, PageType.Empty);
page.Insert(100, out var index0).Fill(101);
page.Insert(200, out var index1).Fill(102);
page.Insert(300, out var index2).Fill(103);
page.Insert(400, out var index3).Fill(104);
page.FragmentedBytes.Should().Be(0);
page.UsedBytes.Should().Be(1000);
page.NextFreePosition.Should().Be(32 + 1000);
page.Delete(index0);
page.Delete(index1);
page.FragmentedBytes.Should().Be(300);
page.UsedBytes.Should().Be(700);
page.NextFreePosition.Should().Be(32 + 1000);
// fill all page
page.Insert(7440, out var index4).Fill(105); // 8192 - 32 - (4 * 4) - 700
page.FragmentedBytes.Should().Be(0);
page.UsedBytes.Should().Be(8140);
page.NextFreePosition.Should().Be(8172);
page.Get(index2).All(103).Should().BeTrue();
page.Get(index3).All(104).Should().BeTrue();
page.Get(index4).All(105).Should().BeTrue();
page.GetUsedIndexs().ToArray().Should().Equal(0, 2, 3);
buffer.ShareCounter = 0;
}
public void BasePage_Defrag()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 0);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
var page = new BasePage(buffer, 1, PageType.Empty);
page.Insert(100, out var index0).Fill(101);
page.Insert(200, out var index1).Fill(102);
page.Insert(300, out var index2).Fill(103);
page.Insert(400, out var index3).Fill(104);
Assert.AreEqual(0, page.FragmentedBytes);
Assert.AreEqual(1000, page.UsedBytes);
Assert.AreEqual(32 + 1000, page.NextFreePosition);
page.Delete(index0);
page.Delete(index1);
Assert.AreEqual(300, page.FragmentedBytes);
Assert.AreEqual(700, page.UsedBytes);
Assert.AreEqual(32 + 1000, page.NextFreePosition);
page.Defrag();
Assert.AreEqual(0, page.FragmentedBytes);
Assert.AreEqual(700, page.UsedBytes);
Assert.AreEqual(32 + 700, page.NextFreePosition);
Assert.IsTrue(page.Get(index2).All(103));
Assert.IsTrue(page.Get(index3).All(104));
CollectionAssert.AreEqual(new byte[] { 2, 3 }, page.GetUsedIndexs().ToArray());
buffer.ShareCounter = 0;
}
public void BasePage_Insert_Full_Bytes_Page()
{
// create new memory area
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 1);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new base page
var page = new BasePage(buffer, 1, PageType.Empty);
var full = page.FreeBytes - BasePage.SLOT_SIZE;
page.Insert((ushort)full, out var index0).Fill(1);
Assert.AreEqual(1, page.ItemsCount);
Assert.AreEqual(full, page.UsedBytes);
Assert.AreEqual(0, page.FreeBytes);
Assert.AreEqual(32 + full, page.NextFreePosition);
buffer.ShareCounter = 0;
}
public void BasePage_Test_Output()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 0);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
var page = new BasePage(buffer, 1, PageType.Empty);
page.Insert(100, out var index0).Fill(101);
page.Insert(7900, out var index1).Fill(102);
page.Insert(100, out var index2).Fill(103);
page.FragmentedBytes.Should().Be(0);
page.UsedBytes.Should().Be(8100);
page.NextFreePosition.Should().Be(8132);
page.Delete(index1);
page.Insert(7948 - 4, out var index3).Fill(104);
buffer.ShareCounter = 0;
}
public void BasePage_Update()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 0);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
var page = new BasePage(buffer, 1, PageType.Empty);
page.Insert(100, out var index0).Fill(101);
page.Insert(200, out var index1).Fill(102);
page.Insert(300, out var index2).Fill(103);
page.Insert(400, out var index3).Fill(104);
Assert.AreEqual(0, page.FragmentedBytes);
Assert.AreEqual(1000, page.UsedBytes);
Assert.AreEqual(32 + 1000, page.NextFreePosition);
// update same segment length
page.Update(index0, 100).Fill(201);
Assert.IsTrue(page.Get(index0).All(201));
Assert.AreEqual(0, page.FragmentedBytes);
Assert.AreEqual(1000, page.UsedBytes);
Assert.AreEqual(32 + 1000, page.NextFreePosition);
// less bytes (segment in middle of page)
page.Update(index1, 150).Fill(202);
Assert.IsTrue(page.Get(index1).All(202));
Assert.AreEqual(50, page.FragmentedBytes);
Assert.AreEqual(950, page.UsedBytes);
Assert.AreEqual(32 + 1000, page.NextFreePosition);
// less bytes (segment in end of page)
page.Update(index3, 350).Fill(204);
Assert.IsTrue(page.Get(index3).All(204));
Assert.AreEqual(50, page.FragmentedBytes);
Assert.AreEqual(900, page.UsedBytes);
Assert.AreEqual(32 + 950, page.NextFreePosition);
// more bytes (segment in end of page)
page.Update(index3, 550).Fill(214);
Assert.IsTrue(page.Get(index3).All(214));
Assert.AreEqual(50, page.FragmentedBytes);
Assert.AreEqual(1100, page.UsedBytes);
Assert.AreEqual(32 + 1150, page.NextFreePosition);
// more bytes (segment in middle of page)
page.Update(index0, 200).Fill(211);
Assert.IsTrue(page.Get(index0).All(211));
Assert.AreEqual(150, page.FragmentedBytes);
Assert.AreEqual(1200, page.UsedBytes);
Assert.AreEqual(32 + 1350, page.NextFreePosition);
buffer.ShareCounter = 0;
}
public void BasePage_Delete_Full()
{
var data = new byte[Constants.PAGE_SIZE];
var buffer = new PageBuffer(data, 0, 0);
// mark buffer as writable (debug propose)
buffer.ShareCounter = Constants.BUFFER_WRITABLE;
// create new base page
var page = new BasePage(buffer, 1, PageType.Empty);
var seg0 = page.Insert(100, out var index0);
var seg1 = page.Insert(200, out var index1);
var seg2 = page.Insert(8192 - 32 - (100 + 200 + 8) - 4, out var index2); // 7848
seg0.Fill(10);
seg1.Fill(11);
seg2.Fill(12);
page.HighestIndex.Should().Be(2);
page.ItemsCount.Should().Be(3);
page.UsedBytes.Should().Be(8148);
page.NextFreePosition.Should().Be(8180); // no next free position
page.FreeBytes.Should().Be(0); // full used
page.FragmentedBytes.Should().Be(0);
// deleting 200b (end of page)
page.Delete(index1);
page.HighestIndex.Should().Be(2);
page.ItemsCount.Should().Be(2);
page.UsedBytes.Should().Be(8148 - 200);
page.NextFreePosition.Should().Be(8180);
page.FreeBytes.Should().Be(200);
page.FragmentedBytes.Should().Be(200);
page.Delete(index0);
page.HighestIndex.Should().Be(2);
page.ItemsCount.Should().Be(1);
page.UsedBytes.Should().Be(8148 - 200 - 100);
page.NextFreePosition.Should().Be(8180);
page.FreeBytes.Should().Be(300);
page.FragmentedBytes.Should().Be(300);
var seg3 = page.Insert(250, out var index3);
seg3.Fill(13);
page.HighestIndex.Should().Be(2);
page.ItemsCount.Should().Be(2);
page.UsedBytes.Should().Be(8148 - 200 - 100 + 250);
page.NextFreePosition.Should().Be(8180 - 50);
page.FreeBytes.Should().Be(50);
page.FragmentedBytes.Should().Be(0);
var seg3f = page.Get(index3);
seg3f.All(13).Should().BeTrue();
buffer.ShareCounter = 0;
}
