public MaxOrMinByStateSerializer(Type valueType, Type keyType) { this.valueType = valueType; this.keyType = keyType; this.serializedType = new RowType(ImmutableList.of(keyType, valueType), Optional.empty()); }
public List<SqlFunction> createFunctions(Type type) { RowType rowType = checkType(type, RowType.class, "type"); ImmutableList.Builder<SqlFunction> builder = ImmutableList.builder(); List<RowField> fields = rowType.getFields(); for (int i = 0; i < fields.size(); i++) { RowField field = fields.get(i); int index = i; field.getName() .ifPresent(name -> builder.add(new RowFieldReference(rowType, field.getType(), index, field.getName().get()))); } return builder.build(); } }
@Override public BlockBuilder createBlockBuilder(BlockBuilderStatus blockBuilderStatus, int expectedEntries, int expectedBytesPerEntry) { return new ArrayBlockBuilder( new InterleavedBlockBuilder(getTypeParameters(), blockBuilderStatus, expectedEntries * getTypeParameters().size(), expectedBytesPerEntry), blockBuilderStatus, expectedEntries); }
@Test public void testRowDisplayNoColumnNames() { List<Type> types = asList(BOOLEAN, DOUBLE, new ArrayType(VARCHAR), new MapType(BOOLEAN, DOUBLE)); RowType row = new RowType(types, Optional.empty()); assertEquals( row.getDisplayName(), "row(boolean, double, array(varchar), map(boolean, double))"); } }
@Test public void testRowHistograms() throws Exception { RowType innerRowType = new RowType(ImmutableList.of(BIGINT, DOUBLE), Optional.of(ImmutableList.of("f1", "f2"))); MapType mapType = new MapType(innerRowType, BIGINT); InternalAggregationFunction aggregationFunction = metadata.getFunctionRegistry().getAggregateFunctionImplementation(new Signature(NAME, AGGREGATE, mapType.getTypeSignature().toString(), innerRowType.getTypeSignature().toString())); BlockBuilder builder = innerRowType.createBlockBuilder(new BlockBuilderStatus(), 3); innerRowType.writeObject(builder, testRowBigintBigint(1L, 1.0)); innerRowType.writeObject(builder, testRowBigintBigint(2L, 2.0)); innerRowType.writeObject(builder, testRowBigintBigint(3L, 3.0)); assertAggregation( aggregationFunction, 1.0, ImmutableMap.of(ImmutableList.of(1L, 1.0), 1L, ImmutableList.of(2L, 2.0), 1L, ImmutableList.of(3L, 3.0), 1L), builder.build()); }
if (elementType != null) { if (!(elementType instanceof RowType)) { elementType = new RowType(Lists.newArrayList(elementType), Optional.of(ImmutableList.of(NAME_ARRAY_ELEMENT))); final RowType rowType = (RowType) prestoType; final LogicalSchema schema = new LogicalSchema(); rowType.getFields().stream().forEach( rowField -> schema.addField( fromPrestoTypeToPigSchema(rowField.getName().isPresent() ? rowField.getName().get() : null,
@Test public void testStateDeserializer() throws Exception { String[] keys = {"loooooong string", "short string"}; double[] values = {3.14, 2.71}; MaxOrMinByStateSerializer serializer = new MaxOrMinByStateSerializer(DOUBLE, VARCHAR); BlockBuilder builder = new RowType(ImmutableList.of(VARCHAR, DOUBLE), Optional.empty()).createBlockBuilder(new BlockBuilderStatus(), 2); for (int i = 0; i < keys.length; i++) { serializer.serialize(makeState(keys[i], values[i]), builder); } Block serialized = builder.build(); for (int i = 0; i < keys.length; i++) { MaxOrMinByState deserialized = new MaxOrMinByStateFactory().createSingleState(); serializer.deserialize(serialized, i, deserialized); assertEquals(VARCHAR.getSlice(deserialized.getKey(), 0), Slices.utf8Slice(keys[i])); assertEquals(DOUBLE.getDouble(deserialized.getValue(), 0), values[i]); } }
public RowFieldReference(RowType type, Type returnType, int index, String fieldName) { super(mangleFieldReference(fieldName), ImmutableList.of(), returnType.getTypeSignature().toString(), ImmutableList.of(type.getTypeSignature().toString())); String stackType = returnType.getJavaType().getSimpleName().toLowerCase(); MethodHandle methodHandle; if (METHOD_HANDLE_MAP.containsKey(stackType)) { methodHandle = METHOD_HANDLE_MAP.get(stackType); } else { methodHandle = METHOD_HANDLE_OBJECT; } this.methodHandle = methodHandle.bindTo(returnType).bindTo(index); }
@Override public boolean equalTo(Block leftBlock, int leftPosition, Block rightBlock, int rightPosition) { Block leftRow = leftBlock.getObject(leftPosition, Block.class); Block rightRow = rightBlock.getObject(rightPosition, Block.class); for (int i = 0; i < leftRow.getPositionCount(); i++) { checkElementNotNull(leftRow.isNull(i)); checkElementNotNull(rightRow.isNull(i)); Type fieldType = fields.get(i).getType(); if (!fieldType.equalTo(leftRow, i, rightRow, i)) { return false; } } return true; }
@Test public void testDoubleRowMap() throws Exception { RowType innerRowType = new RowType(ImmutableList.of(BIGINT, DOUBLE), Optional.of(ImmutableList.of("f1", "f2"))); MapType mapType = new MapType(DOUBLE, innerRowType); InternalAggregationFunction aggFunc = metadata.getFunctionRegistry().getAggregateFunctionImplementation(new Signature(NAME, AGGREGATE, mapType.getTypeSignature().toString(), StandardTypes.DOUBLE, innerRowType.getTypeSignature().toString())); BlockBuilder builder = innerRowType.createBlockBuilder(new BlockBuilderStatus(), 3); innerRowType.writeObject(builder, testRowBigintBigint(1L, 1.0)); innerRowType.writeObject(builder, testRowBigintBigint(2L, 2.0)); innerRowType.writeObject(builder, testRowBigintBigint(3L, 3.0)); assertAggregation( aggFunc, 1.0, ImmutableMap.of(1.0, ImmutableList.of(1L, 1.0), 2.0, ImmutableList.of(2L, 2.0), 3.0, ImmutableList.of(3L, 3.0)), createDoublesBlock(1.0, 2.0, 3.0), builder.build()); }
@Test public void testRowDisplayName() { List<Type> types = asList(BOOLEAN, DOUBLE, new ArrayType(VARCHAR), new MapType(BOOLEAN, DOUBLE)); Optional<List<String>> names = Optional.of(asList("bool_col", "double_col", "array_col", "map_col")); RowType row = new RowType(types, names); assertEquals( row.getDisplayName(), "row(bool_col boolean, double_col double, array_col array(varchar), map_col map(boolean, double))"); }
@Override public int hash(Block block, int position) { Block arrayBlock = block.getObject(position, Block.class); int result = 1; for (int i = 0; i < arrayBlock.getPositionCount(); i++) { checkElementNotNull(arrayBlock.isNull(i)); Type elementType = fields.get(i).getType(); result = 31 * result + elementType.hash(arrayBlock, i); } return result; }
public MinMaxNStateSerializer(BlockComparator blockComparator, Type elementType) { this.blockComparator = blockComparator; this.elementType = elementType; this.arrayType = new ArrayType(elementType); this.serializedType = new RowType(ImmutableList.of(BIGINT, arrayType), Optional.empty()); }
RowType rowType = (RowType) type; while (parser.nextValue() != JsonToken.END_ARRAY) { checkArgument(field < rowType.getFields().size(), "Unexpected field for type %s", type); Object value = stackRepresentationToObjectHelper(session, parser, rowType.getFields().get(field).getType()); list.add(value); field++; checkArgument(field == rowType.getFields().size(), "Expected %s fields for type %s", rowType.getFields().size(), type);
@Override public BlockBuilder createBlockBuilder(BlockBuilderStatus blockBuilderStatus, int expectedEntries) { return new ArrayBlockBuilder( new InterleavedBlockBuilder(getTypeParameters(), blockBuilderStatus, expectedEntries * getTypeParameters().size()), blockBuilderStatus, expectedEntries); }
@Override public Type createType(List<TypeParameter> parameters) { checkArgument(!parameters.isEmpty(), "Row type must have at least one parameter"); checkArgument( parameters.stream().allMatch(parameter -> parameter.getKind() == ParameterKind.NAMED_TYPE), "Expected only named types as a parameters, got %s", parameters); List<NamedType> namedTypes = parameters.stream().map(TypeParameter::getNamedType).collect(toList()); return new RowType( namedTypes.stream().map(NamedType::getType).collect(toList()), Optional.of(namedTypes.stream().map(NamedType::getName).collect(toList()))); }
for (RowField rowField : rowType.getFields()) { if (rowField.getName().equals(Optional.of(node.getFieldName()))) { rowFieldType = rowField.getType();
List<Type> elementTypes = rowType.getTypeParameters(); Object[] elementNonNullValues = elementTypes.stream().map(AbstractTestType::getNonNullValueForType).toArray(Object[]::new); return TestingRowConstructor.toStackRepresentation(elementTypes, elementNonNullValues);
private Type toPrestoRowType(final LogicalSchema.LogicalFieldSchema field) { final List<Type> fieldTypes = Lists.newArrayList(); final List<String> fieldNames = Lists.newArrayList(); field.schema.getFields().stream().forEach(logicalFieldSchema -> { fieldTypes.add(toPrestoType(logicalFieldSchema)); fieldNames.add(logicalFieldSchema.alias); }); return new RowType(fieldTypes, Optional.of(fieldNames)); }
} else if (type.getTypeSignature().getBase().equals(StandardTypes.ROW)) { final RowType rowType = (RowType) type; final String typeString = rowType.getFields() .stream() .map(this::rowFieldToString)