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 ClientTypeSignatureParameter(TypeSignatureParameter typeParameterSignature) { this.kind = typeParameterSignature.getKind(); switch (kind) { case TYPE: value = new ClientTypeSignature(typeParameterSignature.getTypeSignature()); break; case LONG: value = typeParameterSignature.getLongLiteral(); break; case NAMED_TYPE: value = typeParameterSignature.getNamedTypeSignature(); break; default: throw new UnsupportedOperationException(format("Unknown kind [%s]", kind)); } }
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; }
TypeSignatureParameter parameter = signature.getParameters().get(i); checkArgument( parameter.getKind() == ParameterKind.NAMED_TYPE, "Unexpected parameter [%s] for row type", parameter);
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()))); verify(typeSignatureParameter.getKind() == ParameterKind.LONG); originalTypeTypeParametersBuilder.add(typeSignatureParameter); 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)) { verify(typeSignatureParameter.getKind() == ParameterKind.LONG); if (commonSuperLongLiteral != typeSignatureParameter.getLongLiteral()) { return SolverReturnStatus.UNSOLVABLE;
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)); } }
public FieldType fromPrestoType(String name) { TypeSignature typeSignature = TypeSignature.parseTypeSignature(name); return PrestoQueryExecution.fromPrestoType(typeSignature.getBase(), typeSignature.getParameters().stream() .filter(param -> param.getKind() == TYPE) .map(param -> param.getTypeSignature().getBase()).iterator()); }
@Override public List<SchemaField> getCollection(String project, String collection) { return dao.listTableColumns(project, collection).stream() // this field should be removed since the server sets it .filter(a -> !a.getColumnName().equals(prestoConfig.getCheckpointColumn())) .map(column -> { TypeSignature typeSignature = column.getDataType().getTypeSignature(); return new SchemaField(column.getColumnName(), PrestoQueryExecution.fromPrestoType(typeSignature.getBase(), typeSignature.getParameters().stream() .filter(param -> param.getKind() == TYPE) .map(param -> param.getTypeSignature().getBase()).iterator())); }).collect(Collectors.toList()); }
public Map<String, List<SchemaField>> getTables(String project, BiPredicate<String, String> filter) { HashMap<String, List<SchemaField>> map = new HashMap<>(); for (TableColumn tableColumn : dao.listTableColumns(project, null)) { if (tableColumn.getColumnName().startsWith("$") || !filter.test(tableColumn.getTable().getTableName(), tableColumn.getColumnName())) { continue; } TypeSignature typeSignature = tableColumn.getDataType().getTypeSignature(); FieldType fieldType = PrestoQueryExecution.fromPrestoType(typeSignature.getBase(), typeSignature.getParameters().stream() .filter(param -> param.getKind() == TYPE) .map(param -> param.getTypeSignature().getBase()).iterator()); SchemaField column = new SchemaField(tableColumn.getColumnName(), fieldType); map.computeIfAbsent(tableColumn.getTable().getTableName(), key -> new ArrayList()).add(column); } return map; }
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 ClientTypeSignatureParameter(TypeSignatureParameter typeParameterSignature) { this.kind = typeParameterSignature.getKind(); switch (kind) { case TYPE: value = new ClientTypeSignature(typeParameterSignature.getTypeSignature()); break; case LONG: value = typeParameterSignature.getLongLiteral(); break; case NAMED_TYPE: value = typeParameterSignature.getNamedTypeSignature(); break; default: throw new UnsupportedOperationException(format("Unknown kind [%s]", kind)); } }
TypeSignatureParameter parameter = signature.getParameters().get(i); checkArgument( parameter.getKind() == ParameterKind.NAMED_TYPE, "Unexpected parameter [%s] for row type", parameter);
switch (parameter.getKind()) { case TYPE: parametersBuilder.add(TypeSignatureParameter.of(resolveCalculatedType(
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)); } }