@Override public boolean isFinished() { return closed && pageBuilder.isEmpty(); }
@Override public boolean isFinished() { return finishing && pageBuilder.isEmpty(); }
@Override public boolean isFinished() { return finishing && pageBuilder.isEmpty() && currentPage == null; }
@Override public boolean isFinished() { return finishing && outputPages.isEmpty() && currentGroup == null && pageBuilder.isEmpty(); } }
public boolean isFinished() { return finishing && currentInput == null && outputQueue.isEmpty() && pageBuilder.isEmpty(); }
@Override public final boolean isFinished() { return finishing && pageBuilder.isEmpty() && mergingOutput.isFinished(); }
public boolean isEmpty() { return probeIndexBuilder.isEmpty() && buildPageBuilder.isEmpty(); }
private void flushPage() { if (!pageBuilder.isEmpty()) { pages.add(pageBuilder.build()); pageBuilder.reset(); } } }
private void flush() { if (!pageBuilder.isEmpty()) { Page output = pageBuilder.build(); pageBuilder.reset(); outputQueue.add(output); } }
@Override public void finish() { finishing = true; if (currentGroup != null) { evaluateAndFlushGroup(currentGroup, 0); currentGroup = null; } if (!pageBuilder.isEmpty()) { outputPages.add(pageBuilder.build()); pageBuilder.reset(); } }
public void reset() { if (isEmpty()) { return; } pageBuilderStatus = new PageBuilderStatus(pageBuilderStatus.getMaxPageSizeInBytes()); declaredPositions = 0; for (int i = 0; i < types.size(); i++) { blockBuilders[i] = blockBuilders[i].newBlockBuilderLike(pageBuilderStatus.createBlockBuilderStatus()); } }
private synchronized ListenableFuture<?> flush(int partition) { PageBuilder pageBuilder = pageBuilders[partition]; if (pageBuilder.isEmpty()) { return Futures.immediateFuture(null); } Page page = pageBuilder.build(); pageBuilder.reset(); return getSpiller(partition).spill(page); }
@Override public Page getOutput() { // only return a page if the page buffer isFull or we are finishing and the page buffer has data if (pageBuilder.isFull() || (finishing && !pageBuilder.isEmpty())) { Page page = pageBuilder.build(); pageBuilder.reset(); return page; } return null; }
public void flush(boolean force) { // add all full pages to output buffer for (int partition = 0; partition < pageBuilders.length; partition++) { PageBuilder partitionPageBuilder = pageBuilders[partition]; if (!partitionPageBuilder.isEmpty() && (force || partitionPageBuilder.isFull())) { Page pagePartition = partitionPageBuilder.build(); partitionPageBuilder.reset(); List<SerializedPage> serializedPages = splitPage(pagePartition, DEFAULT_MAX_PAGE_SIZE_IN_BYTES).stream() .map(serde::serialize) .collect(toImmutableList()); outputBuffer.enqueue(partition, serializedPages); pagesAdded.incrementAndGet(); rowsAdded.addAndGet(pagePartition.getPositionCount()); } } } }
@Override protected Page computeNext() { while (!pageBuilder.isFull() && pagePositions.hasNext()) { pagePositions.next().appendTo(pageBuilder); } if (pageBuilder.isEmpty()) { return endOfData(); } Page page = pageBuilder.build(); pageBuilder.reset(); return page; }
@Override public Page computeNext() { currentPosition = buildPage(currentPosition, outputChannels, pageBuilder); if (pageBuilder.isEmpty()) { return endOfData(); } Page page = pageBuilder.build(); pageBuilder.reset(); return page; } };
@Override public Page getOutput() { if (state != State.HAS_OUTPUT) { return null; } if (currentPosition >= pageIndex.getPositionCount()) { state = State.FINISHED; return null; } // iterate through the positions sequentially until we have one full page pageBuilder.reset(); currentPosition = pageIndex.buildPage(currentPosition, outputChannels, pageBuilder); // output the page if we have any data if (pageBuilder.isEmpty()) { state = State.FINISHED; return null; } Page page = pageBuilder.build(); return page; }
@Override public Page getNextPage() { verify(pageBuilder.isEmpty()); count = 0; for (int i = 0; i < ROWS_PER_REQUEST; i++) { if (!cursor.hasNext()) { finished = true; break; } currentDoc = cursor.next(); count++; pageBuilder.declarePosition(); for (int column = 0; column < columnTypes.size(); column++) { BlockBuilder output = pageBuilder.getBlockBuilder(column); appendTo(columnTypes.get(column), currentDoc.get(columnNames.get(column)), output); } } Page page = pageBuilder.build(); pageBuilder.reset(); return page; }
private static BiPredicate<PageBuilder, PageWithPosition> keepSameHashValuesWithinSinglePage(InterpretedHashGenerator hashGenerator) { return (pageBuilder, pageWithPosition) -> { long hash = hashGenerator.hashPosition(pageWithPosition.getPosition(), pageWithPosition.getPage()); return !pageBuilder.isEmpty() && hashGenerator.hashPosition(pageBuilder.getPositionCount() - 1, pageBuilder::getBlockBuilder) != hash && pageBuilder.isFull(); }; }
@Override public Page getOutput() { verify(!finished); if (!pageBuilder.isFull() && probe != null) { processProbe(); } if (pageBuilder.isFull()) { Page page = pageBuilder.build(); pageBuilder.reset(); return page; } if (finishing && probe == null) { Page page = null; if (!pageBuilder.isEmpty()) { page = pageBuilder.build(); pageBuilder.reset(); } pagesSpatialIndexFactory.probeOperatorFinished(); pagesSpatialIndexFuture = null; finished = true; return page; } return null; }