Flink 原理与实现: FlinkSQL的Table API 与SQL之函数（Functions）

2022-02-14

字数统计: 2.5k字 | 阅读时长≈ 10分

Flink Table 和 SQL内置了很多SQL中支持的函数；如果有无法满足的需要，则可以实现用户自定义的函数（UDF）来解决。

系统内置函数

Flink Table API 和 SQL为用户提供了一组用于数据转换的内置函数。SQL中支持的很多函数，Table API和SQL都已经做了实现，其它还在快速开发扩展中。

以下是一些典型函数的举例，全部的内置函数，可以参考官网介绍。

1.比较函数

SQL：

1
2
3

value1 = value2

	value1 > value2

Table API：

1
2
3

ANY1 === ANY2

ANY1 > ANY2

2.逻辑函数

SQL：

boolean1 OR boolean2

boolean IS FALSE

NOT boolean

Table API：

BOOLEAN1 || BOOLEAN2

BOOLEAN.isFalse

!BOOLEAN

3.算术函数

SQL：

1
2
3

numeric1 + numeric2

POWER(numeric1, numeric2)

Table API：

1
2
3

NUMERIC1 + NUMERIC2

NUMERIC1.power(NUMERIC2)

4.字符串函数

SQL：

string1 || string2

UPPER(string)

CHAR_LENGTH(string)

Table API：

STRING1 + STRING2

STRING.upperCase()

STRING.charLength()

5.时间函数

SQL：

DATE string

TIMESTAMP string

	CURRENT_TIME

INTERVAL string range

Table API：

STRING.toDate

STRING.toTimestamp

currentTime()

NUMERIC.days

NUMERIC.minutes

6.聚合函数

SQL：

COUNT(*)

SUM([ ALL | DISTINCT ] expression)

RANK()

ROW_NUMBER()

Table API：

1
2
3

FIELD.count

FIELD.sum0

UDF

用户定义函数（User-defined Functions，UDF）是一个重要的特性，因为它们显著地扩展了查询（Query）的表达能力。一些系统内置函数无法解决的需求，我们可以用UDF来自定义实现。

注册用户自定义函数UDF

在大多数情况下，用户定义的函数必须先注册，然后才能在查询中使用。不需要专门为Scala 的Table API注册函数。

函数通过调用registerFunction（）方法在TableEnvironment中注册。当用户定义的函数被注册时，它被插入到TableEnvironment的函数目录中，这样Table API或SQL解析器就可以识别并正确地解释它。

标量函数（Scalar Functions）

用户定义的标量函数，可以将0、1或多个标量值，映射到新的标量值。

为了定义标量函数，必须在org.apache.flink.table.functions中扩展基类Scalar Function，并实现（一个或多个）求值（evaluation，eval）方法。标量函数的行为由求值方法决定，求值方法必须公开声明并命名为eval（直接def声明，没有override）。求值方法的参数类型和返回类型，确定了标量函数的参数和返回类型。

在下面的代码中，我们定义自己的HashCode函数，在TableEnvironment中注册它，并在查询中调用它。

// 自定义一个标量函数
public static class HashCode extends ScalarFunction {
    private int factor = 13;

    public HashCode(int factor) {
        this.factor = factor;
    }

    public int eval(String s) {
        return s.hashCode() * factor;
    }
}

主函数中调用，计算sensor id的哈希值（前面部分照抄，流环境、表环境、读取source、建表）：

public static void main(String[] args) throws Exception {
    // 1. 创建环境
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);

    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 2. 读取文件，得到 DataStream
    String filePath = "..\\sensor.txt";

    DataStream<String> inputStream = env.readTextFile(filePath);

    // 3. 转换成 Java Bean，并指定timestamp和watermark
    DataStream<SensorReading> dataStream = inputStream
            .map( line -> {
                String[] fields = line.split(",");
                return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
            } );

    // 4. 将 DataStream 转换为 Table
    Table sensorTable = tableEnv.fromDataStream(dataStream, "id, timestamp as ts, temperature");

    // 5. 调用自定义hash函数，对id进行hash运算
    HashCode hashCode = new HashCode(23);
    tableEnv.registerFunction("hashCode", hashCode);
    Table resultTable = sensorTable
            .select("id, ts, hashCode(id)");

    //  sql
    tableEnv.createTemporaryView("sensor", sensorTable);
    Table resultSqlTable = tableEnv.sqlQuery("select id, ts, hashCode(id) from sensor");

    tableEnv.toAppendStream(resultTable, Row.class).print("result");
    tableEnv.toRetractStream(resultSqlTable, Row.class).print("sql");

    env.execute("scalar function test");
}

表函数（Table Functions）

与用户定义的标量函数类似，用户定义的表函数，可以将0、1或多个标量值作为输入参数；与标量函数不同的是，它可以返回任意数量的行作为输出，而不是单个值。

为了定义一个表函数，必须扩展org.apache.flink.table.functions中的基类TableFunction并实现（一个或多个）求值方法。表函数的行为由其求值方法决定，求值方法必须是public的，并命名为eval。求值方法的参数类型，决定表函数的所有有效参数。

返回表的类型由TableFunction的泛型类型确定。求值方法使用protected collect（T）方法发出输出行。

在Table API中，Table函数需要与.joinLateral或.leftOuterJoinLateral一起使用。

joinLateral算子，会将外部表中的每一行，与表函数（TableFunction，算子的参数是它的表达式）计算得到的所有行连接起来。

而leftOuterJoinLateral算子，则是左外连接，它同样会将外部表中的每一行与表函数计算生成的所有行连接起来；并且，对于表函数返回的是空表的外部行，也要保留下来。

在SQL中，则需要使用Lateral Table（），或者带有ON TRUE条件的左连接。

下面的代码中，我们将定义一个表函数，在表环境中注册它，并在查询中调用它。

自定义TableFunction：

// 自定义TableFunction
public static class Split extends TableFunction<Tuple2<String, Integer>> {
    private String separator = ",";

    public Split(String separator) {
        this.separator = separator;
    }

    // 类似flatmap，没有返回值
    public void eval(String str) {
        for (String s : str.split(separator)) {
            collect(new Tuple2<String, Integer>(s, s.length()));
        }
    }
}

接下来，就是在代码中调用。首先是Table API的方式：

Split split = new Split("_");
tableEnv.registerFunction("split", split);
Table resultTable = sensorTable
        .joinLateral( "split(id) as (word, length)")
        .select("id, ts, word, length");

然后是SQL的方式：

1
2
3

tableEnv.createTemporaryView("sensor", sensorTable);
Table resultSqlTable = tableEnv.sqlQuery("select id, ts, word, length " +
        "from sensor, lateral table( split(id) ) as splitId(word, length)");

聚合函数（Aggregate Functions）

用户自定义聚合函数（User-Defined Aggregate Functions，UDAGGs）可以把一个表中的数据，聚合成一个标量值。用户定义的聚合函数，是通过继承AggregateFunction抽象类实现的。

上图中显示了一个聚合的例子。

假设现在有一张表，包含了各种饮料的数据。该表由三列（id、name和price）、五行组成数据。现在我们需要找到表中所有饮料的最高价格，即执行max（）聚合，结果将是一个数值。

AggregateFunction的工作原理如下。

首先，它需要一个累加器，用来保存聚合中间结果的数据结构（状态）。可以通过调用AggregateFunction的createAccumulator（）方法创建空累加器。
随后，对每个输入行调用函数的accumulate（）方法来更新累加器。
处理完所有行后，将调用函数的getValue（）方法来计算并返回最终结果。

AggregationFunction要求必须实现的方法：

createAccumulator()
accumulate()
getValue()

除了上述方法之外，还有一些可选择实现的方法。其中一些方法，可以让系统执行查询更有效率，而另一些方法，对于某些场景是必需的。例如，如果聚合函数应用在会话窗口（session group window）的上下文中，则merge（）方法是必需的。

retract()
merge()
resetAccumulator()

接下来我们写一个自定义AggregateFunction，计算一下每个sensor的平均温度值.

// 定义AggregateFunction的Accumulator
public static class AvgTempAcc {
    double sum = 0.0;
    int count = 0;
}

// 自定义一个聚合函数，求每个传感器的平均温度值，保存状态(tempSum, tempCount)
public static class AvgTemp extends AggregateFunction<Double, AvgTempAcc>{
    @Override
    public Double getValue(AvgTempAcc accumulator) {
        return accumulator.sum / accumulator.count;
    }

    @Override
    public AvgTempAcc createAccumulator() {
        return new AvgTempAcc();
    }

    // 实现一个具体的处理计算函数，accumulate
    public void accumulate( AvgTempAcc accumulator, Double temp) {
        accumulator.sum += temp;
        accumulator.count += 1;
    }
}

接下来就可以在代码中调用了。

// 创建一个聚合函数实例
AvgTemp avgTemp = new AvgTemp();

// Table API的调用 
tableEnv.registerFunction("avgTemp", avgTemp);
Table resultTable = sensorTable
        .groupBy("id")
        .aggregate("avgTemp(temperature) as avgTemp")
        .select("id, avgTemp");
// sql
tableEnv.createTemporaryView("sensor", sensorTable);
Table resultSqlTable = tableEnv.sqlQuery("select id, avgTemp(temperature) " +
        "from sensor group by id");

tableEnv.toRetractStream(resultTable, Row.class).print("result");
tableEnv.toRetractStream(resultSqlTable, Row.class).print("sql");

表聚合函数（Table Aggregate Functions）

用户定义的表聚合函数（User-Defined Table Aggregate Functions，UDTAGGs），可以把一个表中数据，聚合为具有多行和多列的结果表。这跟AggregateFunction非常类似，只是之前聚合结果是一个标量值，现在变成了一张表。

比如现在我们需要找到表中所有饮料的前2个最高价格，即执行top2（）表聚合。我们需要检查5行中的每一行，得到的结果将是一个具有排序后前2个值的表。

用户定义的表聚合函数，是通过继承TableAggregateFunction抽象类来实现的。

TableAggregateFunction的工作原理如下。

首先，它同样需要一个累加器（Accumulator），它是保存聚合中间结果的数据结构。通过调用TableAggregateFunction的createAccumulator（）方法可以创建空累加器。
随后，对每个输入行调用函数的accumulate（）方法来更新累加器。
处理完所有行后，将调用函数的emitValue（）方法来计算并返回最终结果。

AggregationFunction要求必须实现的方法：

createAccumulator()
accumulate()

除了上述方法之外，还有一些可选择实现的方法。

retract()
merge()
resetAccumulator()
emitValue()
emitUpdateWithRetract()

接下来我们写一个自定义TableAggregateFunction，用来提取每个sensor最高的两个温度值。

// 先定义一个 Accumulator 
public static class Top2TempAcc {
    double highestTemp = Double.MIN_VALUE;
    double secondHighestTemp = Double.MIN_VALUE;
}

// 自定义表聚合函数
public static class Top2Temp extends TableAggregateFunction<Tuple2<Double, Integer>, Top2TempAcc> {
    @Override
    public Top2TempAcc createAccumulator() {
        return new Top2TempAcc();
    }

    // 实现计算聚合结果的函数accumulate
    public void accumulate(Top2TempAcc acc, Double temp) {
        if (temp > acc.highestTemp) {
            acc.secondHighestTemp = acc.highestTemp;
            acc.highestTemp = temp;
        } else if (temp > acc.secondHighestTemp) {
            acc.secondHighestTemp = temp;
        }
    }
    // 实现一个输出结果的方法，最终处理完表中所有数据时调用
    public void emitValue(Top2TempAcc acc, Collector<Tuple2<Double, Integer>> out) {
        out.collect(new Tuple2<>(acc.highestTemp, 1));
        out.collect(new Tuple2<>(acc.secondHighestTemp, 2));
    }
}

接下来就可以在代码中调用了。

// 创建一个表聚合函数实例
Top2Temp top2Temp = new Top2Temp();
tableEnv.registerFunction("top2Temp", top2Temp);
Table resultTable = sensorTable
        .groupBy("id")
        .flatAggregate("top2Temp(temperature) as (temp, rank)")
        .select("id, temp, rank");

tableEnv.toRetractStream(resultTable, Row.class).print("result");

本文作者： xubatian
本文链接： http://xubatian.cn/Flink-原理与实现-FlinkSQL的Table-API-与SQL之函数（Functions）/
版权声明： 本博客所有文章除特别声明外均为原创，采用 CC BY 4.0 CN协议许可协议。转载请注明出处:https://www.xubatian.cn/