Flink 函数(Functions)

最新推荐文章于 2023-07-18 17:53:17 发布
最新推荐文章于 2023-07-18 17:53:17 发布
阅读量726 收藏 1
点赞数
分类专栏： Flink java集合 文章标签： flink 大数据 big data
原文链接：https://ashiamd.github.io/
版权

Flink-函数 | 用户自定义函数（UDF）标量函数 | 表函数 | 聚合函数 | 表聚合函数

在这里插入图片描述

 在这里插入图片描述

用户自定义函数(UDF)

  • 用户定义函数（User-defined Functions，UDF）是一个重要的特性，它们显著地扩展了查询的表达能力

    一些系统内置函数无法解决的需求，我们可以用UDF来自定义实现

  • 在大多数情况下，用户定义的函数必须先注册，然后才能在查询中使用

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

标量函数(Scalar Functions)

Scalar Funcion类似于map，一对一

Table Function类似flatMap，一对多

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

  • 为了定义标量函数，必须在 org.apache.flink.table.functions 中扩展基类Scalar Function，并实现（一个或多个）求值（eval）方法

  • 标量函数的行为由求值方法决定，求值方法必须public公开声明并命名为 eval

    public static class HashCode extends ScalarFunction {

  private int factor = 13;

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

  public int eval(String id) {
    return id.hashCode() * 13;
  }
}

测试代码

package apitest.tableapi.udf;

import apitest.beans.SensorReading;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.functions.ScalarFunction;
import org.apache.flink.types.Row;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/4 3:28 AM
 */
public class UdfTest1_ScalarFunction {
  public static void main(String[] args) throws Exception {
    // 创建执行环境
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    // 并行度设置为1
    env.setParallelism(1);

    // 创建Table执行环境
    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 1. 读取数据
    DataStream<String> inputStream = env.readTextFile("/tmp/Flink_Tutorial/src/main/resources/sensor.txt");

    // 2. 转换成POJO
    DataStream<SensorReading> dataStream = inputStream.map(line -> {
      String[] fields = line.split(",");
      return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
    });

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

    // 4. 自定义标量函数，实现求id的hash值
    HashCode hashCode = new HashCode(23);
    // 注册UDF
    tableEnv.registerFunction("hashCode", hashCode);

    // 4.1 table API
    Table resultTable = sensorTable.select("id, ts, hashCode(id)");

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

    // 打印输出
    tableEnv.toAppendStream(resultTable, Row.class).print();
    tableEnv.toAppendStream(resultSqlTable, Row.class).print();

    env.execute();
  }

  public static class HashCode extends ScalarFunction {

    private int factor = 13;

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

    public int eval(String id) {
      return id.hashCode() * 13;
    }
  }
}

输出结果

sensor_1,1547718199,-772373508
sensor_1,1547718199,-772373508
sensor_6,1547718201,-772373443
sensor_6,1547718201,-772373443
sensor_7,1547718202,-772373430
sensor_7,1547718202,-772373430
sensor_10,1547718205,1826225652
sensor_10,1547718205,1826225652
sensor_1,1547718207,-772373508
sensor_1,1547718207,-772373508
sensor_1,1547718209,-772373508
sensor_1,1547718209,-772373508
sensor_1,1547718212,-772373508
sensor_1,1547718212,-772373508

表函数(Table Fcuntions)

Scalar Funcion类似于map，一对一

Table Function类似flatMap，一对多

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

  • 为了定义一个表函数，必须扩展 org.apache.flink.table.functions 中的基类 TableFunction 并实现（一个或多个）求值方法

  • 表函数的行为由其求值方法决定，求值方法必须是 public 的，并命名为 eval

    public static class Split extends TableFunction<Tuple2<String, Integer>> {

  // 定义属性，分隔符
  private String separator = ",";

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

  public void eval(String str) {
    for (String s : str.split(separator)) {
      collect(new Tuple2<>(s, s.length()));
    }
  }
}

测试代码

package apitest.tableapi.udf;

import apitest.beans.SensorReading;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.functions.TableFunction;
import org.apache.flink.types.Row;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/4 3:58 AM
 */
public class UdfTest2_TableFunction {
  public static void main(String[] args) throws Exception {
    // 创建执行环境
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    // 并行度设置为1
    env.setParallelism(1);

    // 创建Table执行环境
    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 1. 读取数据
    DataStream<String> inputStream = env.readTextFile("/tmp/Flink_Tutorial/src/main/resources/sensor.txt");

    // 2. 转换成POJO
    DataStream<SensorReading> dataStream = inputStream.map(line -> {
      String[] fields = line.split(",");
      return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
    });

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

    // 4. 自定义表函数，实现将id拆分，并输出（word, length）
    Split split = new Split("_");
    // 需要在环境中注册UDF
    tableEnv.registerFunction("split", split);

    // 4.1 table API
    Table resultTable = sensorTable
      .joinLateral("split(id) as (word, length)")
      .select("id, ts, word, length");

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

    // 打印输出
    tableEnv.toAppendStream(resultTable, Row.class).print("result");
    tableEnv.toAppendStream(resultSqlTable, Row.class).print("sql");

    env.execute();
  }

  // 实现自定义 Table Function
  public static class Split extends TableFunction<Tuple2<String, Integer>> {

    // 定义属性，分隔符
    private String separator = ",";

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

    public void eval(String str) {
      for (String s : str.split(separator)) {
        collect(new Tuple2<>(s, s.length()));
      }
    }
  }
}

输出结果

result> sensor_1,1547718199,sensor,6
result> sensor_1,1547718199,1,1
sql> sensor_1,1547718199,sensor,6
sql> sensor_1,1547718199,1,1
result> sensor_6,1547718201,sensor,6
result> sensor_6,1547718201,6,1
sql> sensor_6,1547718201,sensor,6
sql> sensor_6,1547718201,6,1
result> sensor_7,1547718202,sensor,6
result> sensor_7,1547718202,7,1
sql> sensor_7,1547718202,sensor,6
sql> sensor_7,1547718202,7,1
result> sensor_10,1547718205,sensor,6
result> sensor_10,1547718205,10,2
sql> sensor_10,1547718205,sensor,6
sql> sensor_10,1547718205,10,2
result> sensor_1,1547718207,sensor,6
result> sensor_1,1547718207,1,1
sql> sensor_1,1547718207,sensor,6
sql> sensor_1,1547718207,1,1
result> sensor_1,1547718209,sensor,6
result> sensor_1,1547718209,1,1
sql> sensor_1,1547718209,sensor,6
sql> sensor_1,1547718209,1,1
result> sensor_1,1547718212,sensor,6
result> sensor_1,1547718212,1,1
sql> sensor_1,1547718212,sensor,6
sql> sensor_1,1547718212,1,1

聚合函数(Aggregate Functions)

聚合，多对一，类似前面的窗口聚合

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

在这里插入图片描述

  • AggregationFunction要求必须实现的方法
    • createAccumulator()
    • accumulate()
    • getValue()
  • AggregateFunction 的工作原理如下：
    • 首先，它需要一个累加器（Accumulator），用来保存聚合中间结果的数据结构；可以通过调用 createAccumulator() 方法创建空累加器
    • 随后，对每个输入行调用函数的 accumulate() 方法来更新累加器
    • 处理完所有行后，将调用函数的 getValue() 方法来计算并返回最终结果

测试代码

package apitest.tableapi.udf;

import apitest.beans.SensorReading;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.streaming.api.datastream.DataStream;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.Table;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.functions.AggregateFunction;
import org.apache.flink.types.Row;

/**
 * @author : Ashiamd email: ashiamd@foxmail.com
 * @date : 2021/2/4 4:24 AM
 */
public class UdfTest3_AggregateFunction {
  public static void main(String[] args) throws Exception {
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    env.setParallelism(1);

    StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);

    // 1. 读取数据
    DataStream<String> inputStream = env.readTextFile("/tmp/Flink_Tutorial/src/main/resources/sensor.txt");

    // 2. 转换成POJO
    DataStream<SensorReading> dataStream = inputStream.map(line -> {
      String[] fields = line.split(",");
      return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));
    });

    // 3. 将流转换成表
    Table sensorTable = tableEnv.fromDataStream(dataStream, "id, timestamp as ts, temperature as temp");

    // 4. 自定义聚合函数，求当前传感器的平均温度值
    // 4.1 table API
    AvgTemp avgTemp = new AvgTemp();

    // 需要在环境中注册UDF
    tableEnv.registerFunction("avgTemp", avgTemp);
    Table resultTable = sensorTable
      .groupBy("id")
      .aggregate("avgTemp(temp) as avgtemp")
      .select("id, avgtemp");

    // 4.2 SQL
    tableEnv.createTemporaryView("sensor", sensorTable);
    Table resultSqlTable = tableEnv.sqlQuery("select id, avgTemp(temp) " +
                                             " from sensor group by id");

    // 打印输出
    tableEnv.toRetractStream(resultTable, Row.class).print("result");
    tableEnv.toRetractStream(resultSqlTable, Row.class).print("sql");

    env.execute();
  }

  // 实现自定义的AggregateFunction
  public static class AvgTemp extends AggregateFunction<Double, Tuple2<Double, Integer>> {
    @Override
    public Double getValue(Tuple2<Double, Integer> accumulator) {
      return accumulator.f0 / accumulator.f1;
    }

    @Override
    public Tuple2<Double, Integer> createAccumulator() {
      return new Tuple2<>(0.0, 0);
    }

    // 必须实现一个accumulate方法，来数据之后更新状态
    // 这里方法名必须是这个，且必须public。
    // 累加器参数，必须得是第一个参数；随后的才是我们自己传的入参
    public void accumulate(Tuple2<Double, Integer> accumulator, Double temp) {
      accumulator.f0 += temp;
      accumulator.f1 += 1;
    }
  }
}

输出结果：

result> (true,sensor_1,35.8)
result> (true,sensor_6,15.4)
result> (true,sensor_7,6.7)
result> (true,sensor_10,38.1)
result> (false,sensor_1,35.8)
result> (true,sensor_1,36.05)
sql> (true,sensor_1,35.8)
result> (false,sensor_1,36.05)
sql> (true,sensor_6,15.4)
result> (true,sensor_1,34.96666666666666)
sql> (true,sensor_7,6.7)
result> (false,sensor_1,34.96666666666666)
sql> (true,sensor_10,38.1)
result> (true,sensor_1,35.5)
sql> (false,sensor_1,35.8)
sql> (true,sensor_1,36.05)
sql> (false,sensor_1,36.05)
sql> (true,sensor_1,34.96666666666666)
sql> (false,sensor_1,34.96666666666666)
sql> (true,sensor_1,35.5)

 表聚合函数

  • 用户定义的表聚合函数（User-Defined Table Aggregate Functions，UDTAGGs），可以把一个表中数据，聚合为具有多行和多列的结果表
  • 用户定义表聚合函数，是通过继承 TableAggregateFunction 抽象类来实现的

在这里插入图片描述

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

测试代码

Flink-函数 | 用户自定义函数（UDF）标量函数 | 表函数 | 聚合函数 | 表聚合函数

import com.atguigu.bean.SensorReading
import org.apache.flink.streaming.api.TimeCharacteristic
import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor
import org.apache.flink.streaming.api.scala._
import org.apache.flink.streaming.api.windowing.time.Time
import org.apache.flink.table.api.Table
import org.apache.flink.table.api.scala._
import org.apache.flink.table.functions.TableAggregateFunction
import org.apache.flink.types.Row
import org.apache.flink.util.Collector

object TableAggregateFunctionTest {
  def main(args: Array[String]): Unit = {

    val env: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    env.setParallelism(1)

    // 开启事件时间语义
    env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime)

    // 创建表环境
    val tableEnv: StreamTableEnvironment = StreamTableEnvironment.create(env)

    val inputDStream: DataStream[String] = env.readTextFile("D:\\MyWork\\WorkSpaceIDEA\\flink-tutorial\\src\\main\\resources\\SensorReading.txt")

    val dataDStream: DataStream[SensorReading] = inputDStream.map(
      data => {
        val dataArray: Array[String] = data.split(",")
        SensorReading(dataArray(0), dataArray(1).toLong, dataArray(2).toDouble)
      })
    .assignTimestampsAndWatermarks( new BoundedOutOfOrdernessTimestampExtractor[SensorReading]
                                   ( Time.seconds(1) ) {
                                     override def extractTimestamp(element: SensorReading): Long = element.timestamp * 1000L
                                   } )

    // 用proctime定义处理时间
    val dataTable: Table = tableEnv
    .fromDataStream(dataDStream, 'id, 'temperature, 'timestamp.rowtime as 'ts)

    // 使用自定义的hash函数，求id的哈希值
    val myAggTabTemp = MyAggTabTemp()

    // 查询 Table API 方式
    val resultTable: Table = dataTable
    .groupBy('id)
    .flatAggregate( myAggTabTemp('temperature) as ('temp, 'rank) )
    .select('id, 'temp, 'rank)


    // SQL调用方式，首先要注册表
    tableEnv.createTemporaryView("dataTable", dataTable)
    // 注册函数
    tableEnv.registerFunction("myAggTabTemp", myAggTabTemp)

    /*
    val resultSqlTable: Table = tableEnv.sqlQuery(
      """
        |select id, temp, `rank`
        |from dataTable, lateral table(myAggTabTemp(temperature)) as aggtab(temp, `rank`)
        |group by id
        |""".stripMargin)
*/


    // 测试输出
    resultTable.toRetractStream[ Row ].print( "scalar" )
    //resultSqlTable.toAppendStream[ Row ].print( "scalar_sql" )
    // 查看表结构
    dataTable.printSchema()

    env.execute(" table ProcessingTime test job")
  }
}

// 自定义状态类
case class AggTabTempAcc() {
  var highestTemp: Double = Double.MinValue
  var secondHighestTemp: Double = Double.MinValue
}

case class MyAggTabTemp() extends TableAggregateFunction[(Double, Int), AggTabTempAcc]{
  // 初始化状态
  override def createAccumulator(): AggTabTempAcc = new AggTabTempAcc()

  // 每来一个数据后，聚合计算的操作
  def accumulate( acc: AggTabTempAcc, temp: Double ): Unit ={
    // 将当前温度值，跟状态中的最高温和第二高温比较，如果大的话就替换
    if( temp > acc.highestTemp ){
      // 如果比最高温还高，就排第一，其它温度依次后移
      acc.secondHighestTemp = acc.highestTemp
      acc.highestTemp = temp
    } else if( temp > acc.secondHighestTemp ){
      acc.secondHighestTemp = temp
    }
  }

  // 实现一个输出数据的方法，写入结果表中
  def emitValue( acc: AggTabTempAcc, out: Collector[(Double, Int)] ): Unit ={
    out.collect((acc.highestTemp, 1))
    out.collect((acc.secondHighestTemp, 2))
  }
}

taco詹詹
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Flink处理函数（ProcessFunction、KeyedProcessFunction、ProcessWindowFunction、 ProcessAllWindowFunction）
roi666的博客
01-23 1342
/定义一小时窗口@Overridecount++;
Flink 函数（function）
weixin_45903673的博客
07-26 1446
在Flink中函数的使用，Flink为用户提供了许多内置函数 如果这些函数还满足不了你的需求，还可以自定义函数 内置函数 比较函数 比较功能 描述 value1 = value2 如果value1等于value2，则返回 TRUE ；如果value1或value2为 NULL，则返回 UNKNOWN 。 用户自定义函数 ...
flink UDF（User-defined Functions）
newbrid007的博客
06-18 828
flink 自定义函数学习记录
Flink教程(20) 窗口函数 ReduceFunction AggregateFunction ProcessWindowFunction 结合使用
Java Spring Elasticsearch
03-31 6184
ReduceFunction AggregateFunction ProcessWindowFunction 结合使用一、窗口函数的分类1. 全量和增量的区别2. apply和process的区别3. reduce和aggregate的区别二、AggregateFunction和ProcessWindowFunction结合使用1. 需求背景2. 分析3. 程序主体4. AggregateFunction5. ProcessWindowFunction 一、窗口函数的分类 大多数Flink应用都是要划分窗口
FlinkSQL 自定义函数详解
qq_43732592的博客
07-18 1075
Flinksql 自定义函数
Flink-处理函数
m0_63475429的博客
10-16 1232
在处理函数中，我们直面的就是数据流中最基本的元素：数据事件（event）、状态（state） 以及时间（time）。这就相当于对流有了完全的控制权。处理函数比较抽象，没有具体的操作， 所以对于一些常见的简单应用（比如求和、开窗口）会显得有些麻烦；不过正是因为它不限定 具体做什么，所以理论上我们可以做任何事情，实现所有需求。所以可以说，处理函数是我们 进行 Flink 编程的“大招”，轻易不用，一旦放出来必然会扫平一切。
【FlinkSql篇05】FlinkSql之函数1
08-04
同时，对于系统内建函数无法满足的需求，Flink还支持用户定义函数（User-defined Functions，UDF），从而实现更灵活的数据转换。 1. 比较函数：在SQL中，比较函数包括等于（=）、大于（>）等操作，如`value1 = ...
flink动态业务规则
08-18
2. **User-Defined Functions (UDFs)**：用户可以编写自定义函数来实现特定的业务逻辑，包括规则。当规则变更时，可以替换或更新 UDF 实现，然后重新部署作业。 3. **State Processor API**：Flink 提供的 API 允许...
flink安装包以及wordcount
最新发布
02-03
import org.apache.flink.api.common.functions.FlatMapFunction; import org.apache.flink.api.java.tuple.Tuple2; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink....
【Flink篇05】FlinkAPI之数据类型和UDF函数 1
08-04
- **富函数（Rich Functions）**：这是Flink提供的一个特殊的函数接口，它允许开发者访问运行时环境的上下文并提供一些生命周期方法，如`open()`和`close()`，以便在函数的整个生命周期中执行额外的初始化或清理工作...
flink写入es带有用户名密码
12-23
import org.apache.flink.api.common.functions.RuntimeContext; import org.apache.flink.shaded.elasticsearch7.org.elasticsearch.action.index.IndexRequest; import org.apache.flink.shaded.elasticsearch7....
Flink 窗口函数（Window Functions）全窗口函数
weixin_45417821的博客
04-17 2868
文章目录1）窗口函数（WindowFunction）2）处理窗口函数（ProcessWindowFunction） 窗口操作中的另一大类就是全窗口函数。与增量聚合函数不同，全窗口函数需要先收集窗口中的数据，并在内部缓存起来，等到窗口要输出结果的时候再取出数据进行计算。 很明显，这就是典型的批处理思路了— —先攒数据，等一批都到齐了再正式启动处理流程。这样做毫无疑问是低效的：因为窗口全部的计算任务都积压在了要输出结果的那一瞬间，而在之前收集数据的漫长过程中却无所事事。这就好比平时不用功，到考试之前通宵抱佛脚，
Flink1.8实时电商运营项目实战
08-26
《Flink1.8实时电商运营项目实战》基于某电商公司运营实时分析系统（2B），对Flink DataStream进行全面系统的讲解。通过本课程的学习，既能获得Flink企业级真实项目经验，也能深入掌握Flink DataStream的核心理论知识，从而快速、深入掌握Flink技术。  适用人群 1.有一定Java/Scala基础的学员2.对大数据感兴趣的学员课程目标 1.近12小时Flink项目实战课 2.一套完整的Flink实时项目源码 3.获得3年Flink项目实战经验
Flink1.8实时数仓项目实战
08-26
《Flink1.8实时数仓项目实战》课程主要基于Flink**稳定版本进行讲解，课程包含Flink DataSet、容错、Connector、Flink SQL以及实时数仓项目。希望通过本课程的学习，大家能快速掌握Flink 批处理和Flink SQL，并通过实时数仓项目快速积累项目经验。
函数吗 jsp_Flink | 你真的理解Stateful Function吗？
weixin_39695241的博客
01-13 765
Flink必备 | Stateful Function介绍Flink将Stateful Function放在这样的位置，可想而知，有状态函数在Flink中地位可以说是相当重要，我们毫不夸张的说，它一定是Flink的核心。有状态的函数说到函数，很久以前，我们写的C语言程序里面就有函数的概念。我们使用函数可以进行输入输出数据处理。在C语言中，可以在函数中定义一种static类型的变量。例如以下：#in...
Flink: Function And Rich Function
难得糊涂
10-26 1275
序言 了解了Flink提供的算子,那我们就可以自定义算子了.自定义算子的目的是为了更加灵活的处理我们的业务数据,并将满足条件的结果Sink到目标存储地cuiyaonan2000@163.com Function有2中类型即 Function 和 Rich Function .从字面意思我们可以了解 Rich Function 肯定是比Function提供了更多的功能的. 参考版本为: v1.13.2 官网地址:用户自定义 Functions | Apache Flink...
Flink中Table API和SQL（四）
JiaXingNashishua的博客
10-04 1361
系统函数尽管庞大，也不可能涵盖所有的功能；如果有系统函数不支持的需求，我们就需要用自定义函数（，UDF）来实现了。事实上，系统内置函数仍然在不断扩充，如果我们认为自己实现的自定义函数足够通用、应用非常广泛，也可以在项目跟踪工 具 JIRA 上向 Flink 开发团队提出“议题”（issue），请求将新的函数添加到系统函数中。Flink 的 Table API 和 SQL 提供了多种自定义函数的接口，以抽象类的形式定义。
Flink实战- （8）Flink UDF实现数据脱敏
Carson073的博客
05-31 752
在Flink环境实现数据实时同步的过程中，需要对某些字段进行脱敏处理或者特殊处理，这是需要自己定义UDF函数进行转换。
Flink StateFunction：集成了Flink和FaaS的流处理优点
微信搜：import_bigdata，大数据领域硬核原创作者
10-13 875
点击上方蓝色字体，选择“设为星标”回复”资源“获取更多资源大数据技术与架构点击右侧关注，大数据开发领域最强公众号！大数据真好玩点击右侧关注，大数据真好玩！近日，有状态函数（Statefu...
Flink Window Functions 增量聚合函数 ReduceFunction AggregateFunction 全量窗口函数 ProcessWindowFunction
05-14
Flink Window Functions 是在流数据处理中使用的一种函数，可以对数据流中的数据进行窗口操作，例如按照时间窗口或者数量窗口对数据进行分组、聚合等操作。常见的 Flink Window Functions 有以下几种： 1. 增量聚合...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值