public void DebugValidate(Transaction tx, long root)
{
if (NumberOfEntries == 0)
{
return;
}
var prev = GetNodeKey(0);
var pages = new HashSet <long>();
for (int i = 1; i < NumberOfEntries; i++)
{
var node = GetNode(i);
var current = GetNodeKey(i);
if (prev.Compare(current) >= 0)
{
DebugStuff.RenderAndShow(tx, root, 1);
throw new InvalidOperationException("The page " + PageNumber + " is not sorted");
}
if (node->Flags == (NodeFlags.PageRef))
{
if (pages.Add(node->PageNumber) == false)
{
DebugStuff.RenderAndShow(tx, root, 1);
throw new InvalidOperationException("The page " + PageNumber + " references same page multiple times");
}
}
prev = current;
}
}
public Task FixedSizeTreeStructure()
{
var treeName = GetStringQueryString("name", required: true);
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (var tx = context.OpenReadTransaction())
{
FixedSizeTree tree;
try
{
tree = tx.InnerTransaction.FixedTreeFor(treeName);
}
catch (Exception e)
{
throw new InvalidOperationException("Existing trees: " +
string.Join(", ", GetTreeNames(tx.InnerTransaction, RootObjectType.FixedSizeTree))
, e);
}
HttpContext.Response.ContentType = "text/html";
DebugStuff.DumpFixedSizedTreeToStream(tx.InnerTransaction.LowLevelTransaction, tree, ResponseBodyStream());
}
return(Task.CompletedTask);
}
public void DebugValidateTree(long rootPageNumber)
{
var pages = new HashSet <long>();
var stack = new Stack <Page>();
var root = _tx.GetReadOnlyPage(rootPageNumber);
stack.Push(root);
pages.Add(rootPageNumber);
while (stack.Count > 0)
{
var p = stack.Pop();
if (p.NumberOfEntries == 0 && p != root)
{
DebugStuff.RenderAndShow(_tx, rootPageNumber, 1);
throw new InvalidOperationException("The page " + p.PageNumber + " is empty");
}
p.DebugValidate(_tx, rootPageNumber);
if (p.IsBranch == false)
{
continue;
}
for (int i = 0; i < p.NumberOfEntries; i++)
{
var page = p.GetNode(i)->PageNumber;
if (pages.Add(page) == false)
{
DebugStuff.RenderAndShow(_tx, rootPageNumber, 1);
throw new InvalidOperationException("The page " + page + " already appeared in the tree!");
}
stack.Push(_tx.GetReadOnlyPage(page));
}
}
}
public void CouldNotReadPagesThatWereFilteredOutByJournalApplicator_2()
{
var bytes = new byte[1000];
using (var txw = Env.WriteTransaction())
{
var tree = txw.CreateTree("foo");
tree.Add("bars/1", new MemoryStream(bytes));
tree.Add("bars/2", new MemoryStream(bytes));
tree.Add("bars/3", new MemoryStream(bytes));
tree.Add("bars/4", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(tree);
}
using (var txw = Env.WriteTransaction())
{
var tree = txw.CreateTree("foo");
tree.Add("bars/0", new MemoryStream());
tree.Add("bars/5", new MemoryStream());
txw.Commit();
DebugStuff.RenderAndShow(tree);
}
using (var txw = Env.WriteTransaction())
{
txw.CreateTree("bar");
txw.Commit();
}
using (var txw = Env.WriteTransaction())
{
txw.CreateTree("baz");
txw.Commit();
}
using (var txr = Env.ReadTransaction())
{
using (var txw = Env.WriteTransaction())
{
var tree = txw.CreateTree("foo");
tree.Add("bars/4", new MemoryStream());
txw.Commit();
}
Env.FlushLogToDataFile();
Assert.NotNull(txr.CreateTree("foo").Read("bars/5"));
}
}
public void ShouldNotThrowPageFullExceptionDuringPageSplit()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(tx, "foo");
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("foo");
var normal = new byte[150];
var small = new byte[0];
var large = new byte[366];
new Random(1).NextBytes(small);
tree.Add("01", small);
tree.Add("02", small);
tree.Add("03", small);
tree.Add("04", small);
tree.Add("05", small);
tree.Add("06", small);
tree.Add("07", small);
tree.Add("08", small);
tree.Add("09", small);
tree.Add("10", small);
tree.Add("11", large);
tree.Add("12", large);
tree.Add("13", large);
tree.Add("14", large);
tree.Add("15", large);
tree.Add("16", large);
tree.Add("17", large);
tree.Add("18", large);
tree.Add("19", large);
tree.Add("21", large);
tree.Add("22", large);
tree.Add("23", large);
tree.Add("24", normal);
tree.Add("25", normal);
tree.Add("26", normal);
tree.Add("27", normal);
tree.Add("28", normal);
tree.Add("29", normal);
tree.Add("30", normal);
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
const int toInsert = 230;
tree.Add("20", new byte[toInsert]);
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
}
}
static void MainForm_WindowLoad(object sender, EventArgs e)
{
DebugStuff.AppStarted();
// Скрываем форму загрузки
SplashForm.Dismiss();
}
protected void RenderAndShow(Transaction tx, Tree root)
{
if (Debugger.IsAttached == false)
{
return;
}
var rootPageNumber = tx.Environment.CreateTree(tx, root.Name).State.RootPageNumber;
DebugStuff.RenderAndShow(root);
}
public void SinglePageModificationDoNotCauseCopyingAllIntermediatePages()
{
var keySize = 1024;
using (var tx = Env.WriteTransaction())
{
var tree = tx.CreateTree("foo");
tree.Add(new string('9', keySize), new MemoryStream(new byte[3]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('1', keySize), new MemoryStream(new byte[3]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('4', 1000), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('5', keySize), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('8', keySize), new MemoryStream(new byte[3]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('2', keySize), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('6', keySize), new MemoryStream(new byte[2]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('0', keySize), new MemoryStream(new byte[4]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('3', 1000), new MemoryStream(new byte[1]));
DebugStuff.RenderAndShow(tree);
tree.Add(new string('7', keySize), new MemoryStream(new byte[1]));
tx.Commit();
}
var afterAdds = Env.NextPageNumber;
using (var tx = Env.WriteTransaction())
{
var tree = tx.CreateTree("foo");
tree.Delete(new string('0', keySize));
tree.Add(new string('4', 1000), new MemoryStream(new byte[21]));
tx.Commit();
}
Assert.Equal(afterAdds, Env.NextPageNumber);
// ensure changes were applied
using (var tx = Env.ReadTransaction())
{
var tree = tx.CreateTree("foo");
Assert.Null(tree.Read(new string('0', keySize)));
var readResult = tree.Read(new string('4', 1000));
Assert.Equal(21, readResult.Reader.Length);
}
}
public void DebugValidate(Tree tree, long root)
{
if (NumberOfEntries == 0)
{
return;
}
#if VALIDATE
if (Freed)
{
return;
}
#endif
if (IsBranch && NumberOfEntries < 2)
{
throw new InvalidOperationException("The branch page " + PageNumber + " has " + NumberOfEntries + " entry");
}
Slice prev;
var prevScope = GetNodeKey(tree.Llt, 0, out prev);
try
{
var pages = new HashSet <long>();
for (int i = 1; i < NumberOfEntries; i++)
{
var node = GetNode(i);
Slice current;
var currentScope = GetNodeKey(tree.Llt, i, out current);
if (SliceComparer.CompareInline(prev, current) >= 0)
{
DebugStuff.RenderAndShowTree(tree, root);
throw new InvalidOperationException("The page " + PageNumber + " is not sorted");
}
if (node->Flags == (TreeNodeFlags.PageRef))
{
if (pages.Add(node->PageNumber) == false)
{
DebugStuff.RenderAndShowTree(tree, root);
throw new InvalidOperationException("The page " + PageNumber + " references same page multiple times");
}
}
prevScope.Dispose();
prev = current;
prevScope = currentScope;
}
}
finally
{
prevScope.Dispose();
}
}
public void ShouldNotThrowThatPageIsFullDuringTreeRebalancing()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "rebalancing-issue");
var aKey = new string('a', 1024);
var bKey = new string('b', 1024);
var cKey = new string('c', 1024);
var dKey = new string('d', 1024);
var eKey = new string('e', 600);
var fKey = new string('f', 920);
tree.Add(aKey, new MemoryStream(new byte[1000]));
tree.Add(bKey, new MemoryStream(new byte[1000]));
tree.Add(cKey, new MemoryStream(new byte[1000]));
tree.Add(dKey, new MemoryStream(new byte[1000]));
tree.Add(eKey, new MemoryStream(new byte[800]));
tree.Add(fKey, new MemoryStream(new byte[10]));
DebugStuff.RenderAndShow(tx, 1);
// to expose the bug we need to delete the last item from the left most page
// tree rebalance will try to fix the first reference (the implicit ref page node) in the parent page which is almost full
// and will fail because there is no space to put a new node
tree.Delete(aKey); // this line throws "The page is full and cannot add an entry, this is probably a bug"
tx.Commit();
using (var iterator = tree.Iterate())
{
Assert.True(iterator.Seek(Slice.BeforeAllKeys));
Assert.Equal(bKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(cKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(dKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(eKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(fKey, iterator.CurrentKey);
Assert.False(iterator.MoveNext());
}
}
}
public unsafe void MustNotCreateEmptyNonCompressedPageAfterPageSplit()
{
using (var tx = Env.WriteTransaction())
{
tx.CreateTree("tree", flags: TreeFlags.LeafsCompressed);
tx.Commit();
}
using (var tx = Env.WriteTransaction())
{
var tree = tx.ReadTree("tree");
Assert.True(tree.State.Flags.HasFlag(TreeFlags.LeafsCompressed));
var bytes = new byte[3070];
const int numberOfItems = 21;
for (int i = 0; i < numberOfItems; i++)
{
tree.Add("items/" + i, new MemoryStream(bytes));
}
for (int i = 1; i < numberOfItems; i++) // skipping one item here
{
tree.Delete("items/" + i);
}
// after the above deletions there is only one entry on the page - "items/0"
DebugStuff.RenderAndShow(tree);
// this is an _update_ (very important)
// the issue was that the updated entry was added to a new (right) page by TreePageSplitter
// while the previous entry was removed from compressed page - effectively making it empty
tree.Add("items/0", new MemoryStream(new byte[3700]));
foreach (var pageNumber in tree.AllPages())
{
var page = new TreePage(tx.LowLevelTransaction.GetPage(pageNumber).Pointer, Constants.Storage.PageSize);
if (page.IsCompressed == false)
{
Assert.NotEqual(0, page.NumberOfEntries);
}
}
Assert.Equal(1, tree.AllPages().Count);
}
}
public void HasReducedTreeDepthValueAfterRemovingEntries()
{
const int numberOfItems = 1024;
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "test");
for (int i = 0; i < numberOfItems; i++)
{
tree.Add("test" + new string('-', 256) + i, new byte[256]);
}
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
Assert.Equal(4, tree.State.Depth);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("test");
for (int i = 0; i < numberOfItems * 0.75; i++)
{
tree.Delete("test" + new string('-', 256) + i);
}
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
Assert.Equal(3, tree.State.Depth);
tx.Commit();
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = tx.ReadTree("test");
for (int i = 0; i < numberOfItems; i++)
{
tree.Delete("test" + new string('-', 256) + i);
}
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber);
Assert.Equal(1, tree.State.Depth);
}
}
public void PageNotSorted_ValidateDebugOption()
{
using (var env = new StorageEnvironment(StorageEnvironmentOptions.CreateMemoryOnly()))
{
env.DebugJournal = DebugJournal.FromFile("Bugs/Data/mapped", env);
env.DebugJournal.Replay();
using (var tx = env.NewTransaction(TransactionFlags.Read))
{
var tree = tx.ReadTree("mapped_results_by_view_and_reduce_key");
DebugStuff.RenderAndShow(tx, tree.State.RootPageNumber, 1);
}
}
}
public async Task BTreeStructure()
{
var treeName = GetStringQueryString("name", required: true);
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (var tx = context.OpenReadTransaction())
{
var tree = tx.InnerTransaction.ReadTree(treeName)
?? throw new InvalidOperationException("Tree name '" + treeName + "' was not found. Existing trees: " +
string.Join(", ", GetTreeNames(tx.InnerTransaction, RootObjectType.VariableSizeTree))
);
HttpContext.Response.ContentType = "text/html";
await DebugStuff.DumpTreeToStreamAsync(tree, ResponseBodyStream());
}
}
public void CouldNotReadPagesThatWereFilteredOutByJournalApplicator_1()
{
var bytes = new byte[1000];
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(tree);
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(txw, "bar");
txw.Commit();
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(txw, "baz");
txw.Commit();
}
using (var txr = Env.NewTransaction(TransactionFlags.Read))
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new MemoryStream());
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
Env.FlushLogToDataFile();
Assert.NotNull(Env.CreateTree(txr, "foo").Read("bars/1"));
}
}
public void HasReducedNumberOfPagesAfterRemovingHalfOfEntries()
{
const int numberOfRegularItems = 256;
const int numberOfOverflowItems = 3;
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < numberOfRegularItems; i++)
{
tx.Root.Add("test" + new string('-', 128) + i, new byte[256]);
}
for (int i = 0; i < numberOfOverflowItems; i++)
{
tx.Root.Add("overflow" + new string('-', 128) + i, new byte[8192]);
}
tx.Commit();
Assert.Equal(50, tx.Root.State.PageCount);
Assert.Equal(38, tx.Root.State.LeafPages);
Assert.Equal(3, tx.Root.State.BranchPages);
Assert.Equal(9, tx.Root.State.OverflowPages);
Assert.Equal(3, tx.Root.State.Depth);
}
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < numberOfRegularItems / 2; i++)
{
tx.Root.Delete("test" + new string('-', 128) + i);
}
tx.Root.Delete("overflow" + new string('-', 128) + 0);
tx.Commit();
DebugStuff.RenderAndShow(tx.Root);
Assert.Equal(31, tx.Root.AllPages().Count);
Assert.Equal(31, tx.Root.State.PageCount);
Assert.Equal(22, tx.Root.State.LeafPages);
Assert.Equal(3, tx.Root.State.BranchPages);
Assert.Equal(6, tx.Root.State.OverflowPages);
Assert.Equal(3, tx.Root.State.Depth);
}
}
protected void RenderAndShow(Transaction tx, Tree root, int showEntries = 25)
{
if (Debugger.IsAttached == false)
{
return;
}
var path = Path.Combine(Environment.CurrentDirectory, "test-tree.dot");
var rootPageNumber = tx.Environment.State.GetTree(tx, root.Name).State.RootPageNumber;
TreeDumper.Dump(tx, path, tx.GetReadOnlyPage(rootPageNumber), showEntries);
var output = Path.Combine(Environment.CurrentDirectory, "output.svg");
var p = Process.Start(DebugStuff.FindGraphviz() + @"\bin\dot.exe", "-Tsvg " + path + " -o " + output);
p.WaitForExit();
Process.Start(output);
}
public void DebugValidateTree(long rootPageNumber)
{
var pages = new HashSet <long>();
var stack = new Stack <TreePage>();
var root = GetReadOnlyTreePage(rootPageNumber);
stack.Push(root);
pages.Add(rootPageNumber);
while (stack.Count > 0)
{
var p = stack.Pop();
using (p.IsCompressed ? (DecompressedLeafPage)(p = DecompressPage(p, skipCache: true)) : null)
{
if (p.NumberOfEntries == 0 && p != root)
{
DebugStuff.RenderAndShowTree(this, rootPageNumber);
throw new InvalidOperationException("The page " + p.PageNumber + " is empty");
}
p.DebugValidate(this, rootPageNumber);
if (p.IsBranch == false)
{
continue;
}
if (p.NumberOfEntries < 2)
{
throw new InvalidOperationException("The branch page " + p.PageNumber + " has " +
p.NumberOfEntries + " entry");
}
for (int i = 0; i < p.NumberOfEntries; i++)
{
var page = p.GetNode(i)->PageNumber;
if (pages.Add(page) == false)
{
DebugStuff.RenderAndShowTree(this, rootPageNumber);
throw new InvalidOperationException("The page " + page + " already appeared in the tree!");
}
stack.Push(GetReadOnlyTreePage(page));
}
}
}
}
public void CanMergeRight()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("1", new MemoryStream(new byte[1472]));
tx.Root.Add("2", new MemoryStream(new byte[992]));
tx.Root.Add("3", new MemoryStream(new byte[1632]));
tx.Root.Add("4", new MemoryStream(new byte[632]));
tx.Root.Add("5", new MemoryStream(new byte[824]));
tx.Root.Delete("3");
tx.Root.Add("6", new MemoryStream(new byte[1096]));
DebugStuff.RenderAndShow(tx, 1);
tx.Root.Delete("6");
tx.Root.Delete("4");
DebugStuff.RenderAndShow(tx, 1);
tx.Commit();
}
}
public void CanMergeLeft()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("1", new MemoryStream(new byte[1524]));
tx.Root.Add("2", new MemoryStream(new byte[1524]));
tx.Root.Add("3", new MemoryStream(new byte[1024]));
tx.Root.Add("4", new MemoryStream(new byte[64]));
DebugStuff.RenderAndShow(tx, 1);
tx.Root.Delete("2");
DebugStuff.RenderAndShow(tx, 1);
tx.Root.Delete("3");
DebugStuff.RenderAndShow(tx, 1);
tx.Commit();
}
}
public HttpResponseMessage DumpTree(string name)
{
var transactionalStorage = Database.TransactionalStorage as Raven.Storage.Voron.TransactionalStorage;
if (transactionalStorage == null)
{
return(GetMessageWithObject(new
{
Error = "The database storage is not Voron"
}, HttpStatusCode.BadRequest));
}
using (var tx = transactionalStorage.Environment.NewTransaction(TransactionFlags.Read))
{
var readTree = tx.ReadTree(name);
if (readTree == null)
{
return(GetMessageWithObject(new
{
Error = "The database storage does not contains a tree named: " + name
}, HttpStatusCode.NotFound));
}
}
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new PushStreamContent((stream, content, arg3) =>
{
using (stream)
using (var tx = transactionalStorage.Environment.NewTransaction(TransactionFlags.Read))
{
var readTree = tx.ReadTree(name);
DebugStuff.DumpTreeToStream(readTree, stream);
}
})
{
Headers = { ContentType = MediaTypeHeaderValue.Parse("text/html") }
}
});
}
public void DebugValidate(LowLevelTransaction tx, long root)
{
if (NumberOfEntries == 0)
{
return;
}
if (IsBranch && NumberOfEntries < 2)
{
throw new InvalidOperationException("The branch page " + PageNumber + " has " + NumberOfEntries + " entry");
}
var prev = GetNodeKey(tx, 0);
var pages = new HashSet <long>();
for (int i = 1; i < NumberOfEntries; i++)
{
var node = GetNode(i);
var current = GetNodeKey(tx, i);
if (SliceComparer.CompareInline(prev, current) >= 0)
{
DebugStuff.RenderAndShowTree(tx, root);
throw new InvalidOperationException("The page " + PageNumber + " is not sorted");
}
if (node->Flags == (TreeNodeFlags.PageRef))
{
if (pages.Add(node->PageNumber) == false)
{
DebugStuff.RenderAndShowTree(tx, root);
throw new InvalidOperationException("The page " + PageNumber + " references same page multiple times");
}
}
prev = current;
}
}
public void StressTest()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
for (int i = 0; i < 80; ++i)
{
tx.Root.Add(string.Format("{0}1", i), new MemoryStream(new byte[1472]));
tx.Root.Add(string.Format("{0}2", i), new MemoryStream(new byte[992]));
tx.Root.Add(string.Format("{0}3", i), new MemoryStream(new byte[1632]));
tx.Root.Add(string.Format("{0}4", i), new MemoryStream(new byte[632]));
tx.Root.Add(string.Format("{0}5", i), new MemoryStream(new byte[824]));
tx.Root.Add(string.Format("{0}6", i), new MemoryStream(new byte[1096]));
tx.Root.Add(string.Format("{0}7", i), new MemoryStream(new byte[2048]));
tx.Root.Add(string.Format("{0}8", i), new MemoryStream(new byte[1228]));
tx.Root.Add(string.Format("{0}9", i), new MemoryStream(new byte[8192]));
}
DebugStuff.RenderAndShow(tx, 1);
for (int i = 79; i >= 0; --i)
{
tx.Root.Delete(string.Format("{0}1", i));
tx.Root.Delete(string.Format("{0}2", i));
tx.Root.Delete(string.Format("{0}3", i));
tx.Root.Delete(string.Format("{0}4", i));
tx.Root.Delete(string.Format("{0}5", i));
tx.Root.Delete(string.Format("{0}6", i));
tx.Root.Delete(string.Format("{0}7", i));
tx.Root.Delete(string.Format("{0}8", i));
tx.Root.Delete(string.Format("{0}9", i));
}
tx.Commit();
}
}
public void DebugRenderAndShow()
{
DebugStuff.RenderAndShow(this);
}
void MainWindowDebugStuff()
{
var debugItemBrush = new SolidColorBrush(Colors.Blue);
PresentationTraceSources.DataBindingSource.Switch.Level = SourceLevels.Critical;
Button bonusButton = new()
{
Content = "BONUS!",
Width = 50,
Height = 30,
Foreground = debugItemBrush
};
bonusButton.Click += BonusButton_Click;
DockPanel.SetDock(bonusButton, Dock.Right);
SearchBox_DockPanel.Children.Add(bonusButton);
CreateThumbnailsCommand = new RelayCommand(CreateThumbnails);
MenuItem createThumbs = new()
{
Header = "Create thumbnails",
ToolTip = "Create a thumbnail for every release that doesn't have one.",
Command = CreateThumbnailsCommand,
Foreground = debugItemBrush
};
ArtMenuItem.Items.Add(createThumbs);
SetFactoryDBCommand = new RelayCommand(SetFactoryDB);
MenuItem setFactoryDB = new()
{
Header = "Set factory database",
ToolTip = "Erase all custom settings from database.",
Command = SetFactoryDBCommand,
Foreground = debugItemBrush
};
FileMenuItem.Items.Add(setFactoryDB);
}
async void BonusButton_Click(object sender, RoutedEventArgs e)
{
await DebugStuff.MainWindowBonusAsync();
}
public RelayCommand CreateThumbnailsCommand {
get; set;
}
void CreateThumbnails()
{
Stopwatch Watch = new();
Watch.Start();
int i = 0;
foreach (Release release in R.Data.Releases.Local)
{
Watch.Restart();
Debug.WriteLine(i++ + " : " + Watch.ElapsedMilliseconds);
release.CreateThumbnail();
}
}
public RelayCommand SetFactoryDBCommand {
get; set;
}
void SetFactoryDB()
{
DebugStuff.SetFactoryDatabase();
}
#endif
}
public void ShouldCorrectlyFindSmallValueMergingByTwoSectionsInFreeSpaceHandling()
{
var dataSize = 905048; // never change this
const int itemsCount = 10;
for (int i = 0; i < itemsCount; i++)
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("items/" + i, new byte[dataSize]);
tx.Commit();
}
if (i % (itemsCount / 3) == 0 || i % (itemsCount / 2) == 0)
{
Env.FlushLogToDataFile();
}
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
for (int i = 0; i < itemsCount; i++)
{
var readResult = tx.Root.Read("items/" + i);
Assert.Equal(dataSize, readResult.Reader.Length);
}
}
for (int i = 0; i < itemsCount; i++)
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Delete("items/" + i);
tx.Commit();
}
if (i % (itemsCount / 3) == 0 || i % (itemsCount / 2) == 0)
{
Env.FlushLogToDataFile();
}
}
for (int i = 0; i < itemsCount; i++)
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
tx.Root.Add("items/" + i, new byte[dataSize]);
DebugStuff.RenderAndShow(tx, tx.Root.State.RootPageNumber);
tx.Commit();
}
if (i % (itemsCount / 3) == 0 || i % (itemsCount / 2) == 0)
{
Env.FlushLogToDataFile();
}
}
using (var tx = Env.NewTransaction(TransactionFlags.Read))
{
for (int i = 0; i < itemsCount; i++)
{
var readResult = tx.Root.Read("items/" + i);
Assert.Equal(dataSize, readResult.Reader.Length);
}
}
}
public void CanForceToFlushPagesOlderThanOldestActiveTransactionToFreePagesFromScratch()
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new string('a', 1000));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
Env.CreateTree(txw, "bar");
txw.Commit();
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new string('b', 1000));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
var txr = Env.NewTransaction(TransactionFlags.Read);
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("bars/1", new string('c', 1000));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
Env.FlushLogToDataFile();
txr.Dispose();
using (var txr2 = Env.NewTransaction(TransactionFlags.Read))
{
var allocated1 = Env.ScratchBufferPool.GetNumberOfAllocations(0);
Env.FlushLogToDataFile();
var allocated2 = Env.ScratchBufferPool.GetNumberOfAllocations(0);
Assert.Equal(allocated1, allocated2);
Env.FlushLogToDataFile(allowToFlushOverwrittenPages: true);
var allocated3 = Env.ScratchBufferPool.GetNumberOfAllocations(0);
Assert.True(allocated3 < allocated2);
var read = Env.CreateTree(txr2, "foo").Read("bars/1");
Assert.NotNull(read);
Assert.Equal(new string('c', 1000), read.Reader.AsSlice().ToString());
}
}
}
public void MissingScratchPagesInPageTable()
{
var bytes = new byte[1000];
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree1 = Env.CreateTree(txw, "foo");
var tree2 = Env.CreateTree(txw, "bar");
var tree3 = Env.CreateTree(txw, "baz");
tree1.Add("foos/1", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "bar");
tree.Add("bars/1", new MemoryStream(bytes));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
var bytesToFillFirstJournalCompletely = new byte[8 * AbstractPager.PageSize];
new Random().NextBytes(bytesToFillFirstJournalCompletely);
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "baz");
// here we have to put a big value to be sure that in next transaction we will put the
// updated value into a new journal file - this is the key to expose the issue
tree.Add("bazs/1", new MemoryStream(bytesToFillFirstJournalCompletely));
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
using (var txr = Env.NewTransaction(TransactionFlags.Read))
{
using (var txw = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(txw, "foo");
tree.Add("foos/1", new MemoryStream());
txw.Commit();
DebugStuff.RenderAndShow(txw, 1);
}
Env.FlushLogToDataFile();
Assert.NotNull(Env.CreateTree(txr, "foo").Read("foos/1"));
}
}
private void Awake()
{
current = this;
text = GetComponent <TMP_Text>();
}
public void RavenDB_2543_CouldNotEnsureThatWeHaveEnoughSpace_When_MovingLeafNode()
{
using (var tx = Env.NewTransaction(TransactionFlags.ReadWrite))
{
var tree = Env.CreateTree(tx, "rebalancing-issue");
var aKey = new string('a', 1000);
var bKey = new string('b', 1000);
var cKey = new string('c', 1000);
var dKey = new string('d', 1020);
var eKey = new string('e', 1020);
var fKey = new string('f', 1020);
var gKey = new string('g', 1000);
var hKey = new string('h', 1000);
var iKey = new string('i', 1000);
var jKey = new string('j', 1000);
var kKey = new string('k', 1000);
var lKey = new string('l', 1000);
var mKey = new string('m', 820);
var nKey = new string('n', 102);
tree.Add(aKey, new MemoryStream(new byte[100]));
tree.Add(bKey, new MemoryStream(new byte[100]));
tree.Add(cKey, new MemoryStream(new byte[100]));
tree.Add(dKey, new MemoryStream(new byte[100]));
tree.Add(eKey, new MemoryStream(new byte[100]));
tree.Add(fKey, new MemoryStream(new byte[100]));
tree.Add(gKey, new MemoryStream(new byte[100]));
tree.Add(hKey, new MemoryStream(new byte[100]));
tree.Add(iKey, new MemoryStream(new byte[100]));
tree.Add(jKey, new MemoryStream(new byte[100]));
tree.Add(kKey, new MemoryStream(new byte[100]));
tree.Add(lKey, new MemoryStream(new byte[100]));
tree.Add(mKey, new MemoryStream(new byte[100]));
tree.Add(nKey, new MemoryStream(new byte[1000]));
DebugStuff.RenderAndShow(tx, 1);
tree.Delete(nKey); // this line throws "The page is full and cannot add an entry, this is probably a bug"
DebugStuff.RenderAndShow(tx, 1);
tx.Commit();
using (var iterator = tree.Iterate())
{
Assert.True(iterator.Seek(Slice.BeforeAllKeys));
Assert.Equal(aKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(bKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(cKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(dKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(eKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(fKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(gKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(hKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(iKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(jKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(kKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(lKey, iterator.CurrentKey);
Assert.True(iterator.MoveNext());
Assert.Equal(mKey, iterator.CurrentKey);
Assert.False(iterator.MoveNext());
}
}
}
