@Override public boolean canTransform(Type type) { return type.isPrimitiveType(); }
public static Set<Integer> getProjectedIds(Type schema) { if (schema.isPrimitiveType()) { return ImmutableSet.of(); } return ImmutableSet.copyOf(visit(schema, new GetProjectedIds())); }
@Override public List<String> primitive(Type.PrimitiveType readPrimitive) { if (currentType.equals(readPrimitive)) { return NO_ERRORS; } if (!currentType.isPrimitiveType()) { return ImmutableList.of(String.format(": %s cannot be read as a %s", currentType.typeId().toString().toLowerCase(Locale.ENGLISH), readPrimitive)); } if (!isPromotionAllowed(currentType.asPrimitiveType(), readPrimitive)) { return ImmutableList.of(String.format(": %s cannot be promoted to %s", currentType, readPrimitive)); } // both are primitives and promotion is allowed to the read type return NO_ERRORS; } }
PartitionData(Types.StructType partitionType) { for (Types.NestedField field : partitionType.fields()) { Preconditions.checkArgument(field.type().isPrimitiveType(), "Partitions cannot contain nested types: " + field.type()); } this.partitionType = partitionType; this.size = partitionType.fields().size(); this.data = new Object[size]; this.schema = getSchema(partitionType); this.stringSchema = schema.toString(); }
private static ResourceFieldSchema convert(Type type) throws IOException { ResourceFieldSchema result = new ResourceFieldSchema(); result.setType(convertType(type)); if (!type.isPrimitiveType()) { result.setSchema(convertComplex(type)); } return result; }
public static void checkCompatibility(PartitionSpec spec, Schema schema) { for (PartitionField field : spec.fields) { Type sourceType = schema.findType(field.sourceId()); ValidationException.check(sourceType.isPrimitiveType(), "Cannot partition by non-primitive source field: %s", sourceType); ValidationException.check( field.transform().canTransform(sourceType), "Invalid source type %s for transform: %s", sourceType, field.transform()); } } }
static void toJson(Type type, JsonGenerator generator) throws IOException { if (type.isPrimitiveType()) { toJson(type.asPrimitiveType(), generator); } else { Type.NestedType nested = type.asNestedType(); switch (type.typeId()) { case STRUCT: toJson(nested.asStructType(), generator); break; case LIST: toJson(nested.asListType(), generator); break; case MAP: toJson(nested.asMapType(), generator); break; default: throw new IllegalArgumentException("Cannot write unknown type: " + type); } } }
public Type field(NestedField field) { Type.Repetition repetition = field.isOptional() ? Type.Repetition.OPTIONAL : Type.Repetition.REQUIRED; int id = field.fieldId(); String name = field.name(); if (field.type().isPrimitiveType()) { return primitive(field.type().asPrimitiveType(), repetition, id, name); } else { NestedType nested = field.type().asNestedType(); if (nested.isStructType()) { return struct(nested.asStructType(), repetition, id, name); } else if (nested.isMapType()) { return map(nested.asMapType(), repetition, id, name); } else if (nested.isListType()) { return list(nested.asListType(), repetition, id, name); } throw new UnsupportedOperationException("Can't convert unknown type: " + nested); } }