Java Code Examples for org.apache.flink.api.common.typeutils.CompositeType

The following examples show how to use org.apache.flink.api.common.typeutils.CompositeType. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: flink   Source File: FieldAccessorFactory.java    License: Apache License 2.0 6 votes vote down vote up
private static FieldExpression decomposeFieldExpression(String fieldExpression) {
	Matcher matcher = PATTERN_NESTED_FIELDS_WILDCARD.matcher(fieldExpression);
	if (!matcher.matches()) {
		throw new CompositeType.InvalidFieldReferenceException("Invalid field expression \"" + fieldExpression + "\".");
	}

	String head = matcher.group(0);
	if (head.equals(Keys.ExpressionKeys.SELECT_ALL_CHAR) || head.equals(Keys.ExpressionKeys.SELECT_ALL_CHAR_SCALA)) {
		throw new CompositeType.InvalidFieldReferenceException("No wildcards are allowed here.");
	} else {
		head = matcher.group(1);
	}

	String tail = matcher.group(3);

	return new FieldExpression(head, tail);
}
 
Example 2
Source Project: Flink-CEPplus   Source File: SemanticPropUtil.java    License: Apache License 2.0 6 votes vote down vote up
private static TypeInformation<?> getExpressionTypeInformation(String fieldStr, TypeInformation<?> typeInfo) {
	Matcher wildcardMatcher = PATTERN_WILDCARD.matcher(fieldStr);
	if (wildcardMatcher.matches()) {
		return typeInfo;
	} else {
		Matcher expMatcher = PATTERN_FIELD.matcher(fieldStr);
		if (!expMatcher.matches()) {
			throw new InvalidFieldReferenceException("Invalid field expression \"" + fieldStr + "\".");
		}
		if (typeInfo instanceof CompositeType<?>) {
			return ((CompositeType<?>) typeInfo).getTypeAt(expMatcher.group(1));
		} else {
			throw new InvalidFieldReferenceException("Nested field expression \"" + fieldStr + "\" not possible on atomic type (" + typeInfo + ").");
		}
	}
}
 
Example 3
Source Project: flink   Source File: Serializers.java    License: Apache License 2.0 6 votes vote down vote up
public static void recursivelyRegisterType(TypeInformation<?> typeInfo, ExecutionConfig config, Set<Class<?>> alreadySeen) {
	if (typeInfo instanceof GenericTypeInfo) {
		GenericTypeInfo<?> genericTypeInfo = (GenericTypeInfo<?>) typeInfo;
		Serializers.recursivelyRegisterType(genericTypeInfo.getTypeClass(), config, alreadySeen);
	}
	else if (typeInfo instanceof CompositeType) {
		List<GenericTypeInfo<?>> genericTypesInComposite = new ArrayList<>();
		getContainedGenericTypes((CompositeType<?>)typeInfo, genericTypesInComposite);
		for (GenericTypeInfo<?> gt : genericTypesInComposite) {
			Serializers.recursivelyRegisterType(gt.getTypeClass(), config, alreadySeen);
		}
	}
	else if (typeInfo instanceof ObjectArrayTypeInfo) {
		ObjectArrayTypeInfo<?, ?> objectArrayTypeInfo = (ObjectArrayTypeInfo<?, ?>) typeInfo;
		recursivelyRegisterType(objectArrayTypeInfo.getComponentInfo(), config, alreadySeen);
	}
}
 
Example 4
Source Project: Flink-CEPplus   Source File: Serializers.java    License: Apache License 2.0 6 votes vote down vote up
public static void recursivelyRegisterType(TypeInformation<?> typeInfo, ExecutionConfig config, Set<Class<?>> alreadySeen) {
	if (typeInfo instanceof GenericTypeInfo) {
		GenericTypeInfo<?> genericTypeInfo = (GenericTypeInfo<?>) typeInfo;
		Serializers.recursivelyRegisterType(genericTypeInfo.getTypeClass(), config, alreadySeen);
	}
	else if (typeInfo instanceof CompositeType) {
		List<GenericTypeInfo<?>> genericTypesInComposite = new ArrayList<>();
		getContainedGenericTypes((CompositeType<?>)typeInfo, genericTypesInComposite);
		for (GenericTypeInfo<?> gt : genericTypesInComposite) {
			Serializers.recursivelyRegisterType(gt.getTypeClass(), config, alreadySeen);
		}
	}
	else if (typeInfo instanceof ObjectArrayTypeInfo) {
		ObjectArrayTypeInfo<?, ?> objectArrayTypeInfo = (ObjectArrayTypeInfo<?, ?>) typeInfo;
		recursivelyRegisterType(objectArrayTypeInfo.getComponentInfo(), config, alreadySeen);
	}
}
 
Example 5
Source Project: flink   Source File: FieldAccessor.java    License: Apache License 2.0 6 votes vote down vote up
RecursiveProductFieldAccessor(int pos, TypeInformation<T> typeInfo, FieldAccessor<R, F> innerAccessor, ExecutionConfig config) {
	int arity = ((TupleTypeInfoBase) typeInfo).getArity();
	if (pos < 0 || pos >= arity) {
		throw new CompositeType.InvalidFieldReferenceException(
			"Tried to select " + ((Integer) pos).toString() + ". field on \"" +
				typeInfo.toString() + "\", which is an invalid index.");
	}
	checkNotNull(typeInfo, "typeInfo must not be null.");
	checkNotNull(innerAccessor, "innerAccessor must not be null.");

	this.pos = pos;
	this.fieldType = ((TupleTypeInfoBase<T>) typeInfo).getTypeAt(pos);
	this.serializer = (TupleSerializerBase<T>) typeInfo.createSerializer(config);
	this.length = this.serializer.getArity();
	this.fields = new Object[this.length];
	this.innerAccessor = innerAccessor;
}
 
Example 6
Source Project: Flink-CEPplus   Source File: OuterJoinOperatorBase.java    License: Apache License 2.0 6 votes vote down vote up
@SuppressWarnings("unchecked")
private <T> TypeComparator<T> buildComparatorFor(int input, ExecutionConfig executionConfig, TypeInformation<T> typeInformation) {
	TypeComparator<T> comparator;
	if (typeInformation instanceof AtomicType) {
		comparator = ((AtomicType<T>) typeInformation).createComparator(true, executionConfig);
	} else if (typeInformation instanceof CompositeType) {
		int[] keyPositions = getKeyColumns(input);
		boolean[] orders = new boolean[keyPositions.length];
		Arrays.fill(orders, true);

		comparator = ((CompositeType<T>) typeInformation).createComparator(keyPositions, orders, 0, executionConfig);
	} else {
		throw new RuntimeException("Type information for input of type " + typeInformation.getClass()
				.getCanonicalName() + " is not supported. Could not generate a comparator.");
	}
	return comparator;
}
 
Example 7
Source Project: Flink-CEPplus   Source File: SortPartitionOperatorBase.java    License: Apache License 2.0 6 votes vote down vote up
@Override
protected List<IN> executeOnCollections(List<IN> inputData, RuntimeContext runtimeContext, ExecutionConfig executionConfig) {

	TypeInformation<IN> inputType = getInput().getOperatorInfo().getOutputType();

	int[] sortColumns = this.partitionOrdering.getFieldPositions();
	boolean[] sortOrderings = this.partitionOrdering.getFieldSortDirections();

	final TypeComparator<IN> sortComparator;
	if (inputType instanceof CompositeType) {
		sortComparator = ((CompositeType<IN>) inputType).createComparator(sortColumns, sortOrderings, 0, executionConfig);
	} else if (inputType instanceof AtomicType) {
		sortComparator = ((AtomicType) inputType).createComparator(sortOrderings[0], executionConfig);
	} else {
		throw new UnsupportedOperationException("Partition sorting does not support type "+inputType+" yet.");
	}

	Collections.sort(inputData, new Comparator<IN>() {
		@Override
		public int compare(IN o1, IN o2) {
			return sortComparator.compare(o1, o2);
		}
	});

	return inputData;
}
 
Example 8
Source Project: Flink-CEPplus   Source File: Keys.java    License: Apache License 2.0 6 votes vote down vote up
public static boolean isSortKey(String fieldExpr, TypeInformation<?> type) {

			TypeInformation<?> sortKeyType;

			fieldExpr = fieldExpr.trim();
			if (SELECT_ALL_CHAR.equals(fieldExpr) || SELECT_ALL_CHAR_SCALA.equals(fieldExpr)) {
				sortKeyType = type;
			}
			else {
				if (type instanceof CompositeType) {
					sortKeyType = ((CompositeType<?>) type).getTypeAt(fieldExpr);
				}
				else {
					throw new InvalidProgramException(
						"Field expression must be equal to '" + SELECT_ALL_CHAR + "' or '" + SELECT_ALL_CHAR_SCALA + "' for atomic types.");
				}
			}

			return sortKeyType.isSortKeyType();
		}
 
Example 9
Source Project: flink   Source File: JavaApiPostPass.java    License: Apache License 2.0 6 votes vote down vote up
@SuppressWarnings("unchecked")
private <T> TypeComparatorFactory<?> createComparator(TypeInformation<T> typeInfo, FieldList keys, boolean[] sortOrder) {
	
	TypeComparator<T> comparator;
	if (typeInfo instanceof CompositeType) {
		comparator = ((CompositeType<T>) typeInfo).createComparator(keys.toArray(), sortOrder, 0, executionConfig);
	}
	else if (typeInfo instanceof AtomicType) {
		// handle grouping of atomic types
		comparator = ((AtomicType<T>) typeInfo).createComparator(sortOrder[0], executionConfig);
	}
	else {
		throw new RuntimeException("Unrecognized type: " + typeInfo);
	}

	return new RuntimeComparatorFactory<T>(comparator);
}
 
Example 10
Source Project: Flink-CEPplus   Source File: FieldAccessorFactory.java    License: Apache License 2.0 6 votes vote down vote up
private static FieldExpression decomposeFieldExpression(String fieldExpression) {
	Matcher matcher = PATTERN_NESTED_FIELDS_WILDCARD.matcher(fieldExpression);
	if (!matcher.matches()) {
		throw new CompositeType.InvalidFieldReferenceException("Invalid field expression \"" + fieldExpression + "\".");
	}

	String head = matcher.group(0);
	if (head.equals(Keys.ExpressionKeys.SELECT_ALL_CHAR) || head.equals(Keys.ExpressionKeys.SELECT_ALL_CHAR_SCALA)) {
		throw new CompositeType.InvalidFieldReferenceException("No wildcards are allowed here.");
	} else {
		head = matcher.group(1);
	}

	String tail = matcher.group(3);

	return new FieldExpression(head, tail);
}
 
Example 11
Source Project: flink   Source File: Serializers.java    License: Apache License 2.0 6 votes vote down vote up
public static void recursivelyRegisterType(TypeInformation<?> typeInfo, ExecutionConfig config, Set<Class<?>> alreadySeen) {
	if (typeInfo instanceof GenericTypeInfo) {
		GenericTypeInfo<?> genericTypeInfo = (GenericTypeInfo<?>) typeInfo;
		Serializers.recursivelyRegisterType(genericTypeInfo.getTypeClass(), config, alreadySeen);
	}
	else if (typeInfo instanceof CompositeType) {
		List<GenericTypeInfo<?>> genericTypesInComposite = new ArrayList<>();
		getContainedGenericTypes((CompositeType<?>)typeInfo, genericTypesInComposite);
		for (GenericTypeInfo<?> gt : genericTypesInComposite) {
			Serializers.recursivelyRegisterType(gt.getTypeClass(), config, alreadySeen);
		}
	}
	else if (typeInfo instanceof ObjectArrayTypeInfo) {
		ObjectArrayTypeInfo<?, ?> objectArrayTypeInfo = (ObjectArrayTypeInfo<?, ?>) typeInfo;
		recursivelyRegisterType(objectArrayTypeInfo.getComponentInfo(), config, alreadySeen);
	}
}
 
Example 12
Source Project: Flink-CEPplus   Source File: FieldAccessor.java    License: Apache License 2.0 6 votes vote down vote up
RecursiveProductFieldAccessor(int pos, TypeInformation<T> typeInfo, FieldAccessor<R, F> innerAccessor, ExecutionConfig config) {
	int arity = ((TupleTypeInfoBase) typeInfo).getArity();
	if (pos < 0 || pos >= arity) {
		throw new CompositeType.InvalidFieldReferenceException(
			"Tried to select " + ((Integer) pos).toString() + ". field on \"" +
				typeInfo.toString() + "\", which is an invalid index.");
	}
	checkNotNull(typeInfo, "typeInfo must not be null.");
	checkNotNull(innerAccessor, "innerAccessor must not be null.");

	this.pos = pos;
	this.fieldType = ((TupleTypeInfoBase<T>) typeInfo).getTypeAt(pos);
	this.serializer = (TupleSerializerBase<T>) typeInfo.createSerializer(config);
	this.length = this.serializer.getArity();
	this.fields = new Object[this.length];
	this.innerAccessor = innerAccessor;
}
 
Example 13
Source Project: flink   Source File: JavaApiPostPass.java    License: Apache License 2.0 6 votes vote down vote up
@SuppressWarnings("unchecked")
private <T> TypeComparatorFactory<?> createComparator(TypeInformation<T> typeInfo, FieldList keys, boolean[] sortOrder) {
	
	TypeComparator<T> comparator;
	if (typeInfo instanceof CompositeType) {
		comparator = ((CompositeType<T>) typeInfo).createComparator(keys.toArray(), sortOrder, 0, executionConfig);
	}
	else if (typeInfo instanceof AtomicType) {
		// handle grouping of atomic types
		comparator = ((AtomicType<T>) typeInfo).createComparator(sortOrder[0], executionConfig);
	}
	else {
		throw new RuntimeException("Unrecognized type: " + typeInfo);
	}

	return new RuntimeComparatorFactory<T>(comparator);
}
 
Example 14
Source Project: Flink-CEPplus   Source File: JavaApiPostPass.java    License: Apache License 2.0 6 votes vote down vote up
@SuppressWarnings("unchecked")
private <T> TypeComparatorFactory<?> createComparator(TypeInformation<T> typeInfo, FieldList keys, boolean[] sortOrder) {
	
	TypeComparator<T> comparator;
	if (typeInfo instanceof CompositeType) {
		comparator = ((CompositeType<T>) typeInfo).createComparator(keys.toArray(), sortOrder, 0, executionConfig);
	}
	else if (typeInfo instanceof AtomicType) {
		// handle grouping of atomic types
		comparator = ((AtomicType<T>) typeInfo).createComparator(sortOrder[0], executionConfig);
	}
	else {
		throw new RuntimeException("Unrecognized type: " + typeInfo);
	}

	return new RuntimeComparatorFactory<T>(comparator);
}
 
Example 15
Source Project: Flink-CEPplus   Source File: Utils.java    License: Apache License 2.0 6 votes vote down vote up
private static <T> TypeComparatorFactory<?> createComparator(TypeInformation<T> typeInfo, FieldList keys, boolean[] sortOrder, ExecutionConfig executionConfig) {

		TypeComparator<T> comparator;
		if (typeInfo instanceof CompositeType) {
			comparator = ((CompositeType<T>) typeInfo).createComparator(keys.toArray(), sortOrder, 0, executionConfig);
		}
		else if (typeInfo instanceof AtomicType) {
			// handle grouping of atomic types
			comparator = ((AtomicType<T>) typeInfo).createComparator(sortOrder[0], executionConfig);
		}
		else {
			throw new RuntimeException("Unrecognized type: " + typeInfo);
		}

		return new RuntimeComparatorFactory<>(comparator);
	}
 
Example 16
Source Project: flink   Source File: TableSchema.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Creates a table schema from a {@link TypeInformation} instance. If the type information is
 * a {@link CompositeType}, the field names and types for the composite type are used to
 * construct the {@link TableSchema} instance. Otherwise, a table schema with a single field
 * is created. The field name is "f0" and the field type the provided type.
 *
 * @param typeInfo The {@link TypeInformation} from which the table schema is generated.
 * @return The table schema that was generated from the given {@link TypeInformation}.
 *
 * @deprecated This method will be removed soon. Use {@link DataTypes} to declare types.
 */
@Deprecated
public static TableSchema fromTypeInfo(TypeInformation<?> typeInfo) {
	if (typeInfo instanceof CompositeType<?>) {
		final CompositeType<?> compositeType = (CompositeType<?>) typeInfo;
		// get field names and types from composite type
		final String[] fieldNames = compositeType.getFieldNames();
		final TypeInformation<?>[] fieldTypes = new TypeInformation[fieldNames.length];
		for (int i = 0; i < fieldTypes.length; i++) {
			fieldTypes[i] = compositeType.getTypeAt(i);
		}
		return new TableSchema(fieldNames, fieldTypes);
	} else {
		// create table schema with a single field named "f0" of the given type.
		return new TableSchema(
			new String[]{ATOMIC_TYPE_FIELD_NAME},
			new TypeInformation<?>[]{typeInfo});
	}
}
 
Example 17
Source Project: flink   Source File: Keys.java    License: Apache License 2.0 6 votes vote down vote up
public static boolean isSortKey(int fieldPos, TypeInformation<?> type) {

			if (!type.isTupleType() || !(type instanceof CompositeType)) {
				throw new InvalidProgramException("Specifying keys via field positions is only valid " +
					"for tuple data types. Type: " + type);
			}
			if (type.getArity() == 0) {
				throw new InvalidProgramException("Tuple size must be greater than 0. Size: " + type.getArity());
			}

			if(fieldPos < 0 || fieldPos >= type.getArity()) {
				throw new IndexOutOfBoundsException("Tuple position is out of range: " + fieldPos);
			}

			TypeInformation<?> sortKeyType = ((CompositeType<?>)type).getTypeAt(fieldPos);
			return sortKeyType.isSortKeyType();
		}
 
Example 18
Source Project: flink   Source File: FieldAccessorFactory.java    License: Apache License 2.0 6 votes vote down vote up
private static FieldExpression decomposeFieldExpression(String fieldExpression) {
	Matcher matcher = PATTERN_NESTED_FIELDS_WILDCARD.matcher(fieldExpression);
	if (!matcher.matches()) {
		throw new CompositeType.InvalidFieldReferenceException("Invalid field expression \"" + fieldExpression + "\".");
	}

	String head = matcher.group(0);
	if (head.equals(Keys.ExpressionKeys.SELECT_ALL_CHAR) || head.equals(Keys.ExpressionKeys.SELECT_ALL_CHAR_SCALA)) {
		throw new CompositeType.InvalidFieldReferenceException("No wildcards are allowed here.");
	} else {
		head = matcher.group(1);
	}

	String tail = matcher.group(3);

	return new FieldExpression(head, tail);
}
 
Example 19
Source Project: flink   Source File: Keys.java    License: Apache License 2.0 6 votes vote down vote up
public static boolean isSortKey(int fieldPos, TypeInformation<?> type) {

			if (!type.isTupleType() || !(type instanceof CompositeType)) {
				throw new InvalidProgramException("Specifying keys via field positions is only valid " +
					"for tuple data types. Type: " + type);
			}
			if (type.getArity() == 0) {
				throw new InvalidProgramException("Tuple size must be greater than 0. Size: " + type.getArity());
			}

			if(fieldPos < 0 || fieldPos >= type.getArity()) {
				throw new IndexOutOfBoundsException("Tuple position is out of range: " + fieldPos);
			}

			TypeInformation<?> sortKeyType = ((CompositeType<?>)type).getTypeAt(fieldPos);
			return sortKeyType.isSortKeyType();
		}
 
Example 20
Source Project: flink   Source File: FieldInfoUtils.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Returns field names for a given {@link TypeInformation}. If the input {@link TypeInformation}
 * is not a composite type, the result field name should not exist in the existingNames.
 *
 * @param inputType The TypeInformation extract the field names.
 * @param existingNames The existing field names for non-composite types that can not be used.
 * @param <A> The type of the TypeInformation.
 * @return An array holding the field names
 */
public static <A> String[] getFieldNames(TypeInformation<A> inputType, List<String> existingNames) {
	validateInputTypeInfo(inputType);

	String[] fieldNames;
	if (inputType instanceof CompositeType) {
		fieldNames = ((CompositeType<A>) inputType).getFieldNames();
	} else {
		int i = 0;
		String fieldName = ATOMIC_FIELD_NAME;
		while ((null != existingNames) && existingNames.contains(fieldName)) {
			fieldName = ATOMIC_FIELD_NAME + "_" + i++;
		}
		fieldNames = new String[]{fieldName};
	}

	if (Arrays.asList(fieldNames).contains("*")) {
		throw new TableException("Field name can not be '*'.");
	}

	return fieldNames;
}
 
Example 21
Source Project: flink   Source File: Keys.java    License: Apache License 2.0 6 votes vote down vote up
public SelectorFunctionKeys(KeySelector<T, K> keyExtractor, TypeInformation<T> inputType, TypeInformation<K> keyType) {

			if (keyExtractor == null) {
				throw new NullPointerException("Key extractor must not be null.");
			}
			if (keyType == null) {
				throw new NullPointerException("Key type must not be null.");
			}
			if (!keyType.isKeyType()) {
				throw new InvalidProgramException("Return type "+keyType+" of KeySelector "+keyExtractor.getClass()+" is not a valid key type");
			}

			this.keyExtractor = keyExtractor;
			this.inputType = inputType;
			this.keyType = keyType;

			this.originalKeyTypes = new TypeInformation[] {keyType};
			if (keyType instanceof CompositeType) {
				this.keyFields = ((CompositeType<T>)keyType).getFlatFields(ExpressionKeys.SELECT_ALL_CHAR);
			}
			else {
				this.keyFields = new ArrayList<>(1);
				this.keyFields.add(new FlatFieldDescriptor(0, keyType));
			}
		}
 
Example 22
Source Project: flink   Source File: Keys.java    License: Apache License 2.0 6 votes vote down vote up
public SelectorFunctionKeys(KeySelector<T, K> keyExtractor, TypeInformation<T> inputType, TypeInformation<K> keyType) {

			if (keyExtractor == null) {
				throw new NullPointerException("Key extractor must not be null.");
			}
			if (keyType == null) {
				throw new NullPointerException("Key type must not be null.");
			}
			if (!keyType.isKeyType()) {
				throw new InvalidProgramException("Return type "+keyType+" of KeySelector "+keyExtractor.getClass()+" is not a valid key type");
			}

			this.keyExtractor = keyExtractor;
			this.inputType = inputType;
			this.keyType = keyType;

			this.originalKeyTypes = new TypeInformation[] {keyType};
			if (keyType instanceof CompositeType) {
				this.keyFields = ((CompositeType<T>)keyType).getFlatFields(ExpressionKeys.SELECT_ALL_CHAR);
			}
			else {
				this.keyFields = new ArrayList<>(1);
				this.keyFields.add(new FlatFieldDescriptor(0, keyType));
			}
		}
 
Example 23
Source Project: Flink-CEPplus   Source File: ProjectOperator.java    License: Apache License 2.0 5 votes vote down vote up
@Override
protected org.apache.flink.api.common.operators.base.MapOperatorBase<IN, OUT, MapFunction<IN, OUT>> translateToDataFlow(Operator<IN> input) {
	String name = getName() != null ? getName() : "Projection " + Arrays.toString(fields);
	// create operator
	PlanProjectOperator<IN, OUT> ppo = new PlanProjectOperator<IN, OUT>(fields, name, getInputType(), getResultType(), context.getConfig());
	// set input
	ppo.setInput(input);
	// set parallelism
	ppo.setParallelism(this.getParallelism());
	ppo.setSemanticProperties(SemanticPropUtil.createProjectionPropertiesSingle(fields, (CompositeType<?>) getInputType()));

	return ppo;
}
 
Example 24
Source Project: flink   Source File: FieldAccessorTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test(expected = CompositeType.InvalidFieldReferenceException.class)
public void testIllegalTupleInPojoInTuple() {
	Tuple2<String, Foo> t = Tuple2.of("aa", new Foo(8, Tuple2.of("ddd", 9L), (short) 2));
	TupleTypeInfo<Tuple2<String, Foo>> tpeInfo =
		(TupleTypeInfo<Tuple2<String, Foo>>) TypeExtractor.getForObject(t);

	FieldAccessorFactory.getAccessor(tpeInfo, "illegal.illegal.illegal", null);
}
 
Example 25
Source Project: flink   Source File: PojoComparatorTest.java    License: Apache License 2.0 5 votes vote down vote up
@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());
}
 
Example 26
Source Project: flink   Source File: FieldAccessor.java    License: Apache License 2.0 5 votes vote down vote up
SimpleTupleFieldAccessor(int pos, TypeInformation<T> typeInfo) {
	checkNotNull(typeInfo, "typeInfo must not be null.");
	int arity = ((TupleTypeInfo) typeInfo).getArity();
	if (pos < 0 || pos >= arity) {
		throw new CompositeType.InvalidFieldReferenceException(
			"Tried to select " + ((Integer) pos).toString() + ". field on \"" +
			typeInfo.toString() + "\", which is an invalid index.");
	}

	this.pos = pos;
	this.fieldType = ((TupleTypeInfo) typeInfo).getTypeAt(pos);
}
 
Example 27
Source Project: Flink-CEPplus   Source File: DataSinkTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test(expected = CompositeType.InvalidFieldReferenceException.class)
public void testFailTupleInv() {

	final ExecutionEnvironment env = ExecutionEnvironment
			.getExecutionEnvironment();
	DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env
			.fromCollection(emptyTupleData, tupleTypeInfo);

	// must not work
	tupleDs.writeAsText("/tmp/willNotHappen")
		.sortLocalOutput("notThere", Order.ASCENDING)
		.sortLocalOutput("f4", Order.DESCENDING);
}
 
Example 28
Source Project: Flink-CEPplus   Source File: RightOuterJoinOperatorTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test(expected = CompositeType.InvalidFieldReferenceException.class)
public void testRightOuter8() {
	final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
	DataSet<Tuple5<Integer, Long, String, Long, Integer>> ds1 = env.fromCollection(emptyTupleData, tupleTypeInfo);
	DataSet<Tuple5<Integer, Long, String, Long, Integer>> ds2 = env.fromCollection(emptyTupleData, tupleTypeInfo);

	// invalid key reference
	ds1.rightOuterJoin(ds2)
			.where(1).equalTo("f5")
			.with(new DummyJoin());
}
 
Example 29
Source Project: Flink-CEPplus   Source File: JoinOperatorTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void testJoinKeyNestedTuplesWithCustom() {
	final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
	DataSet<Tuple5<CustomType, Long, String, Long, Integer>> ds1 = env.fromCollection(emptyNestedCustomTupleData, nestedCustomTupleTypeInfo);
	DataSet<Tuple5<Integer, Long, String, Long, Integer>> ds2 = env.fromCollection(emptyTupleData, tupleTypeInfo);
	try {
		TypeInformation<?> t = ds1.join(ds2).where("f0.myInt").equalTo(4).getType();
		assertTrue("not a composite type", t instanceof CompositeType);
	} catch (Exception e) {
		e.printStackTrace();
		Assert.fail();
	}
}
 
Example 30
Source Project: Flink-CEPplus   Source File: RowTypeInfo.java    License: Apache License 2.0 5 votes vote down vote up
@Override
public <X> TypeInformation<X> getTypeAt(String fieldExpression) {
	Matcher matcher = PATTERN_NESTED_FIELDS.matcher(fieldExpression);
	if (!matcher.matches()) {
		if (fieldExpression.equals(ExpressionKeys.SELECT_ALL_CHAR) ||
			fieldExpression.equals(ExpressionKeys.SELECT_ALL_CHAR_SCALA)) {
			throw new InvalidFieldReferenceException("Wildcard expressions are not allowed here.");
		} else {
			throw new InvalidFieldReferenceException("Invalid format of Row field expression \""+fieldExpression+"\".");
		}
	}

	String field = matcher.group(1);

	Matcher intFieldMatcher = PATTERN_INT_FIELD.matcher(field);
	int fieldIndex;
	if (intFieldMatcher.matches()) {
		// field expression is an integer
		fieldIndex = Integer.valueOf(field);
	} else {
		fieldIndex = this.getFieldIndex(field);
	}
	// fetch the field type will throw exception if the index is illegal
	TypeInformation<X> fieldType = this.getTypeAt(fieldIndex);

	String tail = matcher.group(3);
	if (tail == null) {
		// found the type
		return fieldType;
	} else {
		if (fieldType instanceof CompositeType) {
			return ((CompositeType<?>) fieldType).getTypeAt(tail);
		} else {
			throw new InvalidFieldReferenceException(
				"Nested field expression \""+ tail + "\" not possible on atomic type "+fieldType+".");
		}
	}
}