private static NamedTypeSignature unnamedParameter(TypeSignature value) { return new NamedTypeSignature(Optional.empty(), value); }
public Optional<String> getName() { return getFieldName().map(RowFieldName::getName); }
public Optional<TypeSignature> getTypeSignatureOrNamedTypeSignature() { switch (kind) { case TYPE: return Optional.of(getTypeSignature()); case NAMED_TYPE: return Optional.of(getNamedTypeSignature().getTypeSignature()); default: return Optional.empty(); } }
return ObjectInspectorFactory.getStandardStructObjectInspector( type.getTypeSignature().getParameters().stream() .map(parameter -> parameter.getNamedTypeSignature().getName().get()) .collect(toList()), type.getTypeParameters().stream()
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 ClientTypeSignatureParameter toClientTypeSignatureParameter(TypeSignatureParameter parameter) { switch (parameter.getKind()) { case TYPE: return ClientTypeSignatureParameter.ofType(toClientTypeSignature(parameter.getTypeSignature())); case NAMED_TYPE: return ClientTypeSignatureParameter.ofNamedType(new NamedClientTypeSignature( parameter.getNamedTypeSignature().getFieldName().map(value -> new RowFieldName(value.getName(), value.isDelimited())), toClientTypeSignature(parameter.getNamedTypeSignature().getTypeSignature()))); case LONG: return ClientTypeSignatureParameter.ofLong(parameter.getLongLiteral()); } throw new IllegalArgumentException("Unsupported kind: " + parameter.getKind()); }
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));
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)); } }
private static NamedTypeSignature unnamedParameter(TypeSignature value) { return new NamedTypeSignature(Optional.empty(), value); }
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();
private static ClientTypeSignatureParameter toClientTypeSignatureParameter(TypeSignatureParameter parameter) { switch (parameter.getKind()) { case TYPE: return ClientTypeSignatureParameter.ofType(toClientTypeSignature(parameter.getTypeSignature())); case NAMED_TYPE: return ClientTypeSignatureParameter.ofNamedType(new NamedClientTypeSignature( parameter.getNamedTypeSignature().getFieldName().map(value -> new RowFieldName(value.getName(), value.isDelimited())), toClientTypeSignature(parameter.getNamedTypeSignature().getTypeSignature()))); case LONG: return ClientTypeSignatureParameter.ofLong(parameter.getLongLiteral()); } throw new IllegalArgumentException("Unsupported kind: " + parameter.getKind()); }
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 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))); }
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 ClientTypeSignatureParameter toClientTypeSignatureParameter(TypeSignatureParameter parameter) { switch (parameter.getKind()) { case TYPE: return ClientTypeSignatureParameter.ofType(toClientTypeSignature(parameter.getTypeSignature())); case NAMED_TYPE: return ClientTypeSignatureParameter.ofNamedType(new NamedClientTypeSignature( parameter.getNamedTypeSignature().getFieldName().map(value -> new RowFieldName(value.getName(), value.isDelimited())), toClientTypeSignature(parameter.getNamedTypeSignature().getTypeSignature()))); case LONG: return ClientTypeSignatureParameter.ofLong(parameter.getLongLiteral()); } throw new IllegalArgumentException("Unsupported kind: " + parameter.getKind()); } }
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 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); }
@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 ClientTypeSignatureParameter toClientTypeSignatureParameter(TypeSignatureParameter parameter) { switch (parameter.getKind()) { case TYPE: return ClientTypeSignatureParameter.ofType(toClientTypeSignature(parameter.getTypeSignature())); case NAMED_TYPE: return ClientTypeSignatureParameter.ofNamedType(new NamedClientTypeSignature( parameter.getNamedTypeSignature().getFieldName().map(value -> new RowFieldName(value.getName(), value.isDelimited())), toClientTypeSignature(parameter.getNamedTypeSignature().getTypeSignature()))); case LONG: return ClientTypeSignatureParameter.ofLong(parameter.getLongLiteral()); } throw new IllegalArgumentException("Unsupported kind: " + parameter.getKind()); } }