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

@Test
public void testHiveBuiltInFunction() {
	FunctionDefinition fd = new HiveModule().getFunctionDefinition("reverse").get();

	ScalarFunction func = ((ScalarFunctionDefinition) fd).getScalarFunction();
	HiveSimpleUDF udf = (HiveSimpleUDF) func;

	DataType[] inputType = new DataType[] {
		DataTypes.STRING()
	};

	udf.setArgumentTypesAndConstants(new Object[0], inputType);
	udf.getHiveResultType(new Object[0], inputType);

	udf.open(null);

	assertEquals("cba", udf.eval("abc"));
}
 

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

		Object[] constantArguments = new Object[sqlTypes.size()];
		for (int i = 0; i < sqlTypes.size(); i++) {
			if (!opBinding.isOperandNull(i, false) && opBinding.isOperandLiteral(i, false)) {
				constantArguments[i] = opBinding.getOperandLiteralValue(
						i, getDefaultExternalClassForType(parameters[i]));
			}
		}
		return invokeGetResultType(function, constantArguments, parameters, typeFactory);
	};
}
 

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

		Object[] constantArguments = new Object[sqlTypes.size()];
		for (int i = 0; i < sqlTypes.size(); i++) {
			if (!opBinding.isOperandNull(i, false) && opBinding.isOperandLiteral(i, false)) {
				constantArguments[i] = opBinding.getOperandLiteralValue(
						i, getDefaultExternalClassForType(parameters[i]));
			}
		}
		return invokeGetResultType(function, constantArguments, parameters, typeFactory);
	};
}
 

@Override
public Optional<RexNode> convert(CallExpression call, ConvertContext context) {
	FunctionDefinition def = call.getFunctionDefinition();
	if (def instanceof ScalarFunctionDefinition) {
		ScalarFunction scalaFunc = ((ScalarFunctionDefinition) def).getScalarFunction();
		FunctionIdentifier identifier = call.getFunctionIdentifier()
			.orElse(FunctionIdentifier.of(scalaFunc.functionIdentifier()));
		SqlFunction sqlFunction = UserDefinedFunctionUtils.createScalarSqlFunction(
			identifier,
			scalaFunc.toString(),
			scalaFunc,
			context.getTypeFactory());
		return Optional.of(context.getRelBuilder()
			.call(sqlFunction, toRexNodes(context, call.getChildren())));
	}
	return Optional.empty();
}
 

/**
 * Extracts a type inference from a {@link ScalarFunction}.
 */
public static TypeInference forScalarFunction(
		DataTypeFactory typeFactory,
		Class<? extends ScalarFunction> function) {
	final FunctionMappingExtractor mappingExtractor = new FunctionMappingExtractor(
		typeFactory,
		function,
		UserDefinedFunctionHelper.SCALAR_EVAL,
		createParameterSignatureExtraction(0),
		null,
		createReturnTypeResultExtraction(),
		createParameterAndReturnTypeVerification());
	return extractTypeInference(mappingExtractor);
}
 

public BatchOperator udf(String selectedColName, String outputColName, ScalarFunction scalarFunction,
						 String[] reservedColNames) {
	return linkTo(
		new UDFBatchOp()
			.setSelectedCols(selectedColName)
			.setOutputCol(outputColName)
			.setFunc(scalarFunction)
			.setReservedCols(reservedColNames)
			.setMLEnvironmentId(getMLEnvironmentId())
	);
}
 

public BatchOperator udf(String selectedColName, String outputColName, ScalarFunction scalarFunction) {
	return linkTo(
		new UDFBatchOp()
			.setSelectedCols(selectedColName)
			.setOutputCol(outputColName)
			.setFunc(scalarFunction)
			.setMLEnvironmentId(getMLEnvironmentId())
	);
}
 

/**
 * @deprecated Use {@link #registerTemporarySystemFunction(String, FunctionDefinition, boolean)} instead.
 */
@Deprecated
public void registerTempSystemScalarFunction(String name, ScalarFunction function) {
	UserDefinedFunctionHelper.prepareInstance(config, function);

	registerTempSystemFunction(
		name,
		new ScalarFunctionDefinition(name, function)
	);
}
 

public void registerTempCatalogScalarFunction(ObjectIdentifier oi, ScalarFunction function) {
	UserDefinedFunctionHelper.prepareInstance(config, function);

	registerTempCatalogFunction(
		oi,
		new ScalarFunctionDefinition(oi.getObjectName(), function)
	);
}
 

public StreamOperator udf(String selectedColName, String outputColName, ScalarFunction scalarFunction,
						  String[] reservedColNames) {
	return linkTo(
		new UDFStreamOp()
			.setSelectedCols(selectedColName)
			.setOutputCol(outputColName)
			.setFunc(scalarFunction)
			.setReservedCols(reservedColNames)
			.setMLEnvironmentId(getMLEnvironmentId())
	);
}
 

public StreamOperator udf(String selectedColName, String outputColName, ScalarFunction scalarFunction) {
	return linkTo(
		new UDFStreamOp()
			.setSelectedCols(selectedColName)
			.setOutputCol(outputColName)
			.setFunc(scalarFunction)
			.setMLEnvironmentId(getMLEnvironmentId())
	);
}
 

private void register(StreamTableEnvironment env, String name, Object function) {
    if (function instanceof TableFunction) {
        env.registerFunction(name, (TableFunction) function);
    } else if (function instanceof AggregateFunction) {
        env.registerFunction(name, (AggregateFunction) function);
    } else if (function instanceof ScalarFunction) {
        env.registerFunction(name, (ScalarFunction) function);
    } else {
        throw new RuntimeException("Unknown UDF {} was found." + name);
    }
    LOGGER.info("register udf, name:{}, class:{}", name, function.getClass());
}
 

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
public ScalarFunction makeFunction(Object[] constantArguments, LogicalType[] argTypes) {
	ScalarFunction clone;
	try {
		clone = InstantiationUtil.clone(function);
	} catch (IOException | ClassNotFoundException e) {
		throw new RuntimeException(e);
	}
	return (ScalarFunction) invokeSetArgs(clone, constantArguments, argTypes);
}
 

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

private RexNode visit(UnresolvedCallExpression call) {
	FunctionDefinition func = call.getFunctionDefinition();
	switch (func.getKind()) {
		case SCALAR:
			if (func instanceof ScalarFunctionDefinition) {
				ScalarFunction scalaFunc = ((ScalarFunctionDefinition) func).getScalarFunction();
				List<RexNode> child = convertCallChildren(call.getChildren());
				SqlFunction sqlFunction = UserDefinedFunctionUtils.createScalarSqlFunction(
						scalaFunc.functionIdentifier(),
						scalaFunc.toString(),
						scalaFunc,
						typeFactory);
				return relBuilder.call(sqlFunction, child);
			} else {
				FunctionDefinition def = call.getFunctionDefinition();
				if (conversionsOfBuiltInFunc.containsKey(def)) {
					RexNodeConversion conversion = conversionsOfBuiltInFunc.get(def);
					return conversion.convert(call);
				} else {
					throw new UnsupportedOperationException(def.toString());
				}
			}

		default:
			throw new UnsupportedOperationException();
	}
}
 

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());
			}
		});
	}
}
 

public void registerScalarFunction(String name, ScalarFunction function) {
	UserFunctionsTypeHelper.validateInstantiation(function.getClass());
	registerFunction(
		name,
		new ScalarFunctionDefinition(name, function)
	);
}
 

public HiveScalarSqlFunction(
		FunctionIdentifier identifier, ScalarFunction function, FlinkTypeFactory typeFactory) {
	super(identifier, identifier.toString(), function,
			typeFactory, new Some<>(createReturnTypeInference(function, typeFactory)));
	this.function = function;
}
 

@Override
public void registerFunction(String name, ScalarFunction function) {
	functionCatalog.registerTempSystemScalarFunction(
		name,
		function);
}
 

static TestSpec forScalarFunction(String description, Class<? extends ScalarFunction> function) {
	return new TestSpec(
		description == null ? function.getSimpleName() : description,
		() -> TypeInferenceExtractor.forScalarFunction(new DataTypeFactoryMock(), function));
}
 

static TestSpec forScalarFunction(Class<? extends ScalarFunction> function) {
	return forScalarFunction(null, function);
}
 

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());
			}
		});
	}
}
 

private Optional<SqlFunction> convertToSqlFunction(
		SqlFunctionCategory category,
		String name,
		FunctionDefinition functionDefinition) {
	if (functionDefinition instanceof AggregateFunctionDefinition) {
		return convertAggregateFunction(name, (AggregateFunctionDefinition) functionDefinition);
	} else if (functionDefinition instanceof ScalarFunctionDefinition) {
		return convertScalarFunction(name, (ScalarFunctionDefinition) functionDefinition);
	} else if (functionDefinition instanceof TableFunctionDefinition &&
			category != null &&
			category.isTableFunction()) {
		return convertTableFunction(name, (TableFunctionDefinition) functionDefinition);
	} else if (functionDefinition instanceof BuiltInFunctionDefinition) {
		return Optional.empty();
	}
	LOG.warn(
		"The new type inference for functions is only supported in the Blink planner. " +
			"Falling back to legacy type inference for function '{}'.",
		functionDefinition.getClass().toString());
	if (functionDefinition instanceof ScalarFunction) {
		return convertToSqlFunction(
			category,
			name,
			new ScalarFunctionDefinition(
				name,
				(ScalarFunction) functionDefinition)
		);
	} else if (functionDefinition instanceof TableFunction) {
		final TableFunction<?> t = (TableFunction<?>) functionDefinition;
		return convertToSqlFunction(
			category,
			name,
			new TableFunctionDefinition(
				name,
				t,
				UserDefinedFunctionHelper.getReturnTypeOfTableFunction(t))
		);
	}
	throw new TableException(
		"The new type inference for functions is only supported in the Blink planner.");
}
 

public static void registerFunction(String name, ScalarFunction function) {
	MLEnvironmentFactory.getDefault().getBatchTableEnvironment().registerFunction(name, function);
}
 

public ScalarFunction getFunc() {
    return this.func;
}
 

public UDFBatchOp setFunc(ScalarFunction udf) {
    this.func = udf;
    return this;
}
 

public static void registerFunction(String name, ScalarFunction function) {
	MLEnvironmentFactory.getDefault().getStreamTableEnvironment().registerFunction(name, function);
}
 

public ScalarFunction getFunc() {
    return this.func;
}
 

public UDFStreamOp setFunc(ScalarFunction udf) {
    this.func = udf;
    return this;
}