org.apache.flink.table.functions.AggregateFunction Java Examples

protected ACC accumulateValues(List<T> values)
		throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
	AggregateFunction<T, ACC> aggregator = getAggregator();
	ACC accumulator = getAggregator().createAccumulator();
	Method accumulateFunc = getAccumulateFunc();
	for (T value : values) {
		if (accumulateFunc.getParameterCount() == 1) {
			accumulateFunc.invoke(aggregator, (Object) accumulator);
		} else if (accumulateFunc.getParameterCount() == 2) {
			accumulateFunc.invoke(aggregator, (Object) accumulator, (Object) value);
		} else {
			throw new TableException("Unsupported now");
		}
	}
	return accumulator;
}
 

private void registerFunctions() {
	if (tableEnv instanceof StreamTableEnvironment) {
		StreamTableEnvironment streamTableEnvironment = (StreamTableEnvironment) tableEnv;
		functions.forEach((k, v) -> {
			if (v instanceof ScalarFunction) {
				streamTableEnvironment.registerFunction(k, (ScalarFunction) v);
			} else if (v instanceof AggregateFunction) {
				streamTableEnvironment.registerFunction(k, (AggregateFunction<?, ?>) v);
			} else if (v instanceof TableFunction) {
				streamTableEnvironment.registerFunction(k, (TableFunction<?>) v);
			} else {
				throw new SqlExecutionException("Unsupported function type: " + v.getClass().getName());
			}
		});
	} else {
		BatchTableEnvironment batchTableEnvironment = (BatchTableEnvironment) tableEnv;
		functions.forEach((k, v) -> {
			if (v instanceof ScalarFunction) {
				batchTableEnvironment.registerFunction(k, (ScalarFunction) v);
			} else if (v instanceof AggregateFunction) {
				batchTableEnvironment.registerFunction(k, (AggregateFunction<?, ?>) v);
			} else if (v instanceof TableFunction) {
				batchTableEnvironment.registerFunction(k, (TableFunction<?>) v);
			} else {
				throw new SqlExecutionException("Unsupported function type: " + v.getClass().getName());
			}
		});
	}
}
 

@Override
protected ListAggWsWithRetractAccumulator accumulateValues(List<BinaryString> values)
		throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
	AggregateFunction<BinaryString, ListAggWsWithRetractAccumulator> aggregator = getAggregator();
	ListAggWsWithRetractAccumulator accumulator = getAggregator().createAccumulator();
	Method accumulateFunc = getAccumulateFunc();
	Preconditions.checkArgument(values.size() % 2 == 0,
			"number of values must be an integer multiple of 2.");
	for (int i = 0; i < values.size(); i += 2) {
		BinaryString value = values.get(i + 1);
		BinaryString delimiter = values.get(i);
		accumulateFunc.invoke(aggregator, accumulator, delimiter, value);
	}
	return accumulator;
}
 

public HiveAggSqlFunction(String name, String displayName,
		AggregateFunction aggregateFunction, FlinkTypeFactory typeFactory) {
	super(name, displayName, aggregateFunction, fromLegacyInfoToDataType(new GenericTypeInfo<>(Object.class)),
			fromLegacyInfoToDataType(new GenericTypeInfo<>(Object.class)), typeFactory, false,
			new Some<>(createReturnTypeInference(aggregateFunction, typeFactory)));
	this.aggregateFunction = aggregateFunction;
}
 

@Override
public AggregateFunction makeFunction(Object[] constantArguments, LogicalType[] argTypes) {
	AggregateFunction clone;
	try {
		clone = InstantiationUtil.clone(aggregateFunction);
	} catch (IOException | ClassNotFoundException e) {
		throw new RuntimeException(e);
	}
	return (AggregateFunction) invokeSetArgs(clone, constantArguments, argTypes);
}
 

private static SqlReturnTypeInference createReturnTypeInference(
		AggregateFunction function, FlinkTypeFactory typeFactory) {
	return opBinding -> {
		List<RelDataType> sqlTypes = opBinding.collectOperandTypes();
		LogicalType[] parameters = UserDefinedFunctionUtils.getOperandTypeArray(opBinding);

		Object[] constantArguments = new Object[sqlTypes.size()];
		// Can not touch the literals, Calcite make them in previous RelNode.
		// In here, all inputs are input refs.
		return invokeGetResultType(function, constantArguments, parameters, typeFactory);
	};
}
 

protected void retractValues(ACC accumulator, List<T> values)
		throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
	AggregateFunction<T, ACC> aggregator = getAggregator();
	Method retractFunc = getRetractFunc();
	for (T value : values) {
		if (retractFunc.getParameterCount() == 1) {
			retractFunc.invoke(aggregator, (Object) accumulator);
		} else if (retractFunc.getParameterCount() == 2) {
			retractFunc.invoke(aggregator, (Object) accumulator, (Object) value);
		} else {
			throw new TableException("Unsupported now");
		}
	}
}
 

@Test
public void testMergeReservedAccumulator() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
	AggregateFunction<T, ACC> aggregator = getAggregator();
	boolean hasMerge = UserDefinedFunctionUtils.ifMethodExistInFunction("merge", aggregator);
	boolean hasRetract = UserDefinedFunctionUtils.ifMethodExistInFunction("retract", aggregator);
	if (!hasMerge || !hasRetract) {
		// this test only verify AggregateFunctions which has merge() and retract() method
		return;
	}

	Method mergeFunc = aggregator.getClass().getMethod("merge", getAccClass(), Iterable.class);
	List<List<T>> inputValueSets = getInputValueSets();
	int size = getInputValueSets().size();

	// iterate over input sets
	for (int i = 0; i < size; ++i) {
		List<T> inputValues = inputValueSets.get(i);
		List<ACC> accumulators = new ArrayList<>();
		List<ACC> reversedAccumulators = new ArrayList<>();
		// prepare accumulators
		accumulators.add(accumulateValues(inputValues));
		// prepare reversed accumulators
		ACC retractedAcc = aggregator.createAccumulator();
		retractValues(retractedAcc, inputValues);
		reversedAccumulators.add(retractedAcc);
		// prepare accumulator only contain two elements
		ACC accWithSubset = accumulateValues(inputValues.subList(0, 2));
		T expectedValue = aggregator.getValue(accWithSubset);

		// merge
		ACC acc = aggregator.createAccumulator();
		mergeFunc.invoke(aggregator, acc, accumulators);
		mergeFunc.invoke(aggregator, acc, reversedAccumulators);
		mergeFunc.invoke(aggregator, accWithSubset, Collections.singleton(acc));

		// getValue
		T result = aggregator.getValue(accWithSubset);
		validateResult(expectedValue, result);
	}
}
 

/**
 * Extracts a type inference from a {@link AggregateFunction}.
 */
public static TypeInference forAggregateFunction(
		DataTypeFactory typeFactory,
		Class<? extends AggregateFunction<?, ?>> function) {
	final FunctionMappingExtractor mappingExtractor = new FunctionMappingExtractor(
		typeFactory,
		function,
		UserDefinedFunctionHelper.AGGREGATE_ACCUMULATE,
		createParameterSignatureExtraction(1),
		createGenericResultExtraction(AggregateFunction.class, 1),
		createGenericResultExtraction(AggregateFunction.class, 0),
		createParameterWithAccumulatorVerification());
	return extractTypeInference(mappingExtractor);
}
 

protected void retractValues(ACC accumulator, List<T> values)
		throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
	AggregateFunction<T, ACC> aggregator = getAggregator();
	Method retractFunc = getRetractFunc();
	for (T value : values) {
		if (retractFunc.getParameterCount() == 1) {
			retractFunc.invoke(aggregator, (Object) accumulator);
		} else if (retractFunc.getParameterCount() == 2) {
			retractFunc.invoke(aggregator, (Object) accumulator, (Object) value);
		} else {
			throw new TableException("Unsupported now");
		}
	}
}
 

@Override
protected AggregateFunction<Double, MaxWithRetractAccumulator<Double>> getAggregator() {
	return new DoubleMaxWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Boolean, GenericRowData> getAggregator() {
	return new BooleanLastValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Long, GenericRow> getAggregator() {
	return new LongLastValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Boolean, GenericRowData> getAggregator() {
	return new BooleanFirstValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Short, GenericRow> getAggregator() {
	return new ShortLastValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<BinaryString, GenericRow> getAggregator() {
	return new StringFirstValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<DecimalData, GenericRowData> getAggregator() {
	return new DecimalFirstValueWithRetractAggFunction(DecimalDataTypeInfo.of(precision, scale));
}
 

@Override
protected AggregateFunction<Byte, GenericRow> getAggregator() {
	return new ByteFirstValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Integer, GenericRow> getAggregator() {
	return new IntFirstValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<StringData, GenericRowData> getAggregator() {
	return new StringFirstValueAggFunction();
}
 

@Override
protected AggregateFunction<Short, GenericRow> getAggregator() {
	return new ShortLastValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Byte, GenericRowData> getAggregator() {
	return new ByteFirstValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Integer, GenericRowData> getAggregator() {
	return new IntLastValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Time, MinWithRetractAccumulator<Time>> getAggregator() {
	return new TimeMinWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<DecimalData, GenericRowData> getAggregator() {
	return new DecimalFirstValueAggFunction(DecimalDataTypeInfo.of(precision, scale));
}
 

private void registerFunctions(Map<String, FunctionDefinition> functions) {
	if (tableEnv instanceof StreamTableEnvironment) {
		StreamTableEnvironment streamTableEnvironment = (StreamTableEnvironment) tableEnv;
		functions.forEach((k, v) -> {
			// Blink planner uses FLIP-65 functions for scalar and table functions
			// aggregate functions still use the old type inference
			if (environment.getExecution().isBlinkPlanner()) {
				if (v instanceof ScalarFunction || v instanceof TableFunction) {
					streamTableEnvironment.createTemporarySystemFunction(k, (UserDefinedFunction) v);
				} else if (v instanceof AggregateFunction) {
					streamTableEnvironment.registerFunction(k, (AggregateFunction<?, ?>) v);
				} else {
					throw new SqlExecutionException("Unsupported function type: " + v.getClass().getName());
				}
			}
			// legacy
			else {
				if (v instanceof ScalarFunction) {
					streamTableEnvironment.registerFunction(k, (ScalarFunction) v);
				} else if (v instanceof AggregateFunction) {
					streamTableEnvironment.registerFunction(k, (AggregateFunction<?, ?>) v);
				} else if (v instanceof TableFunction) {
					streamTableEnvironment.registerFunction(k, (TableFunction<?>) v);
				} else {
					throw new SqlExecutionException("Unsupported function type: " + v.getClass().getName());
				}
			}
		});
	} else {
		BatchTableEnvironment batchTableEnvironment = (BatchTableEnvironment) tableEnv;
		functions.forEach((k, v) -> {
			if (v instanceof ScalarFunction) {
				batchTableEnvironment.registerFunction(k, (ScalarFunction) v);
			} else if (v instanceof AggregateFunction) {
				batchTableEnvironment.registerFunction(k, (AggregateFunction<?, ?>) v);
			} else if (v instanceof TableFunction) {
				batchTableEnvironment.registerFunction(k, (TableFunction<?>) v);
			} else {
				throw new SqlExecutionException("Unsupported function type: " + v.getClass().getName());
			}
		});
	}
}
 

@Override
protected AggregateFunction<BinaryString, MinWithRetractAccumulator<BinaryString>> getAggregator() {
	return new StringMinWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Long, GenericRowData> getAggregator() {
	return new LongFirstValueAggFunction();
}
 

@Override
protected AggregateFunction<Integer, GenericRowData> getAggregator() {
	return new IntLastValueWithRetractAggFunction();
}
 

@Override
protected AggregateFunction<Double, MinWithRetractAccumulator<Double>> getAggregator() {
	return new DoubleMinWithRetractAggFunction();
}