public List <long> AllPages()
{
var results = new List <long>();
var stack = new Stack <Page>();
var root = _tx.GetReadOnlyPage(State.RootPageNumber);
stack.Push(root);
while (stack.Count > 0)
{
var p = stack.Pop();
results.Add(p.PageNumber);
var key = p.CreateNewEmptyKey();
for (int i = 0; i < p.NumberOfEntries; i++)
{
var node = p.GetNode(i);
var pageNumber = node->PageNumber;
if (p.IsBranch)
{
stack.Push(_tx.GetReadOnlyPage(pageNumber));
}
else if (node->Flags == NodeFlags.PageRef)
{
// This is an overflow page
var overflowPage = _tx.GetReadOnlyPage(pageNumber);
var numberOfPages = _tx.DataPager.GetNumberOfOverflowPages(overflowPage.OverflowSize);
for (long j = 0; j < numberOfPages; ++j)
{
results.Add(overflowPage.PageNumber + j);
}
}
else if (node->Flags == NodeFlags.MultiValuePageRef)
{
// this is a multi value
p.SetNodeKey(node, ref key);
var tree = OpenMultiValueTree(_tx, (Slice)key, node);
results.AddRange(tree.AllPages());
}
else
{
if (State.Flags.HasFlag(TreeFlags.FixedSizeTrees))
{
var valueReader = NodeHeader.Reader(_tx, node);
byte valueSize = *valueReader.Base;
var fixedSizeTreeName = p.GetNodeKey(i);
var fixedSizeTree = new FixedSizeTree(_tx, this, (Slice)fixedSizeTreeName, valueSize);
var pages = fixedSizeTree.AllPages();
results.AddRange(pages);
}
}
}
}
return(results);
}
public List <long> AllPages()
{
var results = new List <long>();
var stack = new Stack <TreePage>();
var root = _llt.GetReadOnlyTreePage(State.RootPageNumber);
stack.Push(root);
Slice key = default(Slice);
while (stack.Count > 0)
{
var p = stack.Pop();
results.Add(p.PageNumber);
for (int i = 0; i < p.NumberOfEntries; i++)
{
var node = p.GetNode(i);
var pageNumber = node->PageNumber;
if (p.IsBranch)
{
stack.Push(_llt.GetReadOnlyTreePage(pageNumber));
}
else if (node->Flags == TreeNodeFlags.PageRef)
{
// This is an overflow page
var overflowPage = _llt.GetReadOnlyTreePage(pageNumber);
var numberOfPages = _llt.DataPager.GetNumberOfOverflowPages(overflowPage.OverflowSize);
for (long j = 0; j < numberOfPages; ++j)
{
results.Add(overflowPage.PageNumber + j);
}
}
else if (node->Flags == TreeNodeFlags.MultiValuePageRef)
{
key = TreeNodeHeader.ToSlicePtr(_tx.Allocator, node, ByteStringType.Mutable);
var tree = OpenMultiValueTree(key, node);
results.AddRange(tree.AllPages());
}
else
{
if ((State.Flags & TreeFlags.FixedSizeTrees) == TreeFlags.FixedSizeTrees)
{
var valueReader = TreeNodeHeader.Reader(_llt, node);
var valueSize = ((FixedSizeTreeHeader.Embedded *)valueReader.Base)->ValueSize;
var fixedSizeTreeName = p.GetNodeKey(_llt, i);
var fixedSizeTree = new FixedSizeTree(_llt, this, fixedSizeTreeName, valueSize);
var pages = fixedSizeTree.AllPages();
results.AddRange(pages);
}
}
}
}
return(results);
}
private List <double> GetPageDensities(FixedSizeTree tree)
{
var densities = new List <double>();
var allPages = tree.AllPages();
var pageSize = _tx.Environment.Options.PageSize;
for (var i = 0; i < allPages.Count; i++)
{
var fstp = _tx.GetPage(allPages[i]).ToFixedSizeTreePage();
var sizeUsed = Constants.FixedSizeTreePageHeaderSize +
(fstp.NumberOfEntries * (fstp.IsLeaf ? fstp.ValueSize : FixedSizeTree.BranchEntrySize));
densities.Add(((double)sizeUsed) / pageSize);
}
return(densities);
}
private static List <double> GetPageDensities(FixedSizeTree tree)
{
var allPages = tree.AllPages();
if (allPages.Count == 0)
{
return(null);
}
var densities = new List <double>();
foreach (var pageNumber in allPages)
{
var page = tree.Llt.GetPage(pageNumber);
var fstp = new FixedSizeTreePage(page.Pointer, tree.ValueSize + sizeof(long), Constants.Storage.PageSize);
var sizeUsed = Constants.FixedSizeTree.PageHeaderSize +
fstp.NumberOfEntries * (fstp.IsLeaf ? fstp.ValueSize + sizeof(long) : FixedSizeTree.BranchEntrySize);
densities.Add((double)sizeUsed / Constants.Storage.PageSize);
}
return(densities);
}
public List <long> AllPages()
{
var results = new List <long>();
var stack = new Stack <TreePage>();
var root = GetReadOnlyTreePage(State.RootPageNumber);
stack.Push(root);
Slice key = default(Slice);
while (stack.Count > 0)
{
var p = stack.Pop();
results.Add(p.PageNumber);
for (int i = 0; i < p.NumberOfEntries; i++)
{
var node = p.GetNode(i);
var pageNumber = node->PageNumber;
if (p.IsBranch)
{
stack.Push(GetReadOnlyTreePage(pageNumber));
}
else if (node->Flags == TreeNodeFlags.PageRef)
{
// This is an overflow page
var overflowPage = GetReadOnlyTreePage(pageNumber);
var numberOfPages = VirtualPagerLegacyExtensions.GetNumberOfOverflowPages(overflowPage.OverflowSize);
for (long j = 0; j < numberOfPages; ++j)
{
results.Add(overflowPage.PageNumber + j);
}
}
else if (node->Flags == TreeNodeFlags.MultiValuePageRef)
{
using (TreeNodeHeader.ToSlicePtr(_tx.Allocator, node, out key))
{
var tree = OpenMultiValueTree(key, node);
results.AddRange(tree.AllPages());
}
}
else
{
if ((State.Flags & TreeFlags.FixedSizeTrees) == TreeFlags.FixedSizeTrees)
{
var valueReader = GetValueReaderFromHeader(node);
var valueSize = ((FixedSizeTreeHeader.Embedded *)valueReader.Base)->ValueSize;
Slice fixedSizeTreeName;
using (p.GetNodeKey(_llt, i, out fixedSizeTreeName))
{
var fixedSizeTree = new FixedSizeTree(_llt, this, fixedSizeTreeName, valueSize);
var pages = fixedSizeTree.AllPages();
results.AddRange(pages);
if ((State.Flags & TreeFlags.Streams) == TreeFlags.Streams)
{
Debug.Assert(fixedSizeTree.ValueSize == ChunkDetails.SizeOf);
var streamPages = GetStreamPages(fixedSizeTree, GetStreamInfo(fixedSizeTree.Name, writable: false));
results.AddRange(streamPages);
}
}
}
}
}
}
return(results);
}
