public RTreeOpContext(IRTreeLeafFrame leafFrame, IRTreeInteriorFrame interiorFrame, IPageManager freePageManager, IBinaryComparatorFactory[] cmpFactories, IModificationOperationCallback modificationCallback) { if (cmpFactories[0] != null) { this.cmp = MultiComparator.create(cmpFactories); } else { this.cmp = null; } this.interiorFrame = interiorFrame; this.leafFrame = leafFrame; this.freePageManager = freePageManager; this.metaFrame = freePageManager.createMetadataFrame(); this.modificationCallback = modificationCallback; pathList = new PathList(INITIAL_HEIGHT, INITIAL_HEIGHT); NSNUpdates = new ArrayList<>(); LSNUpdates = new ArrayList<>(); }
@Override public synchronized void deactivate() throws HyracksDataException { if (!isActive) { throw HyracksDataException.create(ErrorCode.CANNOT_DEACTIVATE_INACTIVE_INDEX); } freePageManager.close(HaltOnFailureCallback.INSTANCE); bufferCache.closeFile(fileId); isActive = false; }
@Override public void returnFreePageBlock(int blockPageId, int size) throws HyracksDataException { freePageManager.releaseBlock(metaFrame, blockPageId, size); }
private void setRootPage() throws HyracksDataException { rootPage = freePageManager.getRootPageId(); bulkloadLeafStart = freePageManager.getBulkLoadLeaf(); }
private void persistFrontiers(int level, int rightPage) throws HyracksDataException { if (level >= nodeFrontiers.size()) { rootPage = nodeFrontiers.get(level - 1).pageId; releasedLatches = true; return; } if (level < 1) { ICachedPage lastLeaf = nodeFrontiers.get(level).page; int lastLeafPage = nodeFrontiers.get(level).pageId; lastLeaf.setDiskPageId(BufferedFileHandle.getDiskPageId(getFileId(), nodeFrontiers.get(level).pageId)); putInQueue(lastLeaf); nodeFrontiers.get(level).page = null; persistFrontiers(level + 1, lastLeafPage); return; } NodeFrontier frontier = nodeFrontiers.get(level); interiorFrame.setPage(frontier.page); //just finalize = the layer right above the leaves has correct righthand pointers already if (rightPage < 0) { throw new HyracksDataException( "Error in index creation. Internal node appears to have no rightmost guide"); } ((IBTreeInteriorFrame) interiorFrame).setRightmostChildPageId(rightPage); int finalPageId = freePageManager.takePage(metaFrame); frontier.page.setDiskPageId(BufferedFileHandle.getDiskPageId(getFileId(), finalPageId)); putInQueue(frontier.page); frontier.pageId = finalPageId; persistFrontiers(level + 1, finalPageId); }
public AbstractTreeIndexBulkLoader(float fillFactor) throws HyracksDataException { leafFrame = leafFrameFactory.createFrame(); interiorFrame = interiorFrameFactory.createFrame(); metaFrame = freePageManager.createMetadataFrame(); queue = bufferCache.createFIFOQueue(); if (!isEmptyTree(leafFrame)) { throw HyracksDataException.create(ErrorCode.CANNOT_BULK_LOAD_NON_EMPTY_TREE); } this.cmp = MultiComparator.create(cmpFactories); leafFrame.setMultiComparator(cmp); interiorFrame.setMultiComparator(cmp); tupleWriter = leafFrame.getTupleWriter(); NodeFrontier leafFrontier = new NodeFrontier(leafFrame.createTupleReference()); leafFrontier.pageId = freePageManager.takePage(metaFrame); leafFrontier.page = bufferCache.confiscatePage(BufferedFileHandle.getDiskPageId(fileId, leafFrontier.pageId)); interiorFrame.setPage(leafFrontier.page); interiorFrame.initBuffer((byte) 0); interiorMaxBytes = (int) (interiorFrame.getBuffer().capacity() * fillFactor); leafFrame.setPage(leafFrontier.page); leafFrame.initBuffer((byte) 0); leafMaxBytes = (int) (leafFrame.getBuffer().capacity() * fillFactor); slotSize = leafFrame.getSlotSize(); nodeFrontiers.add(leafFrontier); pagesToWrite = new ArrayList<>(); compressedPageWriter = bufferCache.getCompressedPageWriter(fileId); }
int fileId = bufferCache.openFile(fileRef); treeIndexStats.begin(); int maxPageId = freePageManager.getMaxPageId(metaFrame); for (int pageId = 0; pageId <= maxPageId; pageId++) { ICachedPage page = bufferCache.pin(BufferedFileHandle.getDiskPageId(fileId, pageId), false);
protected TreeIndexState isValidTreeIndex(ITreeIndex treeIndex) throws HyracksDataException { IBufferCache bufferCache = treeIndex.getBufferCache(); treeIndex.activate(); try { int metadataPage = treeIndex.getPageManager().getMetadataPageId(); if (metadataPage < 0) { return TreeIndexState.INVALID; } ITreeIndexMetadataFrame metadataFrame = treeIndex.getPageManager().createMetadataFrame(); ICachedPage page = bufferCache.pin(BufferedFileHandle.getDiskPageId(treeIndex.getFileId(), metadataPage), false); page.acquireReadLatch(); try { metadataFrame.setPage(page); if (!metadataFrame.isValid()) { return TreeIndexState.INVALID; } else if (metadataFrame.getVersion() != ITreeIndexFrame.Constants.VERSION) { return TreeIndexState.VERSION_MISMATCH; } else { return TreeIndexState.VALID; } } finally { page.releaseReadLatch(); bufferCache.unpin(page); } } finally { treeIndex.deactivate(); } }
@Override public synchronized void create() throws HyracksDataException { if (isActive) { throw HyracksDataException.create(ErrorCode.CANNOT_CREATE_ACTIVE_INDEX); } fileId = bufferCache.createFile(file); boolean failed = true; try { bufferCache.openFile(fileId); failed = false; } finally { if (failed) { bufferCache.deleteFile(fileId); } } failed = true; try { freePageManager.open(fileId); freePageManager.init(interiorFrameFactory, leafFrameFactory); setRootPage(); freePageManager.close(HaltOnFailureCallback.INSTANCE); failed = false; } finally { bufferCache.closeFile(fileId); if (failed) { bufferCache.deleteFile(fileId); } } }
@Override public int getFreeBlock(int size) throws HyracksDataException { return freePageManager.takeBlock(metaFrame, size); }
prevPageId); int finalPageId = freePageManager.takePage(metaFrame); n.pageId = finalPageId; n.page.setDiskPageId(BufferedFileHandle.getDiskPageId(getFileId(), finalPageId));
private void diskOrderScan(ITreeIndexCursor icursor, RTreeOpContext ctx) throws HyracksDataException { TreeIndexDiskOrderScanCursor cursor = (TreeIndexDiskOrderScanCursor) icursor; ctx.reset(); MultiComparator cmp = MultiComparator.create(cmpFactories); SearchPredicate searchPred = new SearchPredicate(null, cmp); int currentPageId = bulkloadLeafStart; int maxPageId = freePageManager.getMaxPageId(ctx.getMetaFrame()); ICachedPage page = bufferCache.pin(BufferedFileHandle.getDiskPageId(getFileId(), currentPageId), false); page.acquireReadLatch(); try { cursor.setBufferCache(bufferCache); cursor.setFileId(getFileId()); cursor.setCurrentPageId(currentPageId); cursor.setMaxPageId(maxPageId); ctx.getCursorInitialState().setOriginialKeyComparator(ctx.getCmp()); ctx.getCursorInitialState().setPage(page); cursor.open(ctx.getCursorInitialState(), searchPred); } catch (Exception e) { page.releaseReadLatch(); bufferCache.unpin(page); throw HyracksDataException.create(e); } }
@Override public int getFreeBlock(int size) throws HyracksDataException { return freePageManager.takeBlock(getMetaFrame(), size); }
leafFrontier.pageId = freePageManager.takePage(metaFrame);
this.metaFrame = freePageManager.createMetadataFrame(); this.pageLsns = new LongArrayList(INIT_ARRAYLIST_SIZE, INIT_ARRAYLIST_SIZE); this.smoCount = 0;
private void diskOrderScan(ITreeIndexCursor icursor, BTreeOpContext ctx) throws HyracksDataException { TreeIndexDiskOrderScanCursor cursor = (TreeIndexDiskOrderScanCursor) icursor; ctx.reset(); RangePredicate diskOrderScanPred = new RangePredicate(null, null, true, true, ctx.getCmp(), ctx.getCmp()); int maxPageId = freePageManager.getMaxPageId(ctx.getMetaFrame()); int currentPageId = bulkloadLeafStart; ICachedPage page = bufferCache.pin(BufferedFileHandle.getDiskPageId(getFileId(), currentPageId), false); try { cursor.setBufferCache(bufferCache); cursor.setFileId(getFileId()); cursor.setCurrentPageId(currentPageId); cursor.setMaxPageId(maxPageId); ctx.getCursorInitialState().setPage(page); ctx.getCursorInitialState().setSearchOperationCallback(ctx.getSearchCallback()); ctx.getCursorInitialState().setOriginialKeyComparator(ctx.getCmp()); cursor.open(ctx.getCursorInitialState(), diskOrderScanPred); } catch (Exception e) { bufferCache.unpin(page); throw HyracksDataException.create(e); } }
public static void markAsValid(ITreeIndex treeIndex, boolean forceToDisk, IPageWriteFailureCallback callback) throws HyracksDataException { int fileId = treeIndex.getFileId(); IBufferCache bufferCache = treeIndex.getBufferCache(); treeIndex.getPageManager().close(callback); if (callback.hasFailed()) { throw HyracksDataException.create(callback.getFailure()); } // Force modified metadata page to disk. // If the index is not durable, then the flush is not necessary. if (forceToDisk) { bufferCache.force(fileId, true); } }
@Override public void returnFreePageBlock(int blockPageId, int size) throws HyracksDataException { freePageManager.releaseBlock(getMetaFrame(), blockPageId, size); }
if (spaceForTwoTuples != FrameOpSpaceStatus.SUFFICIENT_CONTIGUOUS_SPACE && !toRoot) { int finalPageId = freePageManager.takePage(metaFrame); if (prevNodeFrontierPages.size() <= level) { prevNodeFrontierPages.add(finalPageId);