public bool Seek(Slice key)
{
var current = _page.Search(key);
if (current == null)
{
return(false);
}
_page.SetNodeKey(current, ref _currentInternalKey);
_currentKey = _currentInternalKey.ToSlice();
return(this.ValidateCurrentKey(current, _page));
}
public bool Seek(Slice key)
{
if (_disposed)
{
throw new ObjectDisposedException("TreeIterator " + _tree.Name);
}
Lazy <Cursor> lazy;
NodeHeader * node;
_currentPage = _tree.FindPageFor(key, out node, out lazy);
_cursor = lazy.Value;
_cursor.Pop();
if (node != null)
{
_currentPage.SetNodeKey(node, ref _currentInternalKey);
_currentKey = _currentInternalKey.ToSlice();
return(this.ValidateCurrentKey(Current, _currentPage));
}
// The key is not found in the db, but we are Seek()ing for equals or starts with.
// We know that the exact value isn't there, but it is possible that the next page has values
// that is actually greater than the key, so we need to check it as well.
_currentPage.LastSearchPosition = _currentPage.NumberOfEntries; // force next MoveNext to move to the next _page_.
return(MoveNext());
}
public bool MoveNext()
{
while (true)
{
_currentPage.LastSearchPosition++;
if (_currentPage.LastSearchPosition < _currentPage.NumberOfEntries)
{
// run out of entries, need to select the next page...
while (_currentPage.IsBranch)
{
_cursor.Push(_currentPage);
var node = _currentPage.GetNode(_currentPage.LastSearchPosition);
_currentPage = _tx.GetReadOnlyPage(node->PageNumber);
_currentPage.LastSearchPosition = 0;
}
var current = _currentPage.GetNode(_currentPage.LastSearchPosition);
if (this.ValidateCurrentKey(current, _currentPage) == false)
{
return(false);
}
_currentPage.SetNodeKey(current, ref _currentInternalKey);
_currentKey = _currentInternalKey.ToSlice();
return(true); // there is another entry in this page
}
if (_cursor.PageCount == 0)
{
break;
}
_currentPage = _cursor.Pop();
}
_currentPage = null;
return(false);
}
public bool Seek(Slice key)
{
if (_disposed)
{
throw new ObjectDisposedException("PageIterator");
}
var current = _page.Search(key);
if (current == null)
{
return(false);
}
_page.SetNodeKey(current, ref _currentInternalKey);
_currentKey = _currentInternalKey.ToSlice();
return(this.ValidateCurrentKey(current, _page));
}
private byte *SplitPageInHalf(Page rightPage)
{
int currentIndex = _page.LastSearchPosition;
bool newPosition = true;
int splitIndex = _page.NumberOfEntries / 2;
if (currentIndex < splitIndex)
{
newPosition = false;
}
if (_page.IsLeaf)
{
splitIndex = AdjustSplitPosition(currentIndex, splitIndex, ref newPosition);
}
var currentKey = _page.GetNodeKey(splitIndex);
// here the current key is the separator key and can go either way, so
// use newPosition to decide if it stays on the left node or moves to the right
MemorySlice seperatorKey;
if (currentIndex == splitIndex && newPosition)
{
seperatorKey = currentKey.Compare(_newKey) < 0 ? currentKey : _newKey;
}
else
{
seperatorKey = currentKey;
}
AddSeparatorToParentPage(rightPage.PageNumber, seperatorKey);
MemorySlice instance = _page.CreateNewEmptyKey();
// move the actual entries from page to right page
ushort nKeys = _page.NumberOfEntries;
for (int i = splitIndex; i < nKeys; i++)
{
NodeHeader *node = _page.GetNode(i);
if (_page.IsBranch && rightPage.NumberOfEntries == 0)
{
rightPage.CopyNodeDataToEndOfPage(node, _tree.KeysPrefixing ? (MemorySlice)PrefixedSlice.BeforeAllKeys : Slice.BeforeAllKeys);
}
else
{
_page.SetNodeKey(node, ref instance);
var key = rightPage.PrepareKeyToInsert(instance, rightPage.NumberOfEntries);
rightPage.CopyNodeDataToEndOfPage(node, key);
}
}
_page.Truncate(_tx, splitIndex);
// actually insert the new key
return((currentIndex > splitIndex || newPosition && currentIndex == splitIndex)
? InsertNewKey(rightPage)
: InsertNewKey(_page));
}
public bool MoveNext()
{
if (_disposed)
{
throw new ObjectDisposedException("TreeIterator " + _tree.Name);
}
while (_currentPage != null)
{
_currentPage.LastSearchPosition++;
if (_currentPage.LastSearchPosition < _currentPage.NumberOfEntries)
{
// run out of entries, need to select the next page...
while (_currentPage.IsBranch)
{
_cursor.Push(_currentPage);
var node = _currentPage.GetNode(_currentPage.LastSearchPosition);
_currentPage = _tx.GetReadOnlyPage(node->PageNumber);
_currentPage.LastSearchPosition = 0;
if (_prefetch && _currentPage.IsLeaf)
{
MaybePrefetchOverflowPages(_currentPage);
}
}
var current = _currentPage.GetNode(_currentPage.LastSearchPosition);
if (this.ValidateCurrentKey(current, _currentPage) == false)
{
return(false);
}
_currentPage.SetNodeKey(current, ref _currentInternalKey);
_currentKey = _currentInternalKey.ToSlice();
return(true);// there is another entry in this page
}
if (_cursor.PageCount == 0)
{
break;
}
_currentPage = _cursor.Pop();
}
_currentPage = null;
return(false);
}
public bool Seek(Slice key)
{
Lazy<Cursor> lazy;
NodeHeader* node;
_currentPage = _tree.FindPageFor(key, out node, out lazy);
_cursor = lazy.Value;
_cursor.Pop();
if (node != null)
{
_currentPage.SetNodeKey(node, ref _currentInternalKey);
_currentKey = _currentInternalKey.ToSlice();
return this.ValidateCurrentKey(Current, _currentPage);
}
// The key is not found in the db, but we are Seek()ing for equals or starts with.
// We know that the exact value isn't there, but it is possible that the next page has values
// that is actually greater than the key, so we need to check it as well.
_currentPage.LastSearchPosition = _currentPage.NumberOfEntries; // force next MoveNext to move to the next _page_.
return MoveNext();
}
private void ExpandMultiTreeNestedPageSize(Transaction tx, Slice key, Slice value, byte *nestedPagePtr, ushort newSize, int currentSize)
{
Debug.Assert(newSize > currentSize);
TemporaryPage tmp;
using (tx.Environment.GetTemporaryPage(tx, out tmp))
{
var tempPagePointer = tmp.TempPagePointer;
MemoryUtils.Copy(tempPagePointer, nestedPagePtr, currentSize);
Delete(key); // release our current page
Page nestedPage = new Page(tempPagePointer, "multi tree", (ushort)currentSize);
var ptr = DirectAdd(key, newSize);
var newNestedPage = new Page(ptr, "multi tree", newSize)
{
Lower = (ushort)Constants.PageHeaderSize,
Upper = KeysPrefixing ? (ushort)(newSize - Constants.PrefixInfoSectionSize) : newSize,
Flags = KeysPrefixing ? PageFlags.Leaf | PageFlags.KeysPrefixed : PageFlags.Leaf,
PageNumber = -1L // mark as invalid page number
};
newNestedPage.ClearPrefixInfo();
MemorySlice nodeKey = nestedPage.CreateNewEmptyKey();
for (int i = 0; i < nestedPage.NumberOfEntries; i++)
{
var nodeHeader = nestedPage.GetNode(i);
nestedPage.SetNodeKey(nodeHeader, ref nodeKey);
nodeKey = newNestedPage.PrepareKeyToInsert(nodeKey, i);
newNestedPage.AddDataNode(i, nodeKey, 0,
(ushort)(nodeHeader->Version - 1)); // we dec by one because AdddataNode will inc by one, and we don't want to change those values
}
newNestedPage.Search(value);
newNestedPage.AddDataNode(newNestedPage.LastSearchPosition, newNestedPage.PrepareKeyToInsert(value, newNestedPage.LastSearchPosition), 0, 0);
}
}
private void ExpandMultiTreeNestedPageSize(Transaction tx, Slice key, Slice value, byte* nestedPagePtr, ushort newSize, int currentSize)
{
Debug.Assert(newSize > currentSize);
TemporaryPage tmp;
using (tx.Environment.GetTemporaryPage(tx, out tmp))
{
var tempPagePointer = tmp.TempPagePointer;
NativeMethods.memcpy(tempPagePointer, nestedPagePtr, currentSize);
Delete(key); // release our current page
Page nestedPage = new Page(tempPagePointer, "multi tree", (ushort)currentSize);
var ptr = DirectAdd(key, newSize);
var newNestedPage = new Page(ptr, "multi tree", newSize)
{
Lower = (ushort)Constants.PageHeaderSize,
Upper = KeysPrefixing ? (ushort) (newSize - Constants.PrefixInfoSectionSize) : newSize,
Flags = KeysPrefixing ? PageFlags.Leaf | PageFlags.KeysPrefixed : PageFlags.Leaf,
PageNumber = -1L // mark as invalid page number
};
newNestedPage.ClearPrefixInfo();
MemorySlice nodeKey = nestedPage.CreateNewEmptyKey();
for (int i = 0; i < nestedPage.NumberOfEntries; i++)
{
var nodeHeader = nestedPage.GetNode(i);
nestedPage.SetNodeKey(nodeHeader, ref nodeKey);
nodeKey = newNestedPage.PrepareKeyToInsert(nodeKey, i);
newNestedPage.AddDataNode(i, nodeKey, 0,
(ushort)(nodeHeader->Version - 1)); // we dec by one because AdddataNode will inc by one, and we don't want to change those values
}
newNestedPage.Search(value);
newNestedPage.AddDataNode(newNestedPage.LastSearchPosition, newNestedPage.PrepareKeyToInsert(value, newNestedPage.LastSearchPosition), 0, 0);
}
}
public bool MovePrev()
{
while (true)
{
_currentPage.LastSearchPosition--;
if (_currentPage.LastSearchPosition >= 0)
{
// run out of entries, need to select the next page...
while (_currentPage.IsBranch)
{
_cursor.Push(_currentPage);
var node = _currentPage.GetNode(_currentPage.LastSearchPosition);
_currentPage = _tx.GetReadOnlyPage(node->PageNumber);
_currentPage.LastSearchPosition = _currentPage.NumberOfEntries - 1;
}
var current = _currentPage.GetNode(_currentPage.LastSearchPosition);
if (this.ValidateCurrentKey(current, _currentPage) == false)
return false;
_currentPage.SetNodeKey(current, ref _currentInternalKey);
_currentKey = _currentInternalKey.ToSlice();
return true;// there is another entry in this page
}
if (_cursor.PageCount == 0)
break;
_currentPage = _cursor.Pop();
}
_currentPage = null;
return false;
}
private byte *SplitPageInHalf(Page rightPage)
{
bool toRight;
var currentIndex = _page.LastSearchPosition;
var splitIndex = _page.NumberOfEntries / 2;
if (currentIndex <= splitIndex)
{
toRight = false;
}
else
{
toRight = true;
var leftPageEntryCount = splitIndex;
var rightPageEntryCount = _page.NumberOfEntries - leftPageEntryCount + 1;
if (rightPageEntryCount > leftPageEntryCount)
{
splitIndex++;
Debug.Assert(splitIndex < _page.NumberOfEntries);
}
}
PrefixNode[] prefixes = null;
if (_tree.KeysPrefixing && _page.HasPrefixes)
{
prefixes = _page.GetPrefixes();
}
if (_page.IsLeaf || prefixes != null)
{
splitIndex = AdjustSplitPosition(currentIndex, splitIndex, prefixes, ref toRight);
}
var currentKey = _page.GetNodeKey(splitIndex);
MemorySlice seperatorKey;
if (toRight && splitIndex == currentIndex)
{
seperatorKey = currentKey.Compare(_newKey) < 0 ? currentKey : _newKey;
}
else
{
seperatorKey = currentKey;
}
Page parentOfRight;
AddSeparatorToParentPage(rightPage.PageNumber, seperatorKey, out parentOfRight);
var parentOfPage = _cursor.CurrentPage;
MemorySlice instance = _page.CreateNewEmptyKey();
if (prefixes != null)
{
for (int i = 0; i < prefixes.Length; i++)
{
var prefix = prefixes[i];
rightPage.WritePrefix(new Slice(prefix.ValuePtr, prefix.PrefixLength), i);
}
}
bool addedAsImplicitRef = false;
if (_page.IsBranch && toRight && seperatorKey == _newKey)
{
// _newKey needs to be inserted as first key (BeforeAllKeys) to the right page, so we need to add it before we move entries from the current page
AddNodeToPage(rightPage, 0, _tree.KeysPrefixing ? (MemorySlice)PrefixedSlice.BeforeAllKeys : Slice.BeforeAllKeys);
addedAsImplicitRef = true;
}
// move the actual entries from page to right page
ushort nKeys = _page.NumberOfEntries;
for (int i = splitIndex; i < nKeys; i++)
{
NodeHeader *node = _page.GetNode(i);
if (_page.IsBranch && rightPage.NumberOfEntries == 0)
{
rightPage.CopyNodeDataToEndOfPage(node, _tree.KeysPrefixing ? (MemorySlice)PrefixedSlice.BeforeAllKeys : Slice.BeforeAllKeys);
}
else
{
_page.SetNodeKey(node, ref instance);
var key = rightPage.PrepareKeyToInsert(instance, rightPage.NumberOfEntries);
rightPage.CopyNodeDataToEndOfPage(node, key);
}
}
_page.Truncate(_tx, splitIndex);
byte *pos;
if (addedAsImplicitRef == false)
{
try
{
if (toRight && _cursor.CurrentPage.PageNumber != parentOfRight.PageNumber)
{
// modify the cursor if we are going to insert to the right page
_cursor.Pop();
_cursor.Push(parentOfRight);
}
// actually insert the new key
pos = toRight ? InsertNewKey(rightPage) : InsertNewKey(_page);
}
catch (InvalidOperationException e)
{
if (e.Message.StartsWith("The page is full and cannot add an entry") == false)
{
throw;
}
throw new InvalidOperationException(GatherDetailedDebugInfo(rightPage, currentKey, seperatorKey, currentIndex, splitIndex, toRight), e);
}
}
else
{
pos = null;
_cursor.Push(rightPage);
}
if (_page.IsBranch) // remove a branch that has only one entry, the page ref needs to be added to the parent of the current page
{
Debug.Assert(_page.NumberOfEntries > 0);
Debug.Assert(rightPage.NumberOfEntries > 0);
if (_page.NumberOfEntries == 1)
{
RemoveBranchWithOneEntry(_page, parentOfPage);
}
if (rightPage.NumberOfEntries == 1)
{
RemoveBranchWithOneEntry(rightPage, parentOfRight);
}
}
return(pos);
}
private byte *SplitPageInHalf(Page rightPage)
{
int currentIndex = _page.LastSearchPosition;
bool newPosition = true;
int splitIndex = _page.NumberOfEntries / 2;
if (currentIndex < splitIndex)
{
newPosition = false;
}
PrefixNode[] prefixes = null;
if (_tree.KeysPrefixing && _page.HasPrefixes)
{
prefixes = _page.GetPrefixes();
}
if (_page.IsLeaf || prefixes != null)
{
splitIndex = AdjustSplitPosition(currentIndex, splitIndex, prefixes, ref newPosition);
}
var currentKey = _page.GetNodeKey(splitIndex);
// here the current key is the separator key and can go either way, so
// use newPosition to decide if it stays on the left node or moves to the right
MemorySlice seperatorKey;
if (currentIndex == splitIndex && newPosition)
{
seperatorKey = currentKey.Compare(_newKey) < 0 ? currentKey : _newKey;
}
else
{
seperatorKey = currentKey;
}
AddSeparatorToParentPage(rightPage.PageNumber, seperatorKey);
MemorySlice instance = _page.CreateNewEmptyKey();
if (prefixes != null)
{
for (int i = 0; i < prefixes.Length; i++)
{
var prefix = prefixes[i];
rightPage.WritePrefix(new Slice(prefix.ValuePtr, prefix.PrefixLength), i);
}
}
// move the actual entries from page to right page
ushort nKeys = _page.NumberOfEntries;
for (int i = splitIndex; i < nKeys; i++)
{
NodeHeader *node = _page.GetNode(i);
if (_page.IsBranch && rightPage.NumberOfEntries == 0)
{
rightPage.CopyNodeDataToEndOfPage(node, _tree.KeysPrefixing ? (MemorySlice)PrefixedSlice.BeforeAllKeys : Slice.BeforeAllKeys);
}
else
{
_page.SetNodeKey(node, ref instance);
var key = rightPage.PrepareKeyToInsert(instance, rightPage.NumberOfEntries);
rightPage.CopyNodeDataToEndOfPage(node, key);
}
}
_page.Truncate(_tx, splitIndex);
// actually insert the new key
try
{
return((currentIndex > splitIndex || newPosition && currentIndex == splitIndex)
? InsertNewKey(rightPage)
: InsertNewKey(_page));
}
catch (InvalidOperationException e)
{
if (e.Message.StartsWith("The page is full and cannot add an entry"))
{
var debugInfo = new StringBuilder();
debugInfo.AppendFormat("\r\n_tree.Name: {0}\r\n", _tree.Name);
debugInfo.AppendFormat("_newKey: {0}, _len: {1}, needed space: {2}\r\n", _newKey, _len, _page.GetRequiredSpace(_newKey, _len));
debugInfo.AppendFormat("currentKey: {0}, seperatorKey: {1}\r\n", currentKey, seperatorKey);
debugInfo.AppendFormat("currentIndex: {0}\r\n", currentIndex);
debugInfo.AppendFormat("splitIndex: {0}\r\n", splitIndex);
debugInfo.AppendFormat("newPosition: {0}\r\n", newPosition);
debugInfo.AppendFormat("_page info: flags - {0}, # of entries {1}, size left: {2}, calculated size left: {3}\r\n", _page.Flags, _page.NumberOfEntries, _page.SizeLeft, _page.CalcSizeLeft());
for (int i = 0; i < _page.NumberOfEntries; i++)
{
var node = _page.GetNode(i);
var key = _page.GetNodeKey(node);
debugInfo.AppendFormat("{0} - {2} {1}\r\n", key,
node->DataSize, node->Flags == NodeFlags.Data ? "Size" : "Page");
}
debugInfo.AppendFormat("rightPage info: flags - {0}, # of entries {1}, size left: {2}, calculated size left: {3}\r\n", rightPage.Flags, rightPage.NumberOfEntries, rightPage.SizeLeft, rightPage.CalcSizeLeft());
for (int i = 0; i < rightPage.NumberOfEntries; i++)
{
var node = rightPage.GetNode(i);
var key = rightPage.GetNodeKey(node);
debugInfo.AppendFormat("{0} - {2} {1}\r\n", key,
node->DataSize, node->Flags == NodeFlags.Data ? "Size" : "Page");
}
throw new InvalidOperationException(debugInfo.ToString(), e);
}
throw;
}
}
