Java Type.UNION屬性代碼示例

public Object fromBytes(Schema schema, byte data[]) throws GoraException {
  Schema fromSchema = null;
  if (schema.getType() == Type.UNION) {
    try {
      Decoder decoder = DecoderFactory.get().binaryDecoder(data, null);
      int unionIndex = decoder.readIndex();
      List<Schema> possibleTypes = schema.getTypes();
      fromSchema = possibleTypes.get(unionIndex);
      Schema effectiveSchema = possibleTypes.get(unionIndex);
      if (effectiveSchema.getType() == Type.NULL) {
        decoder.readNull();
        return null;
      } else {
        data = decoder.readBytes(null).array();
      }
    } catch (IOException e) {
      LOG.error(e.getMessage());
      throw new GoraException("Error decoding union type: ", e);
    }
  } else {
    fromSchema = schema;
  }
  return fromBytes(encoder, fromSchema, data);
}
 

public byte[] toBytes(Schema toSchema, Object o) {
  if (toSchema != null && toSchema.getType() == Type.UNION) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    org.apache.avro.io.BinaryEncoder avroEncoder = EncoderFactory.get().binaryEncoder(baos, null);
    int unionIndex = 0;
    try {
      if (o == null) {
        unionIndex = firstNullSchemaTypeIndex(toSchema);
        avroEncoder.writeIndex(unionIndex);
        avroEncoder.writeNull();
      } else {
        unionIndex = firstNotNullSchemaTypeIndex(toSchema);
        avroEncoder.writeIndex(unionIndex);
        avroEncoder.writeBytes(toBytes(o));
      }
      avroEncoder.flush();
      return baos.toByteArray();
    } catch (IOException e) {
      LOG.error(e.getMessage());
      return toBytes(o);
    }
  } else {
    return toBytes(o);
  }
}
 

/**
 * Select the families that contain at least one column mapped to a query field.
 * @param query indicates the columns to select
 * @return a map which keys are the family names and values the 
 * corresponding column names required to get all the query fields.
 */
public Map<String, List<String>> getFamilyMap(Query<K, T> query) {
  Map<String, List<String>> map = new HashMap<>();
  Schema persistentSchema = query.getDataStore().newPersistent().getSchema();
  for (String field: query.getFields()) {
    String family = this.getMappingFamily(field);
    String column = this.getMappingColumn(field);
    
    // check if the family value was already initialized 
    List<String> list = map.get(family);
    if (list == null) {
      list = new ArrayList<>();
      map.put(family, list);
    }
    if (persistentSchema.getField(field).schema().getType() == Type.UNION)
      list.add(field + CassandraStore.UNION_COL_SUFIX);
    if (column != null) {
      list.add(column);
    }
  }
  
  return map;
}
 

public void validate(final Schema schema) {
    if (schema.getType() != Type.UNION)
        throw new IllegalArgumentException("Must be type " + Type.UNION);
    if (schema.getTypes().size() > TYPES_MAX_COUNT)
        throw new IllegalArgumentException("Only supports up to " + TYPES_MAX_COUNT + " types. Found " + schema.getTypes().size());
    for (Schema typeSchema : schema.getTypes()) {
        fieldCodec.validate(typeSchema);
    }
}
 

/**
 * Select the field names according to the column names, which format 
 * if fully qualified: "family:column"
 * @param query
 * @return a map which keys are the fully qualified column 
 * names and values the query fields
 */
public Map<String, String> getReverseMap(Query<K, T> query) {
  Map<String, String> map = new HashMap<>();
  Schema persistentSchema = query.getDataStore().newPersistent().getSchema();
  for (String field: query.getFields()) {
    String family = this.getMappingFamily(field);
    String column = this.getMappingColumn(field);
    if (persistentSchema.getField(field).schema().getType() == Type.UNION)
      map.put(family + ":" + field + CassandraStore.UNION_COL_SUFIX, field + CassandraStore.UNION_COL_SUFIX);
    map.put(family + ":" + column, field);
  }
  
  return map;
}
 

protected static Type preferredTypeFor(Field fld) {
	
	Type type = fld.schema().getType();
	
	if (type == Type.UNION) {
		List<Schema> types = fld.schema().getTypes();
		if (isNullableSingleType(types)) {
			Schema sch = nonNullSchemaIn(types);
			return sch.getType();
		}
	}
	return type;
}
 

private String labelFor(Schema sc) {
	
	Type typ = (sc.getType() == Type.ARRAY) ?
			sc.getElementType().getType() : 
			sc.getType();
	
	String typeText = formatType(typ.getName());
	String name = showFullNames ? sc.getFullName() : sc.getName();
	
	boolean isNullable = sc.getType() == Type.UNION && isNullableSingleType(sc.getTypes());
	
	return isNullable ?
		"<i>" + name + "</i>  " + typeText :
		name + "  " + typeText;
}
 

private void render(Schema sc, String parent, boolean isNullable) {

		String childId = newIdFor(parent, sc.getName());
		
		startNewLine();
		appendIds(childId, parent);
		append("type", typeFor(sc, isNullable), true);
		append("text", labelFor(sc), false);
		appendDoc(sc.getDoc());
		endLine();
		
		if (showConstraints) showConstraints(sc, childId);
		if (showMetrics) showMetrics(sc, childId);
		
		incrementDepth();
		
		if (sc.getType() == Type.RECORD) {
			for (Field fld : sc.getFields()) { 
				render(fld, childId); 
				}
			}

		if (sc.getType() == Type.ARRAY) {
			render(sc.getElementType(), childId, false);
			}
		
		if (sc.getType() == Type.UNION) {
			System.out.println("####!!!!!####");
			}
		
		decrementDepth();
	}
 

public static Type primaryTypeIn(Schema schema) {

		if (schema.getType() == Type.UNION) {
			for (Schema sch : schema.getTypes()) {
				if (sch.getType() == Type.NULL) continue;
				return sch.getType();	// TODO what about more complex UNIONs ?
			}
		}
		return schema.getType();
	}
 

public static boolean allowsNull(Schema schema) {

		if (schema.getType() == Type.UNION) {
			for (Schema sch : schema.getTypes()) {
				if (sch.getType() == Type.NULL) return true;
			}
		};
		return false;
	}
 

private static Collection<Constraint<?>> allConstraintsIn(JsonNode cstNode, Schema schema, ConstraintFactory<Schema.Type> factory) {

		if (Type.UNION == schema.getType() && schema.getTypes().size() > 2) throw new RuntimeException("Cannot currently handle more than two major datatypes in a UNION");

		Collection<Constraint<?>> constraints = new ArrayList<>(cstNode.size() + 2);
		Type type = AvroUtil.primaryTypeIn(schema);
		boolean allowsNulls = AvroUtil.allowsNull(schema);

		Iterator<JsonNode> iter = cstNode.getElements();
		while (iter.hasNext()) {
			Collection<Constraint<?>> csts = constraintsIn(iter.next(), type, allowsNulls, factory);
			if (csts != null) constraints.addAll(csts);
		}
		return constraints;
	}
 

private static Map<String, MetricDescriptor> allMetricsIn(JsonNode cstNode, Schema schema) {

		if (Type.UNION == schema.getType() && schema.getTypes().size() > 2) throw new RuntimeException("Cannot currently handle more than two major datatypes in a UNION");

		Map<String, MetricDescriptor> metrics = new HashMap<>(cstNode.size() + 2);
		Type type = AvroUtil.primaryTypeIn(schema);
		boolean allowsNulls = AvroUtil.allowsNull(schema);

		Iterator<JsonNode> iter = cstNode.getElements();
		while (iter.hasNext()) {
			Map<String, MetricDescriptor> csts = metricsIn(iter.next(), type, allowsNulls);
			if (csts != null) metrics.putAll(csts);
		}
		return metrics;
	}
 

public static boolean isNullableSingleType(Field field) {
	return field.schema().getType() == Type.UNION &&
			isNullableSingleType(field.schema().getTypes());
}