@Override public Block getSingleValueBlock(int position) { return block.getSingleValueBlock(position); }
@Override public Block getSingleValueBlock(int position) { return dictionary.getSingleValueBlock(getId(position)); }
/** * Gets the values at the specified position as a single element page. The method creates independent * copy of the data. */ public Page getSingleValuePage(int position) { Block[] singleValueBlocks = new Block[this.blocks.length]; for (int i = 0; i < this.blocks.length; i++) { singleValueBlocks[i] = this.blocks[i].getSingleValueBlock(position); } return new Page(1, singleValueBlocks); }
@Override public Block getSingleValueBlock(int position) { assureLoaded(); return block.getSingleValueBlock(position); }
@Override public Block getSingleValueBlock(int position) { position = getAbsolutePosition(position); if (position % 2 == 0) { return getRawKeyBlock().getSingleValueBlock(position / 2); } else { return getRawValueBlock().getSingleValueBlock(position / 2); } }
@Override public Block getSingleValueBlock(int position) { checkFieldIndex(position); return getRawFieldBlock(position).getSingleValueBlock(rowIndex); }
@Override public Block getSingleValueBlock(int position) { checkReadablePosition(position); return getBlock().getSingleValueBlock(position + start); }
private ComputedStatistics getComputedStatistics(Page page, int position) { ImmutableList.Builder<String> groupingColumns = ImmutableList.builder(); ImmutableList.Builder<Block> groupingValues = ImmutableList.builder(); descriptor.getGrouping().forEach((column, channel) -> { groupingColumns.add(column); groupingValues.add(page.getBlock(channel).getSingleValueBlock(position)); }); ComputedStatistics.Builder statistics = ComputedStatistics.builder(groupingColumns.build(), groupingValues.build()); descriptor.getTableStatistics().forEach((type, channel) -> statistics.addTableStatistic(type, page.getBlock(channel).getSingleValueBlock(position))); descriptor.getColumnStatistics().forEach((metadata, channel) -> statistics.addColumnStatistic(metadata, page.getBlock(channel).getSingleValueBlock(position))); return statistics.build(); }
public Block getSingleValueBlock(int channel, int position) { long pageAddress = valueAddresses.getLong(position); Block block = channels[channel].get(decodeSliceIndex(pageAddress)); int blockPosition = decodePosition(pageAddress); return block.getSingleValueBlock(blockPosition); }
public static <T> void assertBlockPosition(Block block, int position, T expectedValue) { assertPositionValue(block, position, expectedValue); assertPositionValue(block.getSingleValueBlock(position), 0, expectedValue); }
@Override public Page next() { if (!hasNext()) { throw new NoSuchElementException(); } if (noColumnShortcutResult >= 0) { rowIndex = maxRowIndex; return new Page(noColumnShortcutResult); } rowIndex++; // Create an array of blocks for all columns in both pages. Block[] blocks = new Block[numberOfProbeColumns + numberOfBuildColumns]; // Make sure we always put the probe data on the left and build data on the right. int indexForRleBlocks = buildPageLarger ? 0 : numberOfProbeColumns; int indexForPageBlocks = buildPageLarger ? numberOfProbeColumns : 0; // For the page with less rows, create RLE blocks and add them to the blocks array for (int i = 0; i < smallPage.getChannelCount(); i++) { Block block = smallPage.getBlock(i).getSingleValueBlock(rowIndex); blocks[indexForRleBlocks] = new RunLengthEncodedBlock(block, largePage.getPositionCount()); indexForRleBlocks++; } // Put the page with more rows in the blocks array for (int i = 0; i < largePage.getChannelCount(); i++) { blocks[indexForPageBlocks + i] = largePage.getBlock(i); } return new Page(largePage.getPositionCount(), blocks); } }
@Override protected Object getGreaterValue(Object value) { RowBlockBuilder blockBuilder = (RowBlockBuilder) TYPE.createBlockBuilder(null, 1); SingleRowBlockWriter singleRowBlockWriter; Block block = (Block) value; singleRowBlockWriter = blockBuilder.beginBlockEntry(); BIGINT.writeLong(singleRowBlockWriter, block.getSingleValueBlock(0).getLong(0, 0) + 1); VARCHAR.writeSlice(singleRowBlockWriter, block.getSingleValueBlock(1).getSlice(0, 0, 1)); blockBuilder.closeEntry(); return TYPE.getObject(blockBuilder.build(), 0); } }
return array.getSingleValueBlock(0);
protected void assertPositionEquals(Block block, int position, Object expectedStackValue, Object expectedObjectValue) { long hash = 0; if (type.isComparable()) { hash = hashPosition(type, block, position); } assertPositionValue(block, position, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getSingleValueBlock(position), 0, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getRegion(position, 1), 0, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getRegion(0, position + 1), position, expectedStackValue, hash, expectedObjectValue); assertPositionValue(block.getRegion(position, block.getPositionCount() - position), 0, expectedStackValue, hash, expectedObjectValue); BlockBuilder blockBuilder = type.createBlockBuilder(null, 1); type.appendTo(block, position, blockBuilder); assertPositionValue(blockBuilder.build(), 0, expectedStackValue, hash, expectedObjectValue); }
protected <T> void assertBlockPosition(Block block, Supplier<BlockBuilder> newBlockBuilder, int position, T expectedValue, Class<?> expectedValueType) { assertPositionValue(block, position, expectedValue); assertPositionValue(block.getSingleValueBlock(position), 0, expectedValue); assertPositionValue(block.getRegion(position, 1), 0, expectedValue); assertPositionValue(block.getRegion(0, position + 1), position, expectedValue); assertPositionValue(block.getRegion(position, block.getPositionCount() - position), 0, expectedValue); assertPositionValue(copyBlockViaBlockSerde(block.getRegion(position, 1)), 0, expectedValue); assertPositionValue(copyBlockViaBlockSerde(block.getRegion(0, position + 1)), position, expectedValue); assertPositionValue(copyBlockViaBlockSerde(block.getRegion(position, block.getPositionCount() - position)), 0, expectedValue); assertPositionValue(copyBlockViaWritePositionTo(block.getRegion(position, 1), newBlockBuilder), 0, expectedValue); assertPositionValue(copyBlockViaWritePositionTo(block.getRegion(0, position + 1), newBlockBuilder), position, expectedValue); assertPositionValue(copyBlockViaWritePositionTo(block.getRegion(position, block.getPositionCount() - position), newBlockBuilder), 0, expectedValue); if (expectedValueType.isArray() || expectedValueType == List.class || expectedValueType == Map.class) { assertPositionValue(copyBlockViaWriteStructure(block.getRegion(position, 1), newBlockBuilder), 0, expectedValue); assertPositionValue(copyBlockViaWriteStructure(block.getRegion(0, position + 1), newBlockBuilder), position, expectedValue); assertPositionValue(copyBlockViaWriteStructure(block.getRegion(position, block.getPositionCount() - position), newBlockBuilder), 0, expectedValue); } assertPositionValue(block.copyRegion(position, 1), 0, expectedValue); assertPositionValue(block.copyRegion(0, position + 1), position, expectedValue); assertPositionValue(block.copyRegion(position, block.getPositionCount() - position), 0, expectedValue); assertPositionValue(block.copyPositions(new int[] {position}, 0, 1), 0, expectedValue); }
private static Block[] getValues(int position, Block[] blocks) { Block[] row = new Block[blocks.length]; for (int i = 0; i < blocks.length; i++) { row[i] = blocks[i].getSingleValueBlock(position); } return row; }
private static Block[] getSingleValueBlocks(Page page, int position) { Block[] blocks = page.getBlocks(); Block[] row = new Block[blocks.length]; for (int i = 0; i < blocks.length; i++) { row[i] = blocks[i].getSingleValueBlock(position); } return row; }
@Override public Block getSingleValueBlock(int position) { return dictionary.getSingleValueBlock(getId(position)); }
@Override public Block getSingleValueBlock(int position) { position = getAbsolutePosition(position); if (position % 2 == 0) { return getRawKeyBlock().getSingleValueBlock(position / 2); } else { return getRawValueBlock().getSingleValueBlock(position / 2); } }
@Override public Block getSingleValueBlock(int position) { checkReadablePosition(position); return getBlock().getSingleValueBlock(position + start); }