private static NamedTypeSignature unnamedParameter(TypeSignature value) { return new NamedTypeSignature(Optional.empty(), value); }
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 static TypeSignature makeSignature(List<Field> fields) { int size = fields.size(); if (size == 0) { throw new IllegalArgumentException("Row type must have at least 1 field"); } List<TypeSignatureParameter> parameters = fields.stream() .map(field -> TypeSignatureParameter.of(new NamedTypeSignature(field.getName().map(name -> new RowFieldName(name, false)), field.getType().getTypeSignature()))) .collect(Collectors.toList()); return new TypeSignature(ROW, parameters); }
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))))));
@Override public Type createType(TypeManager typeManager, 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<TypeSignatureParameter> typeSignatureParameters = parameters.stream() .map(TypeParameter::getNamedType) .map(parameter -> TypeSignatureParameter.of(new NamedTypeSignature(parameter.getName(), parameter.getType().getTypeSignature()))) .collect(toList()); List<RowType.Field> fields = parameters.stream() .map(TypeParameter::getNamedType) .map(parameter -> new RowType.Field(parameter.getName().map(RowFieldName::getName), parameter.getType())) .collect(toList()); return RowType.createWithTypeSignature(new TypeSignature(StandardTypes.ROW, typeSignatureParameters), fields); } }
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())));
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()); } }
private static NamedTypeSignature namedParameter(String name, boolean delimited, TypeSignature value) { return new NamedTypeSignature(Optional.of(new RowFieldName(name, delimited)), value); }
verify(tokenStart >= 0, "Expect tokenStart to be non-negative"); verify(delimitedColumnName != null, "Expect delimitedColumnName to be non-null"); fields.add(TypeSignatureParameter.of(new NamedTypeSignature( Optional.of(new RowFieldName(delimitedColumnName, true)), parseTypeSignature(signature.substring(tokenStart, i).trim(), literalParameters)))); verify(tokenStart >= 0, "Expect tokenStart to be non-negative"); verify(delimitedColumnName != null, "Expect delimitedColumnName to be non-null"); fields.add(TypeSignatureParameter.of(new NamedTypeSignature( Optional.of(new RowFieldName(delimitedColumnName, true)), parseTypeSignature(signature.substring(tokenStart, i).trim(), 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()); }
private static RowType toRowType(List<ColumnMetadata> columns) { return rowType(columns.stream() .map(col -> new NamedTypeSignature(Optional.of(new RowFieldName(format("f_%s", col.getName()), false)), col.getType().getTypeSignature())) .collect(toList())); }
private static Type rowType(Type... fieldTypes) { ImmutableList.Builder<TypeSignatureParameter> typeSignatureParameters = ImmutableList.builder(); for (int i = 0; i < fieldTypes.length; i++) { String filedName = "field_" + i; Type fieldType = fieldTypes[i]; typeSignatureParameters.add(TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName(filedName, false)), fieldType.getTypeSignature()))); } return TYPE_MANAGER.getParameterizedType(StandardTypes.ROW, typeSignatureParameters.build()); } }
typeSignatureBuilder.add(TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName(rowFieldName, false)), typeSignature)));
@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); } }
@Test public void testJsonRoundTrip() { TypeSignature bigint = BIGINT.getTypeSignature(); assertJsonRoundTrip(new ClientTypeSignature(bigint)); assertJsonRoundTrip(new ClientTypeSignature( "array", ImmutableList.of(new ClientTypeSignatureParameter(TypeSignatureParameter.of(bigint))))); assertJsonRoundTrip(new ClientTypeSignature( "foo", ImmutableList.of(new ClientTypeSignatureParameter(TypeSignatureParameter.of(42))))); assertJsonRoundTrip(new ClientTypeSignature( "row", ImmutableList.of( new ClientTypeSignatureParameter(TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName("foo", false)), bigint))), new ClientTypeSignatureParameter(TypeSignatureParameter.of(new NamedTypeSignature(Optional.of(new RowFieldName("bar", false)), bigint)))))); }
private static TypeSignatureParameter applyBoundVariables(TypeSignatureParameter parameter, BoundVariables boundVariables) { ParameterKind parameterKind = parameter.getKind(); switch (parameterKind) { case TYPE: { TypeSignature typeSignature = parameter.getTypeSignature(); return TypeSignatureParameter.of(applyBoundVariables(typeSignature, boundVariables)); } case NAMED_TYPE: { NamedTypeSignature namedTypeSignature = parameter.getNamedTypeSignature(); TypeSignature typeSignature = namedTypeSignature.getTypeSignature(); return TypeSignatureParameter.of(new NamedTypeSignature( namedTypeSignature.getFieldName(), applyBoundVariables(typeSignature, boundVariables))); } case VARIABLE: { String variableName = parameter.getVariable(); checkState(boundVariables.containsLongVariable(variableName), "Variable is not bound: %s", variableName); Long variableValue = boundVariables.getLongVariable(variableName); return TypeSignatureParameter.of(variableValue); } case LONG: { return parameter; } default: throw new IllegalStateException("Unknown parameter kind: " + parameter.getKind()); } }
private static TypeSignature makeSignature(List<Field> fields) { int size = fields.size(); if (size == 0) { throw new IllegalArgumentException("Row type must have at least 1 field"); } List<TypeSignatureParameter> parameters = fields.stream() .map(field -> TypeSignatureParameter.of(new NamedTypeSignature(field.getName().map(name -> new RowFieldName(name, false)), field.getType().getTypeSignature()))) .collect(Collectors.toList()); return new TypeSignature(ROW, parameters); }
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()); } }
private static RowType toRowType(List<ColumnMetadata> columns) { return rowType(columns.stream() .map(col -> new NamedTypeSignature(Optional.of(new RowFieldName(format("f_%s", col.getName()), false)), col.getType().getTypeSignature())) .collect(toList())); }
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()); }