private PageRecordCursor(List<Type> types, Page page) { this.types = ImmutableList.copyOf(requireNonNull(types, "types is null")); this.page = requireNonNull(page, "page is null"); checkArgument(types.size() == page.getChannelCount(), "Types do not match page channels"); }
public PageRecordSet(List<Type> types, Page page) { this.types = ImmutableList.copyOf(requireNonNull(types, "types is null")); this.page = requireNonNull(page, "page is null"); checkArgument(types.size() == page.getChannelCount(), "Types do not match page channels"); }
public StreamingIndexedData(List<Type> outputTypes, List<Type> indexKeyTypes, Page indexKeyTuple, PageBuffer pageBuffer, Driver driver) { this.outputTypes = ImmutableList.copyOf(requireNonNull(outputTypes, "outputTypes is null")); this.indexKeyTypes = ImmutableList.copyOf(requireNonNull(indexKeyTypes, "indexKeyTypes is null")); this.indexKeyTuple = requireNonNull(indexKeyTuple, "indexKeyTuple is null"); checkArgument(indexKeyTuple.getPositionCount() == 1, "indexKeyTuple Page should only have one position"); checkArgument(indexKeyTypes.size() == indexKeyTuple.getChannelCount(), "indexKeyTypes doesn't match indexKeyTuple columns"); this.pageBuffer = requireNonNull(pageBuffer, "pageBuffer is null"); this.driver = requireNonNull(driver, "driver is null"); }
private static int getBucketHashCode(List<TypeInfo> types, Page page, int position) { checkArgument(types.size() == page.getChannelCount()); int result = 0; for (int i = 0; i < page.getChannelCount(); i++) { int fieldHash = hash(types.get(i), page.getBlock(i), position); result = result * 31 + fieldHash; } return result; }
public TuplePageFilter(Page tuplePage, List<Type> types, List<Integer> inputChannels) { requireNonNull(tuplePage, "tuplePage is null"); requireNonNull(types, "types is null"); requireNonNull(inputChannels, "inputChannels is null"); checkArgument(tuplePage.getPositionCount() == 1, "tuplePage should only have one position"); checkArgument(tuplePage.getChannelCount() == inputChannels.size(), "tuplePage and inputChannels have different number of channels"); checkArgument(types.size() == inputChannels.size(), "types and inputChannels have different number of channels"); this.tuplePage = tuplePage; this.types = ImmutableList.copyOf(types); this.inputChannels = new InputChannels(inputChannels); }
public Page getRegion(int positionOffset, int length) { if (positionOffset < 0 || length < 0 || positionOffset + length > positionCount) { throw new IndexOutOfBoundsException(format("Invalid position %s and length %s in page with %s positions", positionOffset, length, positionCount)); } int channelCount = getChannelCount(); Block[] slicedBlocks = new Block[channelCount]; for (int i = 0; i < channelCount; i++) { slicedBlocks[i] = blocks[i].getRegion(positionOffset, length); } return new Page(length, slicedBlocks); }
static void writeRawPage(Page page, SliceOutput output, BlockEncodingSerde serde) { output.writeInt(page.getChannelCount()); for (int channel = 0; channel < page.getChannelCount(); channel++) { writeBlock(serde, output, page.getBlock(channel)); } }
@Override public void addInput(GroupByIdBlock groupIdsBlock, Page page) { Block[] blocks = new Block[page.getChannelCount() + 1]; for (int i = 0; i < page.getChannelCount(); i++) { blocks[i] = page.getBlock(i); } // Add group id block blocks[page.getChannelCount()] = groupIdsBlock; groupCount = max(groupCount, groupIdsBlock.getGroupCount()); pagesIndex.addPage(new Page(blocks)); }
private static boolean containsNullValue(int position, Page page) { for (int channel = 0; channel < page.getChannelCount(); channel++) { Block block = page.getBlock(channel); if (block.isNull(position)) { return true; } } return false; }
public int[] partitionPage(Page partitionColumns, Block bucketBlock) { if (bucketBlock != null) { Block[] blocks = new Block[partitionColumns.getChannelCount() + 1]; for (int i = 0; i < partitionColumns.getChannelCount(); i++) { blocks[i] = partitionColumns.getBlock(i); } blocks[blocks.length - 1] = bucketBlock; partitionColumns = new Page(partitionColumns.getPositionCount(), blocks); } return pageIndexer.indexPage(partitionColumns); }
private static void assertPageEquals(Page expectedPage, Page actualPage) { assertEquals(actualPage.getPositionCount(), expectedPage.getPositionCount()); assertEquals(actualPage.getChannelCount(), expectedPage.getChannelCount()); }
public static void assertPageEquals(List<? extends Type> types, Page actualPage, Page expectedPage) { assertEquals(types.size(), actualPage.getChannelCount()); assertEquals(actualPage.getChannelCount(), expectedPage.getChannelCount()); assertEquals(actualPage.getPositionCount(), expectedPage.getPositionCount()); for (int i = 0; i < actualPage.getChannelCount(); i++) { assertBlockEquals(types.get(i), actualPage.getBlock(i), expectedPage.getBlock(i)); } } }
private static void assertPageEquals(SerializedPage actualPage, Page expectedPage) { assertNotNull(actualPage); assertEquals(actualPage.getPositionCount(), expectedPage.getPositionCount()); assertEquals(PAGES_SERDE.deserialize(actualPage).getChannelCount(), expectedPage.getChannelCount()); }
private static void assertRemovePage(LocalExchangeSource source, Page expectedPage) { assertTrue(source.waitForReading().isDone()); Page actualPage = source.removePage(); assertNotNull(actualPage); assertEquals(actualPage.getChannelCount(), expectedPage.getChannelCount()); PageAssertions.assertPageEquals(TYPES, actualPage, expectedPage); }
private static List<Page> stripRowNumberColumn(List<Page> input) { return input.stream() .map(page -> { Block[] blocks = new Block[page.getChannelCount() - 1]; for (int i = 0; i < page.getChannelCount() - 1; i++) { blocks[i] = page.getBlock(i); } return new Page(page.getPositionCount(), blocks); }) .collect(toImmutableList()); } }
@Test public void testProjectNoColumns() { PageProcessor pageProcessor = new PageProcessor(Optional.empty(), ImmutableList.of(), OptionalInt.of(MAX_BATCH_SIZE)); Page inputPage = new Page(createLongSequenceBlock(0, 100)); Iterator<Optional<Page>> output = processAndAssertRetainedPageSize(pageProcessor, inputPage); List<Optional<Page>> outputPages = ImmutableList.copyOf(output); assertEquals(outputPages.size(), 1); Page outputPage = outputPages.get(0).orElse(null); assertEquals(outputPage.getChannelCount(), 0); assertEquals(outputPage.getPositionCount(), inputPage.getPositionCount()); }
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); } }
static void assertBufferResultEquals(List<? extends Type> types, BufferResult actual, BufferResult expected) { assertEquals(actual.getSerializedPages().size(), expected.getSerializedPages().size(), "page count"); assertEquals(actual.getToken(), expected.getToken(), "token"); for (int i = 0; i < actual.getSerializedPages().size(); i++) { Page actualPage = PAGES_SERDE.deserialize(actual.getSerializedPages().get(i)); Page expectedPage = PAGES_SERDE.deserialize(expected.getSerializedPages().get(i)); assertEquals(actualPage.getChannelCount(), expectedPage.getChannelCount()); PageAssertions.assertPageEquals(types, actualPage, expectedPage); } assertEquals(actual.isBufferComplete(), expected.isBufferComplete(), "buffer complete"); }
private Object selectSingleValue(Operator operator, Type type) { Page output = getAtMostOnePage(operator, SOURCE_PAGE); assertNotNull(output); assertEquals(output.getPositionCount(), 1); assertEquals(output.getChannelCount(), 1); Block block = output.getBlock(0); assertEquals(block.getPositionCount(), 1); return type.getObjectValue(session.toConnectorSession(), block, 0); }
private static Block getRowNumberColumn(List<Page> pages) { BlockBuilder builder = BIGINT.createBlockBuilder(null, pages.size() * 100); for (Page page : pages) { int rowNumberChannel = page.getChannelCount() - 1; for (int i = 0; i < page.getPositionCount(); i++) { BIGINT.writeLong(builder, page.getBlock(rowNumberChannel).getLong(i, 0)); } } return builder.build(); }