private static boolean isTypeWithLiteralParameters(TypeSignature typeSignature) { return typeSignature.getParameters().stream() .map(TypeSignatureParameter::getKind) .allMatch(kind -> kind == ParameterKind.LONG || kind == ParameterKind.VARIABLE); }
public ClientTypeSignature(TypeSignature typeSignature) { this( typeSignature.getBase(), Lists.transform(typeSignature.getParameters(), ClientTypeSignatureParameter::new)); }
private boolean isImplicitRowType(Type type) { return type.getTypeSignature().getParameters() .stream() .map(TypeSignatureParameter::getNamedTypeSignature) .map(NamedTypeSignature::getName) .filter(Optional::isPresent) .map(Optional::get) .allMatch(name -> name.startsWith(implicitPrefix)); }
static void checkTypeParameters(TypeSignature typeSignature, Set<String> typeParameterNames, AnnotatedElement element) { // Check recursively if `typeSignature` contains something like `T<bigint>` if (typeParameterNames.contains(typeSignature.getBase())) { checkArgument(typeSignature.getParameters().isEmpty(), "Expected type parameter not to take parameters, but got %s on method [%s]", typeSignature.getBase(), element); return; } for (TypeSignatureParameter parameter : typeSignature.getParameters()) { Optional<TypeSignature> childTypeSignature = parameter.getTypeSignatureOrNamedTypeSignature(); if (childTypeSignature.isPresent()) { checkTypeParameters(childTypeSignature.get(), typeParameterNames, element); } } }
public static TypeSignature applyBoundVariables(TypeSignature typeSignature, BoundVariables boundVariables) { String baseType = typeSignature.getBase(); if (boundVariables.containsTypeVariable(baseType)) { checkState(typeSignature.getParameters().isEmpty(), "Type parameters cannot have parameters"); return boundVariables.getTypeVariable(baseType).getTypeSignature(); } List<TypeSignatureParameter> parameters = typeSignature.getParameters().stream() .map(typeSignatureParameter -> applyBoundVariables(typeSignatureParameter, boundVariables)) .collect(toList()); return new TypeSignature(baseType, parameters); }
private Type instantiateParametricType(TypeSignature signature) { List<TypeParameter> parameters = new ArrayList<>(); for (TypeSignatureParameter parameter : signature.getParameters()) { TypeParameter typeParameter = TypeParameter.of(parameter, this); parameters.add(typeParameter); } ParametricType parametricType = parametricTypes.get(signature.getBase().toLowerCase(Locale.ENGLISH)); if (parametricType == null) { throw new IllegalArgumentException("Unknown type " + signature); } Type instantiatedType = parametricType.createType(this, parameters); // TODO: reimplement this check? Currently "varchar(Integer.MAX_VALUE)" fails with "varchar" //checkState(instantiatedType.equalsSignature(signature), "Instantiated parametric type name (%s) does not match expected name (%s)", instantiatedType, signature); return instantiatedType; }
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); } }
@Test public void parseSignatureWithLiterals() { TypeSignature result = parseTypeSignature("decimal(X,42)", ImmutableSet.of("X")); assertEquals(result.getParameters().size(), 2); assertEquals(result.getParameters().get(0).isVariable(), true); assertEquals(result.getParameters().get(1).isLongLiteral(), true); }
private static void assertSignature( String typeName, String base, List<String> parameters, String expectedTypeName) { TypeSignature signature = parseTypeSignature(typeName); assertEquals(signature.getBase(), base); assertEquals(signature.getParameters().size(), parameters.size()); for (int i = 0; i < signature.getParameters().size(); i++) { assertEquals(signature.getParameters().get(i).toString(), parameters.get(i)); } assertEquals(signature.toString(), expectedTypeName); }
private static Set<String> longVariablesOf(TypeSignature typeSignature) { Set<String> variables = new HashSet<>(); for (TypeSignatureParameter parameter : typeSignature.getParameters()) { switch (parameter.getKind()) { case TYPE: variables.addAll(longVariablesOf(parameter.getTypeSignature())); break; case NAMED_TYPE: variables.addAll(longVariablesOf(parameter.getNamedTypeSignature().getTypeSignature())); break; case LONG: break; case VARIABLE: variables.add(parameter.getVariable()); break; default: throw new UnsupportedOperationException(); } } return variables; }
private Set<String> typeVariablesOf(TypeSignature typeSignature) { if (typeVariableConstraints.containsKey(typeSignature.getBase())) { return ImmutableSet.of(typeSignature.getBase()); } Set<String> variables = new HashSet<>(); for (TypeSignatureParameter parameter : typeSignature.getParameters()) { switch (parameter.getKind()) { case TYPE: variables.addAll(typeVariablesOf(parameter.getTypeSignature())); break; case NAMED_TYPE: variables.addAll(typeVariablesOf(parameter.getNamedTypeSignature().getTypeSignature())); break; case LONG: break; case VARIABLE: break; default: throw new UnsupportedOperationException(); } } return variables; }
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); }
type.getTypeSignature().getParameters().stream() .map(parameter -> parameter.getNamedTypeSignature().getName().get()) .collect(toList()),
@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"); }
List<TypeSignatureParameter> parameters = formalTypeSignature.getParameters(); for (int i = 0; i < parameters.size(); i++) { TypeSignatureParameter typeSignatureParameter = parameters.get(i); originalTypeTypeParametersBuilder.add(TypeSignatureParameter.of(typeSignature.getParameters().get(i).getLongLiteral())); 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();
private ColumnChunk readStruct(GroupField field) throws IOException { List<TypeSignatureParameter> fields = field.getType().getTypeSignature().getParameters(); Block[] blocks = new Block[fields.size()]; ColumnChunk columnChunk = null; List<Optional<Field>> parameters = field.getChildren(); for (int i = 0; i < fields.size(); i++) { Optional<Field> parameter = parameters.get(i); if (parameter.isPresent()) { columnChunk = readColumnChunk(parameter.get()); blocks[i] = columnChunk.getBlock(); } } for (int i = 0; i < fields.size(); i++) { if (blocks[i] == null) { blocks[i] = RunLengthEncodedBlock.create(field.getType(), null, columnChunk.getBlock().getPositionCount()); } } BooleanList structIsNull = StructColumnReader.calculateStructOffsets(field, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); boolean[] structIsNullVector = structIsNull.toBooleanArray(); Block rowBlock = RowBlock.fromFieldBlocks(structIsNullVector.length, Optional.of(structIsNullVector), blocks); return new ColumnChunk(rowBlock, columnChunk.getDefinitionLevels(), columnChunk.getRepetitionLevels()); }
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++) {
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));
type.getTypeSignature().getParameters().stream() .map(parameter -> parameter.getNamedTypeSignature().getName().get()) .collect(toList()),
@Test public void testTypeSignatureRoundTrip() { TypeManager typeManager = new TypeRegistry(); TypeSignature typeSignature = new TypeSignature( ROW, TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName("col1", false)), new TypeSignature(BIGINT))), TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName("col2", true)), new TypeSignature(DOUBLE)))); List<TypeParameter> parameters = typeSignature.getParameters().stream() .map(parameter -> TypeParameter.of(parameter, typeManager)) .collect(Collectors.toList()); Type rowType = RowParametricType.ROW.createType(typeManager, parameters); assertEquals(rowType.getTypeSignature(), typeSignature); } }