private TreeNodeHeader *CreateNode(int index, Slice key, TreeNodeFlags flags, int len)
{
Debug.Assert(index <= NumberOfEntries && index >= 0);
Debug.Assert(IsBranch == false || index != 0 || key.Size == 0);// branch page's first item must be the implicit ref
if (HasSpaceFor(key, len) == false)
{
throw new InvalidOperationException(string.Format("The page is full and cannot add an entry, this is probably a bug. Key: {0}, data length: {1}, size left: {2}", key, len, SizeLeft));
}
// move higher pointers up one slot
ushort *offsets = KeysOffsets;
for (int i = NumberOfEntries; i > index; i--)
{
offsets[i] = offsets[i - 1];
}
var nodeSize = TreeSizeOf.NodeEntry(PageMaxSpace, key, len);
var node = AllocateNewNode(index, nodeSize);
node->Flags = flags;
Debug.Assert(key.Size <= ushort.MaxValue);
node->KeySize = (ushort)key.Size;
if (key.Options == SliceOptions.Key && node->KeySize > 0)
{
key.CopyTo((byte *)node + Constants.Tree.NodeHeaderSize);
}
return(node);
}
private int AdjustSplitPosition(int currentIndex, int splitIndex, ref bool toRight)
{
Slice keyToInsert = _newKey;
int pageSize = TreeSizeOf.NodeEntry(AbstractPager.PageMaxSpace, keyToInsert, _len) + Constants.Tree.NodeOffsetSize;
if (toRight == false)
{
for (int i = 0; i < splitIndex; i++)
{
TreeNodeHeader *node = _page.GetNode(i);
pageSize += node->GetNodeSize();
pageSize += pageSize & 1;
if (pageSize > _page.PageMaxSpace)
{
if (i <= currentIndex)
{
if (i < currentIndex)
{
toRight = true;
}
return(currentIndex);
}
return(i);
}
}
}
else
{
for (int i = _page.NumberOfEntries - 1; i >= splitIndex; i--)
{
TreeNodeHeader *node = _page.GetNode(i);
pageSize += node->GetNodeSize();
pageSize += pageSize & 1;
if (pageSize > _page.PageMaxSpace)
{
if (i >= currentIndex)
{
toRight = false;
return(currentIndex);
}
return(i + 1);
}
}
}
return(splitIndex);
}
private void HandleUncompressedNodes(DecompressedLeafPage decompressedPage, TreePage p, DecompressionUsage usage)
{
int numberOfEntries = p.NumberOfEntries;
for (var i = 0; i < numberOfEntries; i++)
{
var uncompressedNode = p.GetNode(i);
Slice nodeKey;
using (TreeNodeHeader.ToSlicePtr(_tx.Allocator, uncompressedNode, out nodeKey))
{
if (uncompressedNode->Flags == TreeNodeFlags.CompressionTombstone)
{
HandleTombstone(decompressedPage, nodeKey, usage);
continue;
}
if (decompressedPage.HasSpaceFor(_llt, TreeSizeOf.NodeEntry(uncompressedNode)) == false)
{
throw new InvalidOperationException("Could not add uncompressed node to decompressed page");
}
int index;
if (decompressedPage.NumberOfEntries > 0)
{
Slice lastKey;
using (decompressedPage.GetNodeKey(_llt, decompressedPage.NumberOfEntries - 1, out lastKey))
{
// optimization: it's very likely that uncompressed nodes have greater keys than compressed ones
// when we insert sequential keys
var cmp = SliceComparer.CompareInline(nodeKey, lastKey);
if (cmp > 0)
{
index = decompressedPage.NumberOfEntries;
}
else
{
if (cmp == 0)
{
// update of the last entry, just decrement NumberOfEntries in the page and
// put it at the last position
index = decompressedPage.NumberOfEntries - 1;
decompressedPage.Lower -= Constants.Tree.NodeOffsetSize;
}
else
{
index = decompressedPage.NodePositionFor(_llt, nodeKey);
if (decompressedPage.LastMatch == 0) // update
{
decompressedPage.RemoveNode(index);
if (usage == DecompressionUsage.Write)
{
State.NumberOfEntries--;
}
}
}
}
}
}
else
{
// all uncompressed nodes were compresion tombstones which deleted all entries from the decompressed page
index = 0;
}
switch (uncompressedNode->Flags)
{
case TreeNodeFlags.PageRef:
decompressedPage.AddPageRefNode(index, nodeKey, uncompressedNode->PageNumber);
break;
case TreeNodeFlags.Data:
var pos = decompressedPage.AddDataNode(index, nodeKey, uncompressedNode->DataSize);
var nodeValue = TreeNodeHeader.Reader(_llt, uncompressedNode);
Memory.Copy(pos, nodeValue.Base, nodeValue.Length);
break;
case TreeNodeFlags.MultiValuePageRef:
throw new NotSupportedException("Multi trees do not support compression");
default:
throw new NotSupportedException("Invalid node type to copye: " + uncompressedNode->Flags);
}
}
}
}
public int GetRequiredSpace(Slice key, int len)
{
return(TreeSizeOf.NodeEntry(PageMaxSpace, key, len) + Constants.Tree.NodeOffsetSize);
}
