public static MapType mapType(Type keyType, Type valueType) { return (MapType) TYPE_MANAGER.getParameterizedType(StandardTypes.MAP, ImmutableList.of( TypeSignatureParameter.of(keyType.getTypeSignature()), TypeSignatureParameter.of(valueType.getTypeSignature()))); } }
private static Block serializeStruct(Type type, BlockBuilder builder, Object object) { if (object == null) { requireNonNull(builder, "builder is null"); builder.appendNull(); return builder.build(); } if (builder == null) { builder = type.createBlockBuilder(null, 1); } BlockBuilder currentBuilder = builder.beginBlockEntry(); List<Type> typeParameters = type.getTypeParameters(); for (int i = 0; i < typeParameters.size(); i++) { Optional<String> fieldName = type.getTypeSignature().getParameters().get(i).getNamedTypeSignature().getName(); String name = ""; if (fieldName.isPresent()) { name = fieldName.get().toLowerCase(ENGLISH); } Object value = ((Map) object).get(name); serializeObject(typeParameters.get(i), currentBuilder, value); } builder.closeEntry(); return (Block) type.getObject(builder, 0); }
ImmutableList.Builder<TypeSignatureParameter> originalTypeTypeParametersBuilder = ImmutableList.builder(); List<TypeSignatureParameter> parameters = formalTypeSignature.getParameters(); for (int i = 0; i < parameters.size(); i++) { TypeSignatureParameter typeSignatureParameter = parameters.get(i); if (typeSignatureParameter.getKind() == ParameterKind.VARIABLE) { if (bindings.containsLongVariable(typeSignatureParameter.getVariable())) { originalTypeTypeParametersBuilder.add(TypeSignatureParameter.of(bindings.getLongVariable(typeSignatureParameter.getVariable()))); TypeSignature typeSignature = type.get().getTypeSignature(); originalTypeTypeParametersBuilder.add(TypeSignatureParameter.of(typeSignature.getParameters().get(i).getLongLiteral())); verify(typeSignatureParameter.getKind() == ParameterKind.LONG); originalTypeTypeParametersBuilder.add(typeSignatureParameter); TypeSignature commonSuperTypeSignature = commonSuperType.get().getTypeSignature(); for (int i = 0; i < parameters.size(); i++) { TypeSignatureParameter typeSignatureParameter = parameters.get(i); long commonSuperLongLiteral = commonSuperTypeSignature.getParameters().get(i).getLongLiteral(); if (typeSignatureParameter.getKind() == ParameterKind.VARIABLE) { String variableName = typeSignatureParameter.getVariable(); if (!bindings.containsLongVariable(variableName) || !bindings.getLongVariable(variableName).equals(commonSuperLongLiteral)) { bindings.setLongVariable(variableName, commonSuperLongLiteral); verify(typeSignatureParameter.getKind() == ParameterKind.LONG); if (commonSuperLongLiteral != typeSignatureParameter.getLongLiteral()) { return SolverReturnStatus.UNSOLVABLE;
public List<TypeSignature> getTypeParametersAsTypeSignatures() { List<TypeSignature> result = new ArrayList<>(); for (TypeSignatureParameter parameter : parameters) { if (parameter.getKind() != ParameterKind.TYPE) { throw new IllegalStateException( format("Expected all parameters to be TypeSignatures but [%s] was found", parameter.toString())); } result.add(parameter.getTypeSignature()); } return result; }
public Optional<TypeSignature> getTypeSignatureOrNamedTypeSignature() { switch (kind) { case TYPE: return Optional.of(getTypeSignature()); case NAMED_TYPE: return Optional.of(getNamedTypeSignature().getTypeSignature()); default: return Optional.empty(); } }
public boolean isCalculated() { switch (kind) { case TYPE: return getTypeSignature().isCalculated(); case NAMED_TYPE: return getNamedTypeSignature().getTypeSignature().isCalculated(); case LONG: return false; case VARIABLE: return true; default: throw new IllegalArgumentException("Unexpected parameter kind: " + kind); } }
private Optional<TypeSignature> guessFieldType(Object value) return Optional.empty(); .collect(toList()); if (subTypes.isEmpty() || subTypes.stream().anyMatch(t -> !t.isPresent())) { return Optional.empty(); typeSignature = new TypeSignature(StandardTypes.ARRAY, signatures.stream() .map(TypeSignatureParameter::of) .collect(Collectors.toList())); typeSignature = new TypeSignature(StandardTypes.ROW, IntStream.range(0, subTypes.size()) .mapToObj(idx -> TypeSignatureParameter.of( new NamedTypeSignature(Optional.of(new RowFieldName(String.format("%s%d", implicitPrefix, idx + 1), false)), subTypes.get(idx).get()))) .collect(toList())); parameters.add(TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName(key, false)), fieldType.get()))); typeSignature = new TypeSignature(StandardTypes.ROW, parameters);
public static Optional<Field> constructField(Type type, ColumnIO columnIO) return Optional.empty(); if (ROW.equals(type.getTypeSignature().getBase())) { GroupColumnIO groupColumnIO = (GroupColumnIO) columnIO; List<Type> parameters = type.getTypeParameters(); ImmutableList.Builder<Optional<Field>> fieldsBuilder = ImmutableList.builder(); List<TypeSignatureParameter> fields = type.getTypeSignature().getParameters(); boolean structHasParameters = false; for (int i = 0; i < fields.size(); i++) { NamedTypeSignature namedTypeSignature = fields.get(i).getNamedTypeSignature(); String name = namedTypeSignature.getName().get().toLowerCase(Locale.ENGLISH); Optional<Field> field = constructField(parameters.get(i), lookupColumnByName(groupColumnIO, name)); structHasParameters |= field.isPresent(); fieldsBuilder.add(field); return Optional.empty(); else if (MAP.equals(type.getTypeSignature().getBase())) { GroupColumnIO groupColumnIO = (GroupColumnIO) columnIO; MapType mapType = (MapType) type; return Optional.of(new GroupField(type, repetitionLevel, definitionLevel, required, ImmutableList.of(keyField, valueField))); else if (ARRAY.equals(type.getTypeSignature().getBase())) { return Optional.of(new GroupField(type, repetitionLevel, definitionLevel, required, ImmutableList.of(field)));
if (UnknownType.NAME.equals(firstType.getBase())) { return Optional.of(secondType); if (UnknownType.NAME.equals(secondType.getBase())) { return Optional.of(firstType); else if (secondType.getBase().equals(StandardTypes.VARCHAR) && firstType.getBase().equals(varcharSubType)) { secondType); if (firstParameter.isLongLiteral() && secondParameter.isLongLiteral()) { typeParameters.add(TypeSignatureParameter.of(Math.max( firstParameter.getLongLiteral(), secondParameter.getLongLiteral()))); else if (isCovariantParameterPosition(commonSuperTypeBase.get(), i)) { Optional<TypeSignature> firstParameterSignature = firstParameter.getTypeSignatureOrNamedTypeSignature(); Optional<TypeSignature> secondParameterSignature = secondParameter.getTypeSignatureOrNamedTypeSignature(); if (!firstParameterSignature.isPresent() || !secondParameterSignature.isPresent()) { return Optional.empty(); return Optional.empty(); typeParameters.add(TypeSignatureParameter.of(commonSuperType.get())); if (!firstParameter.equals(secondParameter)) { return Optional.empty();
requireNonNull(typeArguments, "typeArguments is null"); requireNonNull(literalArguments, "literalArguments is null"); ImmutableList.Builder<ClientTypeSignatureParameter> convertedArguments = ImmutableList.builder(); Object value = literalArguments.get(i); checkArgument(value instanceof String, "Expected literalArgument %d in %s to be a string", i, literalArguments); convertedArguments.add(new ClientTypeSignatureParameter(TypeSignatureParameter.of(new NamedTypeSignature( Optional.of(new RowFieldName((String) value, false)), toTypeSignature(typeArguments.get(i))))));
TypeInfo elementType = translate(type.getTypeParameters().get(0)); return getListTypeInfo(elementType); TypeInfo keyType = translate(type.getTypeParameters().get(0)); TypeInfo valueType = translate(type.getTypeParameters().get(1)); return getMapTypeInfo(keyType, valueType); ImmutableList.Builder<String> fieldNames = ImmutableList.builder(); for (TypeSignatureParameter parameter : type.getTypeSignature().getParameters()) { if (!parameter.isNamedTypeSignature()) { throw new IllegalArgumentException(format("Expected all parameters to be named type, but got %s", parameter)); NamedTypeSignature namedTypeSignature = parameter.getNamedTypeSignature(); if (!namedTypeSignature.getName().isPresent()) { throw new PrestoException(NOT_SUPPORTED, format("Anonymous row type is not supported in Hive. Please give each field a name: %s", type)); fieldNames.add(namedTypeSignature.getName().get());
private static TypeSignatureParameter parseTypeOrNamedType(String typeOrNamedType, Set<String> literalParameters) { int split = typeOrNamedType.indexOf(' '); // Type without space or simple type with spaces if (split == -1 || SIMPLE_TYPE_WITH_SPACES.contains(typeOrNamedType)) { return TypeSignatureParameter.of(new NamedTypeSignature(Optional.empty(), parseTypeSignature(typeOrNamedType, literalParameters))); } // Assume the first part of a structured type always has non-alphabetical character. // If the first part is a valid identifier, parameter is a named field. String firstPart = typeOrNamedType.substring(0, split); if (IDENTIFIER_PATTERN.matcher(firstPart).matches()) { return TypeSignatureParameter.of(new NamedTypeSignature( Optional.of(new RowFieldName(firstPart, false)), parseTypeSignature(typeOrNamedType.substring(split + 1).trim(), literalParameters))); } // Structured type composed from types with spaces. i.e. array(timestamp with time zone) return TypeSignatureParameter.of(new NamedTypeSignature(Optional.empty(), parseTypeSignature(typeOrNamedType, literalParameters))); }
private Type getType(List<String> fieldNames) { ImmutableList.Builder<TypeSignatureParameter> typeSignatureParameters = ImmutableList.builder(); for (String fieldName : fieldNames) { typeSignatureParameters.add(TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName(fieldName, false)), TEST_DATA_TYPE.getTypeSignature()))); } return TYPE_MANAGER.getParameterizedType(StandardTypes.ROW, typeSignatureParameters.build()); }
@Test public void testLearn() { Type mapType = typeManager.getParameterizedType("map", ImmutableList.of(TypeSignatureParameter.of(parseTypeSignature(StandardTypes.BIGINT)), TypeSignatureParameter.of(parseTypeSignature(StandardTypes.DOUBLE)))); InternalAggregationFunction aggregation = generateInternalAggregationFunction(LearnClassifierAggregation.class, ClassifierType.BIGINT_CLASSIFIER.getTypeSignature(), ImmutableList.of(BIGINT.getTypeSignature(), mapType.getTypeSignature()), typeManager); assertLearnClassifer(aggregation.bind(ImmutableList.of(0, 1), Optional.empty()).createAccumulator()); }
break; return primitiveType.getTypeSignature(); case MAP: MapTypeInfo mapTypeInfo = (MapTypeInfo) typeInfo; TypeSignature keyType = getTypeSignature(mapTypeInfo.getMapKeyTypeInfo()); TypeSignature valueType = getTypeSignature(mapTypeInfo.getMapValueTypeInfo()); return new TypeSignature( StandardTypes.MAP, ImmutableList.of(TypeSignatureParameter.of(keyType), TypeSignatureParameter.of(valueType))); case LIST: ListTypeInfo listTypeInfo = (ListTypeInfo) typeInfo; TypeSignature elementType = getTypeSignature(listTypeInfo.getListElementTypeInfo()); return new TypeSignature( StandardTypes.ARRAY, ImmutableList.of(TypeSignatureParameter.of(elementType))); case STRUCT: StructTypeInfo structTypeInfo = (StructTypeInfo) typeInfo; throw new PrestoException(HiveErrorCode.HIVE_INVALID_METADATA, format("Invalid Hive struct type: %s", typeInfo)); ImmutableList.Builder<TypeSignatureParameter> typeSignatureBuilder = ImmutableList.builder(); for (int i = 0; i < structFieldTypeInfos.size(); i++) { TypeSignature typeSignature = getTypeSignature(structFieldTypeInfos.get(i)); typeSignatureBuilder.add(TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName(rowFieldName, false)), typeSignature))); return new TypeSignature(StandardTypes.ROW, typeSignatureBuilder.build());
return ObjectInspectorFactory.getStandardListObjectInspector(getJavaObjectInspector(type.getTypeParameters().get(0))); ObjectInspector keyObjectInspector = getJavaObjectInspector(type.getTypeParameters().get(0)); ObjectInspector valueObjectInspector = getJavaObjectInspector(type.getTypeParameters().get(1)); return ObjectInspectorFactory.getStandardMapObjectInspector(keyObjectInspector, valueObjectInspector); type.getTypeSignature().getParameters().stream() .map(parameter -> parameter.getNamedTypeSignature().getName().get()) .collect(toList()), type.getTypeParameters().stream()
private static List<OrcType> toOrcType(int nextFieldTypeIndex, Type type) return ImmutableList.of(new OrcType(OrcTypeKind.BOOLEAN)); return ImmutableList.of(new OrcType(OrcTypeKind.BYTE)); return ImmutableList.of(new OrcType(OrcTypeKind.SHORT)); return ImmutableList.of(new OrcType(OrcTypeKind.DECIMAL, decimalType.getPrecision(), decimalType.getScale())); if (type.getTypeSignature().getBase().equals(ARRAY)) { return createOrcArrayType(nextFieldTypeIndex, type.getTypeParameters().get(0)); if (type.getTypeSignature().getBase().equals(MAP)) { return createOrcMapType(nextFieldTypeIndex, type.getTypeParameters().get(0), type.getTypeParameters().get(1)); if (type.getTypeSignature().getBase().equals(ROW)) { List<String> fieldNames = new ArrayList<>(); for (int i = 0; i < type.getTypeSignature().getParameters().size(); i++) { TypeSignatureParameter parameter = type.getTypeSignature().getParameters().get(i); fieldNames.add(parameter.getNamedTypeSignature().getName().orElse("field" + i)); List<Type> fieldTypes = type.getTypeParameters();
private Type getTypeNullName(int numFields) { ImmutableList.Builder<TypeSignatureParameter> typeSignatureParameters = ImmutableList.builder(); for (int i = 0; i < numFields; i++) { typeSignatureParameters.add(TypeSignatureParameter.of(new NamedTypeSignature(Optional.empty(), TEST_DATA_TYPE.getTypeSignature()))); } return TYPE_MANAGER.getParameterizedType(StandardTypes.ROW, typeSignatureParameters.build()); } }
@Test public void testRowTypeLookup() { functionAssertions.getMetadata().getType(parseTypeSignature("row(a bigint)")); Type type = functionAssertions.getMetadata().getType(parseTypeSignature("row(b bigint)")); assertEquals(type.getTypeSignature().getParameters().size(), 1); assertEquals(type.getTypeSignature().getParameters().get(0).getNamedTypeSignature().getName().get(), "b"); }
private static void checkNoLiteralVariableUsageAcrossTypes(TypeSignature typeSignature, Map<String, TypeSignature> existingUsages) { List<TypeSignatureParameter> variables = typeSignature.getParameters().stream() .filter(TypeSignatureParameter::isVariable) .collect(toList()); for (TypeSignatureParameter variable : variables) { TypeSignature existing = existingUsages.get(variable.getVariable()); if (existing != null && !existing.equals(typeSignature)) { throw new UnsupportedOperationException("Literal parameters may not be shared across different types"); } existingUsages.put(variable.getVariable(), typeSignature); } for (TypeSignatureParameter parameter : typeSignature.getParameters()) { if (parameter.isLongLiteral() || parameter.isVariable()) { continue; } checkNoLiteralVariableUsageAcrossTypes(parameter.getTypeSignatureOrNamedTypeSignature().get(), existingUsages); } }