@Override public final void appendNext(PageBuilder pageBuilder, int outputChannelOffset) { checkState(arrayBlock != null, "arrayBlock is null"); BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(outputChannelOffset); elementType.appendTo(arrayBlock, position, blockBuilder); position++; }
public void pop(BlockBuilder resultBlockBuilder) { type.appendTo(heapBlockBuilder, heapIndex[0], resultBlockBuilder); remove(); }
public void pop(BlockBuilder resultBlockBuilder) { type.appendTo(heapBlockBuilder, heapIndex[0], resultBlockBuilder); remove(); }
private void appendProbe() { int outputChannelOffset = 0; for (int outputIndex : probeOutputChannels) { Type type = probeTypes.get(outputIndex); Block block = probe.getBlock(outputIndex); type.appendTo(block, probePosition, pageBuilder.getBlockBuilder(outputChannelOffset)); outputChannelOffset++; } }
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)); } }
private void addKey(Block key, int position) { checkArgument(position >= 0, "position is negative"); keyType.appendTo(key, position, keyBlockBuilder); int hashPosition = getHashPositionOfKey(key, position); if (keyPositionByHash[hashPosition] == EMPTY_SLOT) { keyPositionByHash[hashPosition] = keyBlockBuilder.getPositionCount() - 1; if (keyBlockBuilder.getPositionCount() >= maxFill) { rehash(); } } }
/** * given an output outputBlockBuilder, writes one row (key -> count) of our histogram * * @param valuesBlock - values.build() is called externally */ void writeNodeAsBlock(Block valuesBlock, BlockBuilder outputBlockBuilder) { type.appendTo(valuesBlock, getValuePosition(), outputBlockBuilder); BIGINT.writeLong(outputBlockBuilder, getCount()); } }
private static void appendTypedArray(Block array, Type type, TypedSet typedSet, BlockBuilder blockBuilder) { for (int i = 0; i < array.getPositionCount(); i++) { if (!typedSet.contains(array, i)) { typedSet.add(array, i); type.appendTo(array, i, blockBuilder); } } }
public void appendTo(int channel, int position, BlockBuilder output) { long pageAddress = valueAddresses.getLong(position); Type type = types.get(channel); Block block = channels[channel].get(decodeSliceIndex(pageAddress)); int blockPosition = decodePosition(pageAddress); type.appendTo(block, blockPosition, output); }
static void write(Type type, BlockPositionState state, BlockBuilder out) { if (state.getBlock() == null) { out.appendNull(); } else { type.appendTo(state.getBlock(), state.getPosition(), out); } } }
static void write(Type type, BlockPositionState state, BlockBuilder out) { if (state.getBlock() == null) { out.appendNull(); } else { type.appendTo(state.getBlock(), state.getPosition(), out); } } }
private Block computeResultBlock(Type type, Block block, int arrayLength) { if (pageBuilder.isFull()) { pageBuilder.reset(); } BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(0); for (int i = 0; i < arrayLength; ++i) { type.appendTo(block, positions.get(i), blockBuilder); } pageBuilder.declarePositions(arrayLength); return blockBuilder.getRegion(blockBuilder.getPositionCount() - arrayLength, arrayLength); }
public static void output(Type elementType, ArrayAggregationState state, BlockBuilder out) { if (state.isEmpty()) { out.appendNull(); } else { BlockBuilder entryBuilder = out.beginBlockEntry(); state.forEach((block, position) -> elementType.appendTo(block, position, entryBuilder)); out.closeEntry(); } } }
@UsedByGeneratedCode public static Block prependElement(Type elementType, long value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeLong(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); }
@UsedByGeneratedCode public static Block prependElement(Type elementType, Slice value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeSlice(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); }
@UsedByGeneratedCode public static Block prependElement(Type elementType, double value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeDouble(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); } }
@UsedByGeneratedCode public static Block prependElement(Type elementType, long value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeLong(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); }
@UsedByGeneratedCode public static Block prependElement(Type elementType, boolean value, Block block) { BlockBuilder blockBuilder = elementType.createBlockBuilder(null, block.getPositionCount() + 1); elementType.writeBoolean(blockBuilder, value); for (int i = 0; i < block.getPositionCount(); i++) { elementType.appendTo(block, i, blockBuilder); } return blockBuilder.build(); }