public byte *Execute()
{
using (DisableFreeSpaceUsageIfSplittingRootTree())
{
TreePage rightPage = _tree.NewPage(_page.TreeFlags, _page.PageNumber);
if (_cursor.PageCount == 0) // we need to do a root split
{
TreePage newRootPage = _tree.NewPage(TreePageFlags.Branch, _page.PageNumber);
_cursor.Push(newRootPage);
_tree.State.RootPageNumber = newRootPage.PageNumber;
_tree.State.Depth++;
// now add implicit left page
newRootPage.AddPageRefNode(0, Slices.BeforeAllKeys, _page.PageNumber);
_parentPage = newRootPage;
_parentPage.LastSearchPosition++;
}
else
{
// we already popped the page, so the current one on the stack is the parent of the page
_parentPage = _tree.ModifyPage(_cursor.CurrentPage);
_cursor.Update(_cursor.Pages, _parentPage);
}
if (_page.IsLeaf)
{
_tree.ClearPagesCache();
}
if (_page.IsCompressed)
{
_pageDecompressed = _tree.DecompressPage(_page);
_pageDecompressed.Search(_tx, _newKey);
if (_pageDecompressed.LastMatch == 0)
{
// we are going to insert the value in a bit, but it might have
// been in the compressed portion and not removed by the calling
// code
_tree.RemoveLeafNode(_pageDecompressed);
}
_page = _pageDecompressed;
}
using (_pageDecompressed)
{
if (_page.LastSearchPosition >= _page.NumberOfEntries)
{
var pos = OptimizedOnlyMoveNewValueToTheRightPage(rightPage);
RecompressPageIfNeeded(wasModified: false);
return(pos);
}
return(SplitPageInHalf(rightPage));
}
}
}
public byte *AddSeparator(Slice separator, long pageRefNumber, int?nodePos = null)
{
var originalLastSearchPositionOfParent = _parentPage.LastSearchPosition;
if (nodePos == null)
{
nodePos = _parentPage.NodePositionFor(_tx, separator); // select the appropriate place for this
}
if (_parentPage.HasSpaceFor(_tx, TreeSizeOf.BranchEntry(separator) + Constants.NodeOffsetSize) == false)
{
var pageSplitter = new TreePageSplitter(_tx, _tree, separator, -1, pageRefNumber, TreeNodeFlags.PageRef, 0, _cursor);
var posToInsert = pageSplitter.Execute();
ParentOfAddedPageRef = _cursor.CurrentPage;
var adjustParentPageOnCursor = true;
for (int i = 0; i < _cursor.CurrentPage.NumberOfEntries; i++)
{
if (_cursor.CurrentPage.GetNode(i)->PageNumber == _currentPage.PageNumber)
{
adjustParentPageOnCursor = false;
_cursor.CurrentPage.LastSearchPosition = i;
break;
}
}
if (adjustParentPageOnCursor)
{
// the above page split has modified the cursor that its first page points to the parent of the leaf where 'separatorKey' was inserted
// and it doesn't have the reference to _page, we need to ensure that the actual parent is first at the cursor
_cursor.Pop();
_cursor.Push(_parentPage);
EnsureValidLastSearchPosition(_parentPage, _currentPage.PageNumber, originalLastSearchPositionOfParent);
}
#if VALIDATE
Debug.Assert(_cursor.CurrentPage.GetNode(_cursor.CurrentPage.LastSearchPosition)->PageNumber == _currentPage.PageNumber,
"The parent page is not referencing a page which is being split");
var parentToValidate = ParentOfAddedPageRef;
Debug.Assert(Enumerable.Range(0, parentToValidate.NumberOfEntries).Any(i => parentToValidate.GetNode(i)->PageNumber == pageRefNumber),
"The parent page of a page reference isn't referencing it");
#endif
return(posToInsert);
}
ParentOfAddedPageRef = _parentPage;
var pos = _parentPage.AddPageRefNode(nodePos.Value, separator, pageRefNumber);
EnsureValidLastSearchPosition(_parentPage, _currentPage.PageNumber, originalLastSearchPositionOfParent);
return(pos);
}
private byte *OptimizedOnlyMoveNewValueToTheRightPage(TreePage rightPage)
{
// when we get a split at the end of the page, we take that as a hint that the user is doing
// sequential inserts, at that point, we are going to keep the current page as is and create a new
// page, this will allow us to do minimal amount of work to get the best density
TreePage branchOfSeparator;
byte *pos;
if (_page.IsBranch)
{
if (_page.NumberOfEntries > 2)
{
// here we steal the last entry from the current page so we maintain the implicit null left entry
TreeNodeHeader *node = _page.GetNode(_page.NumberOfEntries - 1);
Debug.Assert(node->Flags == TreeNodeFlags.PageRef);
rightPage.AddPageRefNode(0, Slices.BeforeAllKeys, node->PageNumber);
pos = AddNodeToPage(rightPage, 1);
Slice separatorKey;
using (TreeNodeHeader.ToSlicePtr(_tx.Allocator, node, out separatorKey))
{
AddSeparatorToParentPage(rightPage.PageNumber, separatorKey, out branchOfSeparator);
}
_page.RemoveNode(_page.NumberOfEntries - 1);
}
else
{
_tree.FreePage(rightPage); // return the unnecessary right page
pos = AddSeparatorToParentPage(_pageNumber, _newKey, out branchOfSeparator);
if (_cursor.CurrentPage.PageNumber != branchOfSeparator.PageNumber)
{
_cursor.Push(branchOfSeparator);
}
return(pos);
}
}
else
{
AddSeparatorToParentPage(rightPage.PageNumber, _newKey, out branchOfSeparator);
pos = AddNodeToPage(rightPage, 0);
}
_cursor.Push(rightPage);
return(pos);
}
private byte *AddNodeToPage(TreePage page, int index, Slice alreadyPreparedNewKey = default(Slice))
{
var newKeyToInsert = alreadyPreparedNewKey.HasValue ? alreadyPreparedNewKey : _newKey;
switch (_nodeType)
{
case TreeNodeFlags.PageRef:
return(page.AddPageRefNode(index, newKeyToInsert, _pageNumber));
case TreeNodeFlags.Data:
return(page.AddDataNode(index, newKeyToInsert, _len));
case TreeNodeFlags.MultiValuePageRef:
return(page.AddMultiValueNode(index, newKeyToInsert, _len));
default:
throw new NotSupportedException("Unknown node type");
}
}
public byte *Execute()
{
using (DisableFreeSpaceUsageIfSplittingRootTree())
{
TreePage rightPage = _tree.NewPage(_page.TreeFlags, 1);
if (_cursor.PageCount == 0) // we need to do a root split
{
TreePage newRootPage = _tree.NewPage(TreePageFlags.Branch, 1);
_cursor.Push(newRootPage);
_tree.State.RootPageNumber = newRootPage.PageNumber;
_tree.State.Depth++;
// now add implicit left page
newRootPage.AddPageRefNode(0, Slices.BeforeAllKeys, _page.PageNumber);
_parentPage = newRootPage;
_parentPage.LastSearchPosition++;
}
else
{
// we already popped the page, so the current one on the stack is the parent of the page
_parentPage = _tree.ModifyPage(_cursor.CurrentPage);
_cursor.Update(_cursor.Pages.First, _parentPage);
}
if (_page.IsLeaf)
{
_tree.ClearPagesCache();
}
if (_page.IsCompressed)
{
_pageDecompressed = _tree.DecompressPage(_page);
_pageDecompressed.Search(_tx, _newKey);
_page = _pageDecompressed;
}
using (_pageDecompressed)
{
if (_page.LastSearchPosition >= _page.NumberOfEntries)
{
// when we get a split at the end of the page, we take that as a hint that the user is doing
// sequential inserts, at that point, we are going to keep the current page as is and create a new
// page, this will allow us to do minimal amount of work to get the best density
TreePage branchOfSeparator;
byte *pos;
if (_page.IsBranch)
{
if (_page.NumberOfEntries > 2)
{
// here we steal the last entry from the current page so we maintain the implicit null left entry
TreeNodeHeader *node = _page.GetNode(_page.NumberOfEntries - 1);
Debug.Assert(node->Flags == TreeNodeFlags.PageRef);
rightPage.AddPageRefNode(0, Slices.BeforeAllKeys, node->PageNumber);
pos = AddNodeToPage(rightPage, 1);
Slice separatorKey;
using (TreeNodeHeader.ToSlicePtr(_tx.Allocator, node, out separatorKey))
{
AddSeparatorToParentPage(rightPage.PageNumber, separatorKey, out branchOfSeparator);
}
_page.RemoveNode(_page.NumberOfEntries - 1);
}
else
{
_tree.FreePage(rightPage); // return the unnecessary right page
pos = AddSeparatorToParentPage(_pageNumber, _newKey, out branchOfSeparator);
if (_cursor.CurrentPage.PageNumber != branchOfSeparator.PageNumber)
{
_cursor.Push(branchOfSeparator);
}
return(pos);
}
}
else
{
AddSeparatorToParentPage(rightPage.PageNumber, _newKey, out branchOfSeparator);
pos = AddNodeToPage(rightPage, 0);
}
_cursor.Push(rightPage);
return(pos);
}
return(SplitPageInHalf(rightPage));
}
}
}
private void MoveBranchNode(TreePage parentPage, TreePage from, TreePage to)
{
Debug.Assert(from.IsBranch);
Slice originalFromKey;
using (GetActualKey(from, from.LastSearchPositionOrLastEntry, out originalFromKey))
{
to.EnsureHasSpaceFor(_tx, originalFromKey, -1);
var fromNode = from.GetNode(from.LastSearchPosition);
long pageNum = fromNode->PageNumber;
if (to.LastSearchPosition == 0)
{
// cannot add to left implicit side, adjust by moving the left node
// to the right by one, then adding the new one as the left
TreeNodeHeader *actualKeyNode;
Slice implicitLeftKey;
using (GetActualKey(to, 0, out actualKeyNode, out implicitLeftKey))
{
var implicitLeftNode = to.GetNode(0);
var leftPageNumber = implicitLeftNode->PageNumber;
Slice implicitLeftKeyToInsert;
ByteStringContext.ExternalScope?externalScope;
if (implicitLeftNode == actualKeyNode)
{
externalScope = TreeNodeHeader.ToSlicePtr(_tx.Allocator, actualKeyNode, out implicitLeftKeyToInsert);
}
else
{
implicitLeftKeyToInsert = implicitLeftKey;
externalScope = null;
}
to.EnsureHasSpaceFor(_tx, implicitLeftKeyToInsert, -1);
to.AddPageRefNode(1, implicitLeftKeyToInsert, leftPageNumber);
externalScope?.Dispose();
to.ChangeImplicitRefPageNode(pageNum); // setup the new implicit node
}
}
else
{
to.AddPageRefNode(to.LastSearchPosition, originalFromKey, pageNum);
}
}
if (from.LastSearchPositionOrLastEntry == 0)
{
var rightPageNumber = from.GetNode(1)->PageNumber;
from.RemoveNode(0); // remove the original implicit node
from.ChangeImplicitRefPageNode(rightPageNumber); // setup the new implicit node
Debug.Assert(from.NumberOfEntries >= 2);
}
else
{
from.RemoveNode(from.LastSearchPositionOrLastEntry);
}
var pos = parentPage.LastSearchPositionOrLastEntry;
parentPage.RemoveNode(pos);
Slice newSeparatorKey;
var scope = GetActualKey(to, 0, out newSeparatorKey); // get the next smallest key it has now
try
{
var pageNumber = to.PageNumber;
if (parentPage.GetNode(0)->PageNumber == to.PageNumber)
{
pageNumber = from.PageNumber;
scope.Dispose();
scope = GetActualKey(from, 0, out newSeparatorKey);
}
AddSeparatorToParentPage(to, parentPage, pageNumber, newSeparatorKey, pos);
}
finally
{
scope.Dispose();
}
}
private void MoveLeafNode(TreePage parentPage, TreePage from, TreePage to)
{
Debug.Assert(from.IsBranch == false);
Slice originalFromKeyStart;
using (GetActualKey(from, from.LastSearchPositionOrLastEntry, out originalFromKeyStart))
{
var fromNode = from.GetNode(from.LastSearchPosition);
byte *val = @from.Base + @from.KeysOffsets[@from.LastSearchPosition] + Constants.Tree.NodeHeaderSize +
originalFromKeyStart.Size;
byte *dataPos;
var fromDataSize = fromNode->DataSize;
switch (fromNode->Flags)
{
case TreeNodeFlags.PageRef:
to.EnsureHasSpaceFor(_tx, originalFromKeyStart, -1);
dataPos = to.AddPageRefNode(to.LastSearchPosition, originalFromKeyStart, fromNode->PageNumber);
break;
case TreeNodeFlags.Data:
to.EnsureHasSpaceFor(_tx, originalFromKeyStart, fromDataSize);
dataPos = to.AddDataNode(to.LastSearchPosition, originalFromKeyStart, fromDataSize);
break;
case TreeNodeFlags.MultiValuePageRef:
to.EnsureHasSpaceFor(_tx, originalFromKeyStart, fromDataSize);
dataPos = to.AddMultiValueNode(to.LastSearchPosition, originalFromKeyStart, fromDataSize);
break;
default:
throw new NotSupportedException("Invalid node type to move: " + fromNode->Flags);
}
if (dataPos != null && fromDataSize > 0)
{
Memory.Copy(dataPos, val, fromDataSize);
}
from.RemoveNode(from.LastSearchPositionOrLastEntry);
var pos = parentPage.LastSearchPositionOrLastEntry;
parentPage.RemoveNode(pos);
Slice newSeparatorKey;
var scope = GetActualKey(to, 0, out newSeparatorKey); // get the next smallest key it has now
try
{
var pageNumber = to.PageNumber;
if (parentPage.GetNode(0)->PageNumber == to.PageNumber)
{
pageNumber = from.PageNumber;
scope.Dispose();
scope = GetActualKey(from, 0, out newSeparatorKey);
}
AddSeparatorToParentPage(to, parentPage, pageNumber, newSeparatorKey, pos);
}
finally
{
scope.Dispose();
}
}
}
private void MoveLeafNode(TreePage parentPage, TreePage from, TreePage to)
{
Debug.Assert(from.IsBranch == false);
var originalFromKeyStart = GetActualKey(from, from.LastSearchPositionOrLastEntry);
var fromNode = from.GetNode(from.LastSearchPosition);
byte *val = @from.Base + @from.KeysOffsets[@from.LastSearchPosition] + Constants.NodeHeaderSize + originalFromKeyStart.Size;
var nodeVersion = fromNode->Version; // every time new node is allocated the version is increased, but in this case we do not want to increase it
if (nodeVersion > 0)
{
nodeVersion -= 1;
}
byte *dataPos;
var fromDataSize = fromNode->DataSize;
switch (fromNode->Flags)
{
case TreeNodeFlags.PageRef:
to.EnsureHasSpaceFor(_tx, originalFromKeyStart, -1);
dataPos = to.AddPageRefNode(to.LastSearchPosition, originalFromKeyStart, fromNode->PageNumber);
break;
case TreeNodeFlags.Data:
to.EnsureHasSpaceFor(_tx, originalFromKeyStart, fromDataSize);
dataPos = to.AddDataNode(to.LastSearchPosition, originalFromKeyStart, fromDataSize, nodeVersion);
break;
case TreeNodeFlags.MultiValuePageRef:
to.EnsureHasSpaceFor(_tx, originalFromKeyStart, fromDataSize);
dataPos = to.AddMultiValueNode(to.LastSearchPosition, originalFromKeyStart, fromDataSize, nodeVersion);
break;
default:
throw new NotSupportedException("Invalid node type to move: " + fromNode->Flags);
}
if (dataPos != null && fromDataSize > 0)
{
Memory.Copy(dataPos, val, fromDataSize);
}
from.RemoveNode(from.LastSearchPositionOrLastEntry);
var pos = parentPage.LastSearchPositionOrLastEntry;
parentPage.RemoveNode(pos);
var newSeparatorKey = GetActualKey(to, 0); // get the next smallest key it has now
var pageNumber = to.PageNumber;
if (parentPage.GetNode(0)->PageNumber == to.PageNumber)
{
pageNumber = from.PageNumber;
newSeparatorKey = GetActualKey(from, 0);
}
AddSeparatorToParentPage(to, parentPage, pageNumber, newSeparatorKey, pos);
}
