Refine search
public void appendTo(PageBuilder pageBuilder, List<Integer> outputChannels, List<Type> outputTypes) { pageBuilder.declarePosition(); for (int i = 0; i < outputChannels.size(); i++) { Type type = outputTypes.get(i); Block block = page.getBlock(outputChannels.get(i)); type.appendTo(block, position, pageBuilder.getBlockBuilder(i)); } } }
private void appendRow(PageBuilder pageBuilder, Page page, int position) { pageBuilder.declarePosition(); for (int channel = 0; channel < sourceTypes.size(); channel++) { Type type = sourceTypes.get(channel); type.appendTo(page.getBlock(channel), position, pageBuilder.getBlockBuilder(channel)); } }
/** * append the index for the probe and append nulls for the build */ public void appendNullForBuild(JoinProbe probe) { // probe side appendProbeIndex(probe); // build side buildPageBuilder.declarePosition(); for (int i = 0; i < buildOutputChannelCount; i++) { buildPageBuilder.getBlockBuilder(i).appendNull(); } }
public Builder add(Object... values) { pageBuilder.declarePosition(); for (int i = 0; i < types.size(); i++) { writeNativeValue(types.get(i), pageBuilder.getBlockBuilder(i), values[i]); } if (pageBuilder.isFull()) { flushPage(); } return this; }
private void evaluateAndFlushGroup(Page page, int position) { pageBuilder.declarePosition(); for (int i = 0; i < groupByTypes.size(); i++) { Block block = page.getBlock(groupByChannels[i]); Type type = groupByTypes.get(i); type.appendTo(block, position, pageBuilder.getBlockBuilder(i)); } int offset = groupByTypes.size(); for (int i = 0; i < aggregates.size(); i++) { aggregates.get(i).evaluate(pageBuilder.getBlockBuilder(offset + i)); } if (pageBuilder.isFull()) { outputPages.add(pageBuilder.build()); pageBuilder.reset(); } aggregates = setupAggregates(step, accumulatorFactories); }
@Override public Page getOutput() { if (state != State.HAS_OUTPUT) { return null; } // project results into output blocks List<Type> types = aggregates.stream().map(Aggregator::getType).collect(toImmutableList()); // output page will only be constructed once, // so a new PageBuilder is constructed (instead of using PageBuilder.reset) PageBuilder pageBuilder = new PageBuilder(1, types); pageBuilder.declarePosition(); for (int i = 0; i < aggregates.size(); i++) { Aggregator aggregator = aggregates.get(i); BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(i); aggregator.evaluate(blockBuilder); } state = State.FINISHED; return pageBuilder.build(); } }
output.declarePosition(); int channel = 0; output.getBlockBuilder(channel).writeLong(groupId); output.getBlockBuilder(channel).appendNull(); output.getBlockBuilder(channel++).writeLong(hashValue); accumulators.get(j).evaluateIntermediate(output.getBlockBuilder(channel)); accumulators.get(j).evaluateFinal(output.getBlockBuilder(channel));
private static void appendToPage(PageBuilder pageBuilder, MaterializedRow row) { for (int field = 0; field < row.getFieldCount(); field++) { Type type = pageBuilder.getType(field); Object value = row.getField(field); BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(field); writeValue(type, blockBuilder, value); } pageBuilder.declarePosition(); }
public static void appendPositionTo(Page page, int position, PageBuilder pageBuilder) { pageBuilder.declarePosition(); for (int i = 0; i < page.getChannelCount(); i++) { Type type = pageBuilder.getType(i); Block block = page.getBlock(i); BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(i); type.appendTo(block, position, blockBuilder); } }
private Page createFragmentsPage() { Collection<Slice> fragments = getFutureValue(finishFuture); committed = true; updateWrittenBytes(); // output page will only be constructed once, // so a new PageBuilder is constructed (instead of using PageBuilder.reset) PageBuilder page = new PageBuilder(fragments.size() + 1, ImmutableList.of(types.get(ROW_COUNT_CHANNEL), types.get(FRAGMENT_CHANNEL))); BlockBuilder rowsBuilder = page.getBlockBuilder(0); BlockBuilder fragmentBuilder = page.getBlockBuilder(1); // write row count page.declarePosition(); BIGINT.writeLong(rowsBuilder, rowCount); fragmentBuilder.appendNull(); // write fragments for (Slice fragment : fragments) { page.declarePosition(); rowsBuilder.appendNull(); VARBINARY.writeSlice(fragmentBuilder, fragment); } return page.build(); }
private synchronized IntArrayList partitionPage(Page page, IntPredicate spillPartitionMask) { IntArrayList unspilledPositions = new IntArrayList(); for (int position = 0; position < page.getPositionCount(); position++) { int partition = partitionFunction.getPartition(page, position); if (!spillPartitionMask.test(partition)) { unspilledPositions.add(position); continue; } spilledPartitions.add(partition); PageBuilder pageBuilder = pageBuilders[partition]; pageBuilder.declarePosition(); for (int channel = 0; channel < types.size(); channel++) { Type type = types.get(channel); type.appendTo(page.getBlock(channel), position, pageBuilder.getBlockBuilder(channel)); } } return unspilledPositions; }
@Override public Page getOutput() { if ((state != State.FINISHING) || !finishFuture.isDone()) { return null; } state = State.FINISHED; Collection<Slice> fragments = getFutureValue(finishFuture); // output page will only be constructed once, // so a new PageBuilder is constructed (instead of using PageBuilder.reset) PageBuilder page = new PageBuilder(fragments.size() + 1, TYPES); BlockBuilder rowsBuilder = page.getBlockBuilder(0); BlockBuilder fragmentBuilder = page.getBlockBuilder(1); // write row count page.declarePosition(); BIGINT.writeLong(rowsBuilder, rowCount); fragmentBuilder.appendNull(); // write fragments for (Slice fragment : fragments) { page.declarePosition(); rowsBuilder.appendNull(); VARBINARY.writeSlice(fragmentBuilder, fragment); } return page.build(); }
private static Page makeInput(int numberOfBuckets) { PageBuilder builder = new PageBuilder(ImmutableList.of(BIGINT, DOUBLE, DOUBLE)); for (int i = 0; i < 100; i++) { builder.declarePosition(); BIGINT.writeLong(builder.getBlockBuilder(0), numberOfBuckets); DOUBLE.writeDouble(builder.getBlockBuilder(1), i); // value DOUBLE.writeDouble(builder.getBlockBuilder(2), 1); // weight } return builder.build(); } }
private static Page makeInput(int numberOfBuckets) { PageBuilder builder = new PageBuilder(ImmutableList.of(BIGINT, REAL, DOUBLE)); for (int i = 0; i < 100; i++) { builder.declarePosition(); BIGINT.writeLong(builder.getBlockBuilder(0), numberOfBuckets); REAL.writeLong(builder.getBlockBuilder(1), i); // value DOUBLE.writeDouble(builder.getBlockBuilder(2), 1); // weight } return builder.build(); } }
public int buildPage(int position, int[] outputChannels, PageBuilder pageBuilder) { while (!pageBuilder.isFull() && position < positionCount) { long pageAddress = valueAddresses.getLong(position); int blockIndex = decodeSliceIndex(pageAddress); int blockPosition = decodePosition(pageAddress); // append the row pageBuilder.declarePosition(); for (int i = 0; i < outputChannels.length; i++) { int outputChannel = outputChannels[i]; Type type = types.get(outputChannel); Block block = this.channels[outputChannel].get(blockIndex); type.appendTo(block, blockPosition, pageBuilder.getBlockBuilder(i)); } position++; } return position; }
@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; }
@Override public Page getOutput() { if (finished) { return null; } finished = true; OptionalLong rowsDeletedCount = metadata.metadataDelete(session, tableHandle, tableLayout); // output page will only be constructed once, // so a new PageBuilder is constructed (instead of using PageBuilder.reset) PageBuilder page = new PageBuilder(1, TYPES); BlockBuilder rowsBuilder = page.getBlockBuilder(0); page.declarePosition(); if (rowsDeletedCount.isPresent()) { BIGINT.writeLong(rowsBuilder, rowsDeletedCount.getAsLong()); } else { rowsBuilder.appendNull(); } return page.build(); } }
int hashChannel = channels[i]; Type type = types.get(i); type.appendTo(page.getBlock(hashChannel), position, currentPageBuilder.getBlockBuilder(i)); BIGINT.writeLong(currentPageBuilder.getBlockBuilder(precomputedHashChannel.getAsInt()), rawHash); currentPageBuilder.declarePosition(); int pageIndex = channelBuilders.get(0).size() - 1; int pagePosition = currentPageBuilder.getPositionCount() - 1;
private Page getSelectedRows() { verify(selectedRowPageBuilder.isPresent()); int rowNumberChannel = types.size() - 1; PageBuilder pageBuilder = selectedRowPageBuilder.get(); verify(pageBuilder.isEmpty()); for (int currentPosition = 0; currentPosition < inputPage.getPositionCount(); currentPosition++) { long partitionId = getPartitionId(currentPosition); long rowCount = partitionRowCount.get(partitionId); if (rowCount == maxRowsPerPartition.get()) { continue; } pageBuilder.declarePosition(); for (int i = 0; i < outputChannels.length; i++) { int channel = outputChannels[i]; Type type = types.get(i); type.appendTo(inputPage.getBlock(channel), currentPosition, pageBuilder.getBlockBuilder(i)); } BIGINT.writeLong(pageBuilder.getBlockBuilder(rowNumberChannel), rowCount + 1); partitionRowCount.set(partitionId, rowCount + 1); } if (pageBuilder.isEmpty()) { return null; } Page page = pageBuilder.build(); pageBuilder.reset(); return page; }
public void processNextRow(PageBuilder pageBuilder) { checkState(hasNext(), "No more rows in partition"); // copy output channels pageBuilder.declarePosition(); int channel = 0; while (channel < outputChannels.length) { pagesIndex.appendTo(outputChannels[channel], currentPosition, pageBuilder.getBlockBuilder(channel)); channel++; } // check for new peer group if (currentPosition == peerGroupEnd) { updatePeerGroup(); } for (FramedWindowFunction framedFunction : windowFunctions) { Range range = getFrameRange(framedFunction.getFrame()); framedFunction.getFunction().processRow( pageBuilder.getBlockBuilder(channel), peerGroupStart - partitionStart, peerGroupEnd - partitionStart - 1, range.getStart(), range.getEnd()); channel++; } currentPosition++; }