Flink - Table API 之 window (窗口)

窗口

  • 时间语义,要配合窗口操作才能发挥作用
  • 在Table API 和 SQL 中,主要有两种窗口

Group Window(分组窗口)

  • 根据时间或行计数间隔,将行聚合到有限的组(Group)中,并对每个组的数据执行一次聚合函数

Over Windows

  • 针对每个输入行,计算相邻范围内的聚合

Group Windows

  • Group Windows是使用window(w:GroupWindows)子句定义的,并且必须由as子句指定一个别名

  • 为了按窗口对表进行分组,窗口的别名必须在group by子句中,像常规的分组字段一样引用

    Table table = input
    	.window(w:GroupWindow] as "w") //定义窗口,别名为"w"
    	.groupBy("w","a")  // 按照字段a和窗口w分组
    	.select("a,b.sum"); // 聚合
    
  • Table API 提供了一组具有特定语义的预定义Window类,这些类会被转换为底层DataStream或DataSet的窗口操作

滚动窗口(Tumbling windows)

  • 滚动窗口要用Tunble类来定义

    //Tumbling Event-time Window
    .window(Tumble.over("10.minutes").on("rowtime").as("w"))
    
    // Tumbling Processing-tiem Window
    .window(Tumble.over("10.minutes").on("proctime").as("w"))
    
    // Tumbling Row-count Window
    .window(Tumble.over("10.rows").on("proctime").as("w"))
    

滑动窗口(Sliding windows)

  • 滑动窗口要用Slide类来定义

    //Sliding Event-time Window
    .window(Slide.over("10.minutes").every("5.minutes").on("rowtime").as("w"))
    
    // Sliding Processing-tiem Window
    .window(Slide.over("10.minutes").every("5.minutes").on("proctime").as("w"))
    
    // Sliding Row-count Window
    .window(Slide.over("10.rows").every("5.rows").on("proctime").as("w"))
    

会话窗口 (Session Window)

  • 会话窗口要用Session类来定义

    // Session Event-time window
    .window(Session.withGap("10.minutes").on("rowtime").as("w"))
    
    // Session Processing-time window
    .window(Session.withGap("10.minutes").on("proctime").as("w"))
    

SQL中的Group Windows

  • Group Windows定义在SQL查询的Group By子句中

    TUMBLE(time_attr,interval)

    • 定义一个滚动窗口,第一个参数是时间字段,第二个参数是窗口字段

    HOP(time_attr,interval,interval)

    • 定义一个滑动窗口,第一个参数是时间字段,第二个参数是窗口滑动步长,第三是窗口长度

    SESSION(time_attr,interval)

    • 定义一个会话窗口,第一个参数是时间字段,第二个参数是窗口间隔。
  • 案例代码

    public static void main(String[] args) throws Exception {
           
            StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    
            env.setParallelism(1);
    
            DataStream<String> fileDataStream = env.readTextFile("data/temps.txt");
    
    
            DataStream<TempInfo> dataStream = fileDataStream.map(new MapFunction<String, TempInfo>() {
           
                @Override
                public TempInfo map(String value) throws Exception {
           
                    String[] split = value.split(",");
                    return new TempInfo(split[0], new Long(split[1]), new Double(split[2]));
                }
            }).assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<TempInfo>(Time.seconds(1)) {
           
                @Override
                public long extractTimestamp(TempInfo element) {
           
                    return element.getTimeStamp() * 1000L;
                }
            });
    
            StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env);
    
            //Table dataTable = tableEnv.fromDataStream(dataStream, "id, timeStamp.rowtime as ts , temp, pt.proctime");
    
            //Table dataTable = tableEnv.fromDataStream(dataStream, "id, timeStamp.rowtime as ts , temp, rt.rowtime");
            Table dataTable = tableEnv.fromDataStream(dataStream,"id, timeStamp as ts, temp, rt.rowtime");
            
            // 构建视图
            tableEnv.createTemporaryView("sensor",dataTable);
    
    
            // 窗口操作
            // 1. Group Window
            // table API
            Table resTable = dataTable.window(Tumble.over("10.seconds").on("rt").as("tw"))
                    .groupBy("id,tw")
                    .select("id, id.count, temp.avg");
    
            // SQL
           Table resSqlTable = tableEnv.sqlQuery("SELECT id, count(id) as cnt, avg(temp) as avgTemp, tumble_end(rt,interval '10' second)" +
                    "from sensor group by id, tumble(rt,interval '10' second) ");
    
    
    
            // 2. Over Window
            // table API
            Table overTable = dataTable.window(Over.partitionBy("id").orderBy("rt").preceding("2.rows").as("ow"))
                    .select("id, rt, id.count over ow,temp.avg over ow");
    
            // SQL
            tableEnv.sqlQuery("select id, rt, count(id) over ow, avg(temp) over ow "+
                    " from sensor "+
                    " window ow as (partition by id order by rt rows between 2 preceding and current row)");
    
    
    
            tableEnv.toAppendStream(resTable, Row.class).print("group window");
            tableEnv.toAppendStream(resSqlTable, Row.class).print("resSqlTable");
            tableEnv.toRetractStream(overTable,Row.class).print("over window");
    
            env.execute();
        }
    

Over Windows

  • Over window聚合是标准SQL中已有的(over子句),可以在查询的SELECT 子句中定义

  • Over window聚合,会针对每个输入行,计算相邻行范围内的聚合

  • Over windows使用window(w:overwindows*)子句定义,并在select()方法中通过别名来引用

    Table table = input
    	.window([w:OverWindow] as "w")
    	.select("a, b.sum over w, c.min over w");
    
  • Table API 提供了Over类,来配置Over窗口的属性

无界 Over Windows

  • 可以在事件时间或处理时间,以及指定为时间间隔,或行计数的范围内,定义Over windows
  • 无界的over windows 是使用常量指定的
// 无界的事件时间 over window
.window(Over.partitionBy("a").orderBy("rowtime").preceding(UNBOUNDED_RANGE).as("w"))

// 无界的处理时间 over window
.window(Over.partitionBy("a").orderBy("proctime").preceding(UNBOUNDED_RANGE).as("w"))

// 无界的事件时间 Row-count over window
.window(Over.partitionBy("a").orderBy("rowtime").preceding(UNBOUNDED_ROW).as("w"))

// 无界的处理时间 Row-count over window
.window(Over.partitionBy("a").orderBy("proctime").preceding(UNBOUNDED_ROW).as("w"))

有界 Over Windows

  • 有界的over window 是用间隔的大小指定的
// 有界的事件时间over window
.window(Over.partitionBy("a").orderBy("rowtime").preceding("1.minutes").as("w"))

// 有界的处理时间 over window
.window(Over.partitionBy("a").orderBy("proctime").preceding("1.minutes").as("w"))

// 有界的事件时间 Row-count over window
.window(Over.partitionBy("a").orderBy("rowtime").preceding("10.rows").as("w"))

// 有届的处理时间 Row-count over window
.window(Over.partitionBy("a").orderBy("proctime").preceding("10.rows").as("w"))

SQL中的Over Windows

  • 用Over做窗口聚合时,所有聚合必须在同一个窗口上定义,也就是说必须是相同的分区,排序和范围

  • 目前仅支持在当前行范围之前的窗口

  • ORDER BY 必须在单一的时间属性上指定

    SELECT COUNT(amount) OVER(
    	PARTITION BY user
    	ORDER BY proctime
    	ROWS BETWEEN 2 PRECEDING AND CURRENT ROW)
    FROM Orders
    

你可能感兴趣的:(flink,flink)