Java CompositeType.createComparator方法代码示例

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
public static <X> KeySelector<X, Tuple> getSelectorForKeys(Keys<X> keys, TypeInformation<X> typeInfo, ExecutionConfig executionConfig) {
	if (!(typeInfo instanceof CompositeType)) {
		throw new InvalidTypesException(
				"This key operation requires a composite type such as Tuples, POJOs, or Case Classes.");
	}

	CompositeType<X> compositeType = (CompositeType<X>) typeInfo;

	int[] logicalKeyPositions = keys.computeLogicalKeyPositions();
	int numKeyFields = logicalKeyPositions.length;

	TypeInformation<?>[] typeInfos = keys.getKeyFieldTypes();
	// use ascending order here, the code paths for that are usually a slight bit faster
	boolean[] orders = new boolean[numKeyFields];
	for (int i = 0; i < numKeyFields; i++) {
		orders[i] = true;
	}

	TypeComparator<X> comparator = compositeType.createComparator(logicalKeyPositions, orders, 0, executionConfig);
	return new ComparableKeySelector<>(comparator, numKeyFields, new TupleTypeInfo<>(typeInfos));
}
 

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
public static <X, K> KeySelector<X, K> getSelectorForOneKey(
		Keys<X> keys, Partitioner<K> partitioner, TypeInformation<X> typeInfo, ExecutionConfig executionConfig) {
	if (!(typeInfo instanceof CompositeType)) {
		throw new InvalidTypesException(
				"This key operation requires a composite type such as Tuples, POJOs, case classes, etc");
	}
	if (partitioner != null) {
		keys.validateCustomPartitioner(partitioner, null);
	}

	CompositeType<X> compositeType = (CompositeType<X>) typeInfo;
	int[] logicalKeyPositions = keys.computeLogicalKeyPositions();
	if (logicalKeyPositions.length != 1) {
		throw new IllegalArgumentException("There must be exactly 1 key specified");
	}

	TypeComparator<X> comparator = compositeType.createComparator(
			logicalKeyPositions, new boolean[] { true }, 0, executionConfig);
	return new OneKeySelector<>(comparator);
}
 

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
@Override
protected TypeComparator<PojoContainingTuple> createComparator(boolean ascending) {
	Assert.assertTrue(type instanceof CompositeType);
	CompositeType<PojoContainingTuple> cType = (CompositeType<PojoContainingTuple>) type;
	ExpressionKeys<PojoContainingTuple> keys = new ExpressionKeys<PojoContainingTuple>(new String[] {"theTuple.*"}, cType);
	boolean[] orders = new boolean[keys.getNumberOfKeyFields()];
	Arrays.fill(orders, ascending);
	return cType.createComparator(keys.computeLogicalKeyPositions(), orders, 0, new ExecutionConfig());
}
 

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
PojoFieldAccessor(String field, TypeInformation<R> type, ExecutionConfig config) {
	if (!(type instanceof CompositeType<?>)) {
		throw new IllegalArgumentException(
				"Key expressions are only supported on POJO types and Tuples. "
						+ "A type is considered a POJO if all its fields are public, or have both getters and setters defined");
	}

	@SuppressWarnings("unchecked")
	CompositeType<R> cType = (CompositeType<R>) type;

	if(field.contains(".")) {
		throw new IllegalArgumentException("The Pojo field accessor currently doesn't support nested POJOs");
	}

	List<CompositeType.FlatFieldDescriptor> fieldDescriptors = cType.getFlatFields(field);

	int logicalKeyPosition = fieldDescriptors.get(0).getPosition();
	this.fieldType = fieldDescriptors.get(0).getType();

	if (cType instanceof PojoTypeInfo) {
		comparator = (PojoComparator<R>) cType.createComparator(
				new int[] { logicalKeyPosition }, new boolean[] { false }, 0, config);
	} else {
		throw new IllegalArgumentException(
				"Key expressions are only supported on POJO types. "
						+ "A type is considered a POJO if all its fields are public, or have both getters and setters defined");
	}
}
 

import org.apache.flink.api.common.typeutils.CompositeType; //导入方法依赖的package包/类
@Override
protected TypeComparator<PojoContainingTuple> createComparator(boolean ascending) {
	Assert.assertTrue(type instanceof CompositeType);
	CompositeType<PojoContainingTuple> cType = (CompositeType<PojoContainingTuple>) type;
	ExpressionKeys<PojoContainingTuple> keys = new ExpressionKeys<PojoContainingTuple>(new String[] {"theTuple.*"}, cType);
	boolean[] orders = new boolean[keys.getNumberOfKeyFields()];
	Arrays.fill(orders, ascending);
	return cType.createComparator(keys.computeLogicalKeyPositions(), orders, 0);
}