private void addKey(Key key) { treeNodes.put(key, new TreeNode(key, -1, -1)); }
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 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 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()); }
@Override public void insertKey(Key key) throws JasDBStorageException { if(isLeave) { addKey(key); modified = true; if(treeNodes.size() > persister.getMaxKeys()) { List<TreeNode>[] leaveValues = treeNodes.split(); List<TreeNode> leftLeaves = leaveValues[0]; List<TreeNode> rightLeaves = leaveValues[1]; treeNodes.reset(); LeaveBlockImpl leftLeaveBlock = (LeaveBlockImpl) persister.createBlock(BlockTypes.LEAVEBLOCK, getPosition()); LeaveBlockImpl rightLeaveBlock = (LeaveBlockImpl) persister.createBlock(BlockTypes.LEAVEBLOCK, getPosition()); leftLeaveBlock.setNext(rightLeaveBlock.getPosition()); rightLeaveBlock.setPrevious(leftLeaveBlock.getPosition()); addKeys(leftLeaves, leftLeaveBlock); addKeys(rightLeaves, rightLeaveBlock); Key promoteKey = leftLeaves.get(leftLeaves.size() - 1).getKey(); TreeNode rootNode = new TreeNode(promoteKey, leftLeaveBlock.getPosition(), rightLeaveBlock.getPosition()); treeNodes.put(promoteKey, rootNode); isLeave = false; RootBlockFactory.writeHeader(getDataBlock(), false); } } else { throw new JasDBStorageException("Unable to store key, root is not a leave"); } }
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); }
protected void insertBlock(Key key, IndexBlock leftChildBlock, IndexBlock rightChildBlock) throws JasDBStorageException { TreeNode node = new TreeNode(key, leftChildBlock.getPosition(), rightChildBlock.getPosition()); treeNodes.put(key, node); modified = true; /* let's relink all the blocks */ TreeNode previousNode = treeNodes.previous(key); TreeNode nextNode = treeNodes.next(key); if(previousNode != null && nextNode != null) { //we are adding in the middle previousNode.setRight(leftChildBlock.getPosition()); nextNode.setLeft(rightChildBlock.getPosition()); } else if(previousNode != null) { //we are adding in the end previousNode.setRight(leftChildBlock.getPosition()); } else { //we must be adding to the beginning nextNode.setLeft(rightChildBlock.getPosition()); } handleBlockOverflow(); }
private void handleBlockOverflow() throws JasDBStorageException { if(treeNodes.size() > persister.getMaxKeys()) { List<TreeNode>[] blockNodeSplit = treeNodes.split(); List<TreeNode> leftBlockNodes = blockNodeSplit[0]; List<TreeNode> rightBlockNodes = blockNodeSplit[1]; treeNodes.reset(); Key promoteKey = rightBlockNodes.get(0).getKey(); TreeBlock leftBlock = (TreeBlock) persister.createBlock(BlockTypes.NODEBLOCK, getParentPointer()); leftBlock.addNodes(leftBlockNodes, null, leftBlock.getPosition()); if(parentPointer != -1) { //add the nodes, we use -1 as parent does not need to be changed addNodes(rightBlockNodes, promoteKey, getPosition()); TreeBlock parentBlock = (TreeBlock) persister.loadBlock(parentPointer); parentBlock.insertBlock(promoteKey, leftBlock, this); } else { //we are at the root TreeBlock rightBlock = (TreeBlock) persister.createBlock(BlockTypes.NODEBLOCK, getPosition()); rightBlock.addNodes(rightBlockNodes, promoteKey, rightBlock.getPosition()); TreeNode node = new TreeNode(promoteKey, leftBlock.getPosition(), rightBlock.getPosition()); treeNodes.put(node.getKey(), node); } } }
@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; }