org.apache.beam.sdk.values.TypeDescriptor#resolveType

Source File: AvroCoder.java From beam with Apache License 2.0

6 votes

private void checkRecord(TypeDescriptor<?> type, Schema schema) {
  // For a record, we want to make sure that all the fields are deterministic.
  Class<?> clazz = type.getRawType();
  for (Schema.Field fieldSchema : schema.getFields()) {
    Field field = getField(clazz, fieldSchema.name());
    String fieldContext = field.getDeclaringClass().getName() + "#" + field.getName();

    if (field.isAnnotationPresent(AvroEncode.class)) {
      reportError(
          fieldContext, "Custom encoders may be non-deterministic -- remove @AvroEncode");
      continue;
    }

    if (!IndexedRecord.class.isAssignableFrom(field.getType())
        && field.isAnnotationPresent(AvroSchema.class)) {
      // TODO: We should be able to support custom schemas on POJO fields, but we shouldn't
      // need to, so we just allow it in the case of IndexedRecords.
      reportError(
          fieldContext, "Custom schemas are only supported for subtypes of IndexedRecord.");
      continue;
    }

    TypeDescriptor<?> fieldType = type.resolveType(field.getGenericType());
    recurse(fieldContext, fieldType, fieldSchema.schema());
  }
}

Source File: AvroCoder.java From beam with Apache License 2.0

6 votes

private void checkArray(String context, TypeDescriptor<?> type, Schema schema) {
  TypeDescriptor<?> elementType = null;
  if (type.isArray()) {
    // The type is an array (with ordering)-> deterministic iff the element is deterministic.
    elementType = type.getComponentType();
  } else if (isSubtypeOf(type, Collection.class)) {
    if (isSubtypeOf(type, List.class, SortedSet.class)) {
      // Ordered collection -> deterministic iff the element is deterministic
      elementType = type.resolveType(Collection.class.getTypeParameters()[0]);
    } else {
      // Not an ordered collection -> not deterministic
      reportError(context, "%s may not be deterministically ordered", type);
      return;
    }
  } else {
    // If it was an unknown type encoded as an array, be conservative and assume
    // that we don't know anything about the order.
    reportError(context, "encoding %s as an ARRAY was unexpected", type);
    return;
  }

  // If we get here, it's either a deterministically-ordered Collection, or
  // an array. Either way, the type is deterministic iff the element type is
  // deterministic.
  recurse(context, elementType, schema.getElementType());
}

Source File: TypePropagationAssert.java From beam with Apache License 2.0

5 votes

public static <KeyT, ValueT, OutputT> void assertOperatorTypeAwareness(
    Operator<OutputT> operator,
    @Nullable TypeDescriptor<KeyT> keyType,
    @Nullable TypeDescriptor<ValueT> valueType,
    TypeDescriptor<OutputT> outputType) {
  if (keyType != null || operator instanceof TypeAware.Key) {
    @SuppressWarnings("unchecked")
    final TypeAware.Key<KeyT> keyAware = (TypeAware.Key) operator;
    assertTrue(keyAware.getKeyType().isPresent());
    assertEquals(keyType, keyAware.getKeyType().get());
    assertTrue(operator.getOutputType().isPresent());
    @SuppressWarnings("unchecked")
    final TypeDescriptor<KV<KeyT, OutputT>> kvOutputType =
        (TypeDescriptor) operator.getOutputType().get();
    final TypeVariable<Class<KV>>[] kvParameters = KV.class.getTypeParameters();
    final TypeDescriptor<?> firstType = kvOutputType.resolveType(kvParameters[0]);
    final TypeDescriptor<?> secondType = kvOutputType.resolveType(kvParameters[1]);
    assertEquals(keyType, firstType);
    assertEquals(outputType, secondType);
  } else {
    // assert output of non keyed operator
    assertEquals(outputType, operator.getOutputType().get());
  }
  if (valueType != null || operator instanceof TypeAware.Value) {
    @SuppressWarnings("unchecked")
    final TypeAware.Value<KeyT> valueAware = (TypeAware.Value) operator;
    assertTrue(valueAware.getValueType().isPresent());
    assertEquals(valueType, valueAware.getValueType().get());
  }
}