protected void removeBlockPointer(Key minBlockValue, IndexBlock removedBlock) throws JasDBStorageException { TreeNode removeNode = treeNodes.getBefore(minBlockValue); // LOG.info("Closest remove node: {} nodes: {}", removeNode, treeNodes.size()); TreeNode next = treeNodes.next(removeNode.getKey()); if(next != null && removeNode.getLeft() != removedBlock.getPosition()) { //we need to relink the next block next.setLeft(removeNode.getLeft()); } treeNodes.remove(removeNode.getKey()); modified = true; handleBlockUnderflow(); }
protected Key getMin() throws JasDBStorageException { TreeNode node = treeNodes.first(); IndexBlock leftBlock = persister.loadBlock(node.getLeft()); if(leftBlock instanceof TreeBlock) { return ((TreeBlock)leftBlock).getMin(); } else { return leftBlock.getFirst(); } }
@Override public LeaveBlock findFirstLeaveBlock(LockIntentType intentType) throws JasDBStorageException { TreeNode firstNode = treeNodes.first(); IndexBlock block = persister.loadBlock(firstNode.getLeft()); persister.getLockManager().acquireLock(intentType, block); return block.findFirstLeaveBlock(intentType); }
protected void addNodes(List<TreeNode> nodes, Key exclude, long parentBlock) throws JasDBStorageException { for(TreeNode node : nodes) { boolean isExcluded = exclude != null && exclude.equals(node.getKey()); if(parentBlock != -1 && (!isExcluded)) { if(node.getLeft() != -1) { IndexBlock block = persister.loadBlock(node.getLeft()); block.setParentPointer(parentBlock); } if(node.getRight() != -1) { IndexBlock block = persister.loadBlock(node.getRight()); block.setParentPointer(parentBlock); } } if(!isExcluded) { treeNodes.put(node.getKey(), node); } } }
@Override public LeaveBlock findLeaveBlock(LockIntentType intent, Key key) throws JasDBStorageException { TreeNode closestNode = treeNodes.getBefore(key); Key nodeKey = closestNode.getKey(); int compare = key.compareTo(nodeKey); long blockPointer; if(compare <= 0) { blockPointer = closestNode.getLeft(); } else { blockPointer = closestNode.getRight(); } IndexBlock block = persister.loadBlock(blockPointer); persister.getLockManager().acquireLock(intent, block); return block.findLeaveBlock(intent, key); }
@Override public void persistBlock(TreeBlock treeBlock) throws JasDBStorageException { if(treeBlock.isModified()) { LOG.debug("Persisting block at position: {}", treeBlock.getPosition()); List<TreeNode> treeNodes = treeBlock.getNodes().values(); DataBlock dataBlock = treeBlock.getDataBlock(); dataBlock.reset(); dataBlock.getHeader().putLong(PARENTPOINTER_INDEX, treeBlock.getParentPointer()); dataBlock.getHeader().putInt(NODEAMOUNT_INDEX, treeNodes.size()); for(TreeNode treeNode : treeNodes) { dataBlock = writeKey(treeBlock, treeNode.getKey(), dataBlock); dataBlock = dataBlock.writeLong(treeNode.getLeft()).getDataBlock(); dataBlock = dataBlock.writeLong(treeNode.getRight()).getDataBlock(); } } }
TreeNode next = treeNodes.next(removeNode.getKey()); if(next != null && removeNode.getLeft() != removedBlock.getPosition()) { next.setLeft(removeNode.getLeft()); LOG.debug("Merging into root"); TreeNode lastTreeNode = treeNodes.first(); IndexBlock leftBlock = persister.loadBlock(lastTreeNode.getLeft()); IndexBlock rightBlock = persister.loadBlock(lastTreeNode.getRight());
protected void updateBlockPointer(Key replaceKey, long leftBlock, long rightBlock) throws JasDBStorageException { modified = true; if(treeNodes.contains(replaceKey)) { treeNodes.remove(replaceKey); treeNodes.put(replaceKey, new TreeNode(replaceKey, leftBlock, rightBlock)); } else { treeNodes.put(replaceKey, new TreeNode(replaceKey, leftBlock, rightBlock)); TreeNode previousNode = treeNodes.previous(replaceKey); TreeNode nextNode = treeNodes.next(replaceKey); if(previousNode != null && nextNode != null) { //we are updating in the middle if(previousNode.getLeft() == leftBlock && previousNode.getRight() == rightBlock) { //the previous node is the one we are replacing, lets remove it treeNodes.remove(previousNode.getKey()); } else if(nextNode.getLeft() == leftBlock && nextNode.getRight() == rightBlock) { //the next node is the one we are replacing, lets remove it treeNodes.remove(nextNode.getKey()); } else { throw new JasDBStorageException("Unable to update the pointer after remove, invalid state"); } } else if(previousNode != null) { //we are updating at the end of the chain treeNodes.remove(previousNode.getKey()); } else { //we must be updating in the beginning of the chain treeNodes.remove(nextNode.getKey()); } } }
private void handleBorrowRight(TreeBlock parentBlock, TreeBlock rightSibbling) throws JasDBStorageException { //we can borrow from right TreeNode rightFirstNode = rightSibbling.getNodes().first(); IndexBlock danglingBlock = persister.loadBlock(rightFirstNode.getLeft()); danglingBlock.setParentPointer(getPosition()); Key newKey = getMax(); rightSibbling.removeNodeInternal(rightFirstNode); TreeNode newNode = new TreeNode(newKey, treeNodes.last().getRight(), danglingBlock.getPosition()); treeNodes.put(newKey, newNode); Key parentKey = getMax(); parentBlock.updateBlockPointer(parentKey, getPosition(), rightSibbling.getPosition()); }
private void handleBorrowLeft(TreeBlock parentBlock, TreeBlock leftSibbling) throws JasDBStorageException { //we can borrow from left TreeNode node = leftSibbling.getNodes().last(); //this block needs relinking IndexBlock danglingBlock = persister.loadBlock(node.getRight()); danglingBlock.setParentPointer(getPosition()); Key newKey = leftSibbling.getMax(); leftSibbling.removeNodeInternal(node); TreeNode newNode = new TreeNode(newKey, danglingBlock.getPosition(), treeNodes.first().getLeft()); treeNodes.put(newKey, newNode); parentBlock.updateBlockPointer(leftSibbling.getMax(), leftSibbling.getPosition(), getPosition()); }
private void handleMerge(TreeBlock parentBlock, TreeBlock leftSibbling, TreeBlock rightSibbling) throws JasDBStorageException { Key removeKey; if(leftSibbling != null) { Key mergeKey = leftSibbling.getMax(); TreeNode leftSibblingLastNode = leftSibbling.getNodes().last(); TreeNode currentFirstNode = treeNodes.first(); removeKey = currentFirstNode.getKey(); TreeNode mergeNode = new TreeNode(mergeKey, leftSibblingLastNode.getRight(), currentFirstNode.getLeft()); leftSibbling.addKey(mergeNode); leftSibbling.addNodes(treeNodes.values(), null, leftSibbling.getPosition()); } else if(rightSibbling != null) { Key mergeKey = getMax(); TreeNode rightFirstNode = rightSibbling.getNodes().first(); TreeNode currentLastNode = treeNodes.last(); removeKey = currentLastNode.getKey(); TreeNode mergeNode = new TreeNode(mergeKey, currentLastNode.getRight(), rightFirstNode.getLeft()); rightSibbling.addKey(mergeNode); rightSibbling.addNodes(treeNodes.values(), null, rightSibbling.getPosition()); } else { throw new JasDBStorageException("Invalid index state there should always be a sibbling tree block"); } treeNodes.reset(); persister.markDeleted(this); parentBlock.removeBlockPointer(removeKey, this); }
@Override public TreeBlock loadBlock(DataBlock dataBlock) throws JasDBStorageException { TreeBlock treeBlock = createBlock(-1, dataBlock); treeBlock.setModified(false); treeBlock.setParentPointer(dataBlock.getHeader().getLong(PARENTPOINTER_INDEX)); int nrNodes = dataBlock.getHeader().getInt(NODEAMOUNT_INDEX); int offset = 0; DataBlock currentBlock = dataBlock; for(int i=0; i<nrNodes; i++) { KeyLoadResult loadedKeyResult = loadKeyResult(treeBlock, offset, currentBlock); DataBlockResult<Long> leftPointerResult = loadedKeyResult.getEndBlock().loadLong(loadedKeyResult.getNextOffset()); DataBlockResult<Long> rightPointerResult = leftPointerResult.getEndBlock().loadLong(leftPointerResult.getNextOffset()); TreeNode node = new TreeNode(loadedKeyResult.getLoadedKey(), leftPointerResult.getValue(), rightPointerResult.getValue()); treeBlock.addKey(node); LOG.trace("Loaded Key: {} with left: {} and right: {} on block: {}", node.getKey(), node.getLeft(), node.getRight(), treeBlock.getPosition()); offset = rightPointerResult.getNextOffset(); currentBlock = rightPointerResult.getEndBlock(); } return treeBlock; }