@Override public void writeSlice(BlockBuilder blockBuilder, Slice value) { writeSlice(blockBuilder, value, 0, value.length()); }
public void writeString(BlockBuilder blockBuilder, String value) { writeSlice(blockBuilder, Slices.utf8Slice(value)); }
@Override public void serialize(EvaluateClassifierPredictionsState state, BlockBuilder out) { Map<String, Map<String, Integer>> jsonState = new HashMap<>(); jsonState.put(TRUE_POSITIVES, state.getTruePositives()); jsonState.put(FALSE_POSITIVES, state.getFalsePositives()); jsonState.put(FALSE_NEGATIVES, state.getFalseNegatives()); try { VARCHAR.writeSlice(out, Slices.utf8Slice(OBJECT_MAPPER.writeValueAsString(jsonState))); } catch (JsonProcessingException e) { throw new RuntimeException(e); } }
private static Block resourceGroupIdToBlock(ResourceGroupId resourceGroupId) { requireNonNull(resourceGroupId, "resourceGroupId is null"); List<String> segments = resourceGroupId.getSegments(); BlockBuilder blockBuilder = createUnboundedVarcharType().createBlockBuilder(null, segments.size()); for (String segment : segments) { createUnboundedVarcharType().writeSlice(blockBuilder, utf8Slice(segment)); } return blockBuilder.build(); }
public Block split(Slice source) { Matcher matcher = re2jPattern.matcher(source); BlockBuilder blockBuilder = VARCHAR.createBlockBuilder(null, 32); int lastEnd = 0; while (matcher.find()) { Slice slice = source.slice(lastEnd, matcher.start() - lastEnd); lastEnd = matcher.end(); VARCHAR.writeSlice(blockBuilder, slice); } VARCHAR.writeSlice(blockBuilder, source.slice(lastEnd, source.length() - lastEnd)); return blockBuilder.build(); }
private void writeRow(List<Object> testRow, BlockBuilder rowBlockBuilder) { BlockBuilder singleRowBlockWriter = rowBlockBuilder.beginBlockEntry(); for (Object fieldValue : testRow) { if (fieldValue instanceof String) { VARCHAR.writeSlice(singleRowBlockWriter, utf8Slice((String) fieldValue)); } else { throw new UnsupportedOperationException(); } } rowBlockBuilder.closeEntry(); }
public Block extractAll(Slice source, long groupIndex) { Matcher matcher = re2jPattern.matcher(source); int group = toIntExact(groupIndex); validateGroup(group, matcher.groupCount()); BlockBuilder blockBuilder = VARCHAR.createBlockBuilder(null, 32); while (true) { if (!matcher.find()) { break; } Slice searchedGroup = matcher.group(group); if (searchedGroup == null) { blockBuilder.appendNull(); continue; } VARCHAR.writeSlice(blockBuilder, searchedGroup); } return blockBuilder.build(); }
private void testGetElementPositionRandomFor(TypedSet set) { BlockBuilder keys = VARCHAR.createBlockBuilder(null, 5); VARCHAR.writeSlice(keys, utf8Slice("hello")); VARCHAR.writeSlice(keys, utf8Slice("bye")); VARCHAR.writeSlice(keys, utf8Slice("abc")); for (int i = 0; i < keys.getPositionCount(); i++) { set.add(keys, i); } BlockBuilder values = VARCHAR.createBlockBuilder(null, 5); VARCHAR.writeSlice(values, utf8Slice("bye")); VARCHAR.writeSlice(values, utf8Slice("abc")); VARCHAR.writeSlice(values, utf8Slice("hello")); VARCHAR.writeSlice(values, utf8Slice("bad")); values.appendNull(); assertEquals(set.positionOf(values, 4), -1); assertEquals(set.positionOf(values, 2), 0); assertEquals(set.positionOf(values, 1), 2); assertEquals(set.positionOf(values, 0), 1); assertFalse(set.contains(values, 3)); set.add(values, 4); assertTrue(set.contains(values, 4)); }
private void testIsFull(PageBuilderStatus pageBuilderStatus) { BlockBuilder blockBuilder = new VariableWidthBlockBuilder(pageBuilderStatus.createBlockBuilderStatus(), 32, 1024); assertTrue(pageBuilderStatus.isEmpty()); while (!pageBuilderStatus.isFull()) { VARCHAR.writeSlice(blockBuilder, Slices.allocate(VARCHAR_VALUE_SIZE)); } assertEquals(blockBuilder.getPositionCount(), EXPECTED_ENTRY_COUNT); assertEquals(pageBuilderStatus.isFull(), true); } }
private void createBlockBuilderWithValues(Map<String, Long> map, BlockBuilder mapBlockBuilder) { if (map == null) { mapBlockBuilder.appendNull(); } else { BlockBuilder elementBlockBuilder = mapBlockBuilder.beginBlockEntry(); for (Map.Entry<String, Long> entry : map.entrySet()) { VARCHAR.writeSlice(elementBlockBuilder, utf8Slice(entry.getKey())); if (entry.getValue() == null) { elementBlockBuilder.appendNull(); } else { BIGINT.writeLong(elementBlockBuilder, entry.getValue()); } } mapBlockBuilder.closeEntry(); } }
private static List<Page> createVarcharPages(int positionCount, int groupCount, int channelCount, boolean hashEnabled) { List<Type> types = Collections.nCopies(channelCount, VARCHAR); ImmutableList.Builder<Page> pages = ImmutableList.builder(); if (hashEnabled) { types = ImmutableList.copyOf(Iterables.concat(types, ImmutableList.of(BIGINT))); } PageBuilder pageBuilder = new PageBuilder(types); for (int position = 0; position < positionCount; position++) { int rand = ThreadLocalRandom.current().nextInt(groupCount); Slice value = Slices.wrappedBuffer(ByteBuffer.allocate(4).putInt(rand)); pageBuilder.declarePosition(); for (int channel = 0; channel < channelCount; channel++) { VARCHAR.writeSlice(pageBuilder.getBlockBuilder(channel), value); } if (hashEnabled) { BIGINT.writeLong(pageBuilder.getBlockBuilder(channelCount), VarcharOperators.hashCode(value)); } if (pageBuilder.isFull()) { pages.add(pageBuilder.build()); pageBuilder.reset(); } } pages.add(pageBuilder.build()); return pages.build(); }
public static BlockBuilder createBlockBuilderWithValues(Slice[][][] expectedValues) { BlockBuilder blockBuilder = createMapBuilder(100); for (Slice[][] expectedMap : expectedValues) { if (expectedMap == null) { blockBuilder.appendNull(); } else { BlockBuilder entryBuilder = blockBuilder.beginBlockEntry(); VARCHAR.createBlockBuilder(null, expectedMap.length); for (Slice[] entry : expectedMap) { Slice key = entry[0]; assertNotNull(key); VARCHAR.writeSlice(entryBuilder, key); Slice value = entry[1]; if (value == null) { entryBuilder.appendNull(); } else { VARCHAR.writeSlice(entryBuilder, value); } } blockBuilder.closeEntry(); } } return blockBuilder; }
private static Block createTestBlock() { RowBlockBuilder blockBuilder = (RowBlockBuilder) TYPE.createBlockBuilder(null, 3); SingleRowBlockWriter singleRowBlockWriter; singleRowBlockWriter = blockBuilder.beginBlockEntry(); BIGINT.writeLong(singleRowBlockWriter, 1); VARCHAR.writeSlice(singleRowBlockWriter, utf8Slice("cat")); blockBuilder.closeEntry(); singleRowBlockWriter = blockBuilder.beginBlockEntry(); BIGINT.writeLong(singleRowBlockWriter, 2); VARCHAR.writeSlice(singleRowBlockWriter, utf8Slice("cats")); blockBuilder.closeEntry(); singleRowBlockWriter = blockBuilder.beginBlockEntry(); BIGINT.writeLong(singleRowBlockWriter, 3); VARCHAR.writeSlice(singleRowBlockWriter, utf8Slice("dog")); blockBuilder.closeEntry(); return blockBuilder.build(); }
private static BlockBuilder createBlockBuilderWithValues(Slice[][] expectedValues) { BlockBuilder blockBuilder = new ArrayBlockBuilder(VARCHAR, null, 100, 100); for (Slice[] expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { BlockBuilder elementBlockBuilder = VARCHAR.createBlockBuilder(null, expectedValue.length); for (Slice v : expectedValue) { VARCHAR.writeSlice(elementBlockBuilder, v); } blockBuilder.appendStructure(elementBlockBuilder.build()); } } return blockBuilder; } }
private BlockBuilder createBlockBuilderWithValues(List<Type> fieldTypes, List<Object>[] rows) { BlockBuilder rowBlockBuilder = new RowBlockBuilder(fieldTypes, null, 1); for (List<Object> row : rows) { if (row == null) { rowBlockBuilder.appendNull(); } else { BlockBuilder singleRowBlockWriter = rowBlockBuilder.beginBlockEntry(); for (Object fieldValue : row) { if (fieldValue == null) { singleRowBlockWriter.appendNull(); } else { if (fieldValue instanceof Long) { BIGINT.writeLong(singleRowBlockWriter, ((Long) fieldValue).longValue()); } else if (fieldValue instanceof String) { VARCHAR.writeSlice(singleRowBlockWriter, utf8Slice((String) fieldValue)); } else { throw new IllegalArgumentException(); } } } rowBlockBuilder.closeEntry(); } } return rowBlockBuilder; }
public static BlockBuilder createBlockBuilderWithValues(Slice[][] expectedValues) { BlockBuilder blockBuilder = createBlockBuilder(null, 100, 100); for (Slice[] expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { BlockBuilder entryBuilder = blockBuilder.beginBlockEntry(); for (Slice v : expectedValue) { if (v == null) { entryBuilder.appendNull(); } else { VARCHAR.writeSlice(entryBuilder, v); } } blockBuilder.closeEntry(); } } return blockBuilder; }
@ScalarFunction @LiteralParameters("x") @Description("returns array of strings split by pattern") @SqlType("array(varchar(x))") public static Block regexpSplit(@SqlType("varchar(x)") Slice source, @SqlType(JoniRegexpType.NAME) Regex pattern) { Matcher matcher = pattern.matcher(source.getBytes()); BlockBuilder blockBuilder = VARCHAR.createBlockBuilder(null, 32); int lastEnd = 0; int nextStart = 0; while (true) { int offset = matcher.search(nextStart, source.length(), Option.DEFAULT); if (offset == -1) { break; } if (matcher.getEnd() == matcher.getBegin()) { nextStart = matcher.getEnd() + 1; } else { nextStart = matcher.getEnd(); } Slice slice = source.slice(lastEnd, matcher.getBegin() - lastEnd); lastEnd = matcher.getEnd(); VARCHAR.writeSlice(blockBuilder, slice); } VARCHAR.writeSlice(blockBuilder, source.slice(lastEnd, source.length() - lastEnd)); return blockBuilder.build(); }
public static BlockBuilder createBlockBuilderWithValues(Slice[][] expectedValues) { BlockBuilder blockBuilder = new ArrayBlockBuilder(VARCHAR, null, 100, 100); for (Slice[] expectedValue : expectedValues) { if (expectedValue == null) { blockBuilder.appendNull(); } else { BlockBuilder elementBlockBuilder = VARCHAR.createBlockBuilder(null, expectedValue.length); for (Slice v : expectedValue) { if (v == null) { elementBlockBuilder.appendNull(); } else { VARCHAR.writeSlice(elementBlockBuilder, v); } } blockBuilder.appendStructure(elementBlockBuilder.build()); } } return blockBuilder; } }
@Test public void testNewBlockBuilderLike() { ArrayType longArrayType = new ArrayType(BIGINT); ArrayType arrayType = new ArrayType(longArrayType); List<Type> channels = ImmutableList.of(BIGINT, VARCHAR, arrayType); PageBuilder pageBuilder = new PageBuilder(channels); BlockBuilder bigintBlockBuilder = pageBuilder.getBlockBuilder(0); BlockBuilder varcharBlockBuilder = pageBuilder.getBlockBuilder(1); BlockBuilder arrayBlockBuilder = pageBuilder.getBlockBuilder(2); for (int i = 0; i < 100; i++) { BIGINT.writeLong(bigintBlockBuilder, i); VARCHAR.writeSlice(varcharBlockBuilder, Slices.utf8Slice("test" + i)); Block longArrayBlock = new ArrayType(BIGINT) .createBlockBuilder(null, 1) .appendStructure(BIGINT.createBlockBuilder(null, 2).writeLong(i).closeEntry().writeLong(i * 2).closeEntry().build()); arrayBlockBuilder.appendStructure(longArrayBlock); pageBuilder.declarePosition(); } PageBuilder newPageBuilder = pageBuilder.newPageBuilderLike(); for (int i = 0; i < channels.size(); i++) { assertEquals(newPageBuilder.getType(i), pageBuilder.getType(i)); // we should get new block builder instances assertNotEquals(pageBuilder.getBlockBuilder(i), newPageBuilder.getBlockBuilder(i)); assertEquals(newPageBuilder.getBlockBuilder(i).getPositionCount(), 0); assertTrue(newPageBuilder.getBlockBuilder(i).getRetainedSizeInBytes() < pageBuilder.getBlockBuilder(i).getRetainedSizeInBytes()); } }
@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); } }