Refine search
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); }
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()
if (signature.getBase().equals(ARRAY)) { List<Object> fixedValue = new ArrayList<>(); for (Object object : List.class.cast(value)) { fixedValue.add(fixValue(signature.getTypeParametersAsTypeSignatures().get(0), object)); if (signature.getBase().equals(MAP)) { TypeSignature keySignature = signature.getTypeParametersAsTypeSignatures().get(0); TypeSignature valueSignature = signature.getTypeParametersAsTypeSignatures().get(1); TypeSignatureParameter parameter = signature.getParameters().get(i); checkArgument( parameter.getKind() == ParameterKind.NAMED_TYPE, "Unexpected parameter [%s] for row type", parameter); NamedTypeSignature namedTypeSignature = parameter.getNamedTypeSignature(); String key = namedTypeSignature.getName().orElse("field" + i); fixedValue.put(key, fixValue(namedTypeSignature.getTypeSignature(), listValue.get(i)));
@Deprecated private String rowToString() { String fields = arguments.stream() .map(ClientTypeSignatureParameter::getNamedTypeSignature) .map(parameter -> { if (parameter.getName().isPresent()) { return format("%s %s", parameter.getName().get(), parameter.getTypeSignature().toString()); } return parameter.getTypeSignature().toString(); }) .collect(Collectors.joining(",")); return format("row(%s)", fields); }
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()); } }
public static TypeParameter of(TypeSignatureParameter parameter, TypeManager typeManager) { switch (parameter.getKind()) { case TYPE: { Type type = typeManager.getType(parameter.getTypeSignature()); return of(type); } case LONG: return of(parameter.getLongLiteral()); case NAMED_TYPE: { Type type = typeManager.getType(parameter.getNamedTypeSignature().getTypeSignature()); return of(new NamedType( parameter.getNamedTypeSignature().getFieldName(), type)); } case VARIABLE: return of(parameter.getVariable()); default: throw new UnsupportedOperationException(format("Unsupported parameter [%s]", parameter)); } }
return type.getBoolean(block, position); return type.getLong(block, position); return (int) type.getLong(block, position); for (int i = 0; i < rowBlock.getPositionCount(); i++) { rowValue.put( type.getTypeSignature().getParameters().get(i).getNamedTypeSignature().getName().orElse("field" + i), getObjectValue(fieldTypes.get(i), rowBlock, i));
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); }
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"); }
return null; TypeSignature signature = parseTypeSignature(type); if (signature.getBase().equals(ARRAY)) { List<Object> fixedValue = new ArrayList<>(); for (Object object : List.class.cast(value)) { fixedValue.add(fixValue(signature.getTypeParametersAsTypeSignatures().get(0).toString(), object)); TypeSignatureParameter parameter = signature.getParameters().get(i); checkArgument( parameter.getKind() == ParameterKind.NAMED_TYPE, "Unexpected parameter [%s] for row type", parameter); NamedTypeSignature namedTypeSignature = parameter.getNamedTypeSignature(); String key = namedTypeSignature.getName(); fixedValue.put(key, fixValue(namedTypeSignature.getTypeSignature().toString(), listValue.get(i)));
private static TypeSignature parseRowTypeSignature(String signature, Set<String> literalParameters) checkArgument(signature.toLowerCase(Locale.ENGLISH).startsWith(StandardTypes.ROW + "("), "Not a row type signature: '%s'", signature); tokenStart = i; else if (isValidStartOfIdentifier(c)) { state = RowTypeSignatureParsingState.TYPE_OR_NAMED_TYPE; tokenStart = i; checkArgument(c == ' ', "Bad type signature: '%s'", signature); 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))));
List<TypeSignatureParameter> parameters = parameter.getParameters(); for (int i = 0; i < parameters.size(); i++) { TypeSignatureParameter actualTypeParameter = type.getTypeSignature().getParameters().get(i); TypeSignatureParameter typeSignatureParameter = type.getTypeSignature().getParameters().get(i); TypeSignatureParameter componentParameter = parameters.get(i); if (componentParameter.isLiteralCalculation()) { if (!typeSignatureParameter.isLongLiteral()) { return false; else if (componentParameter.isLongLiteral()) { if (!typeSignatureParameter.isLongLiteral()) { return false; else if (componentParameter.isNamedTypeSignature() && actualTypeParameter.isNamedTypeSignature()) { componentSignature = componentParameter.getNamedTypeSignature().getTypeSignature(); Type componentType = type.getTypeParameters().get(i); if (!matchAndBind(boundParameters, typeParameters, componentSignature, componentType, allowCoercion, typeManager)) { return false;
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 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))); }
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))))));
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 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; }
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 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); } }