37.DataSet API之Transformations

原文链接： https://ci.apache.org/projects/flink/flink-docs-release-1.8/dev/batch/dataset_transformations.html

flink 1.8

 

数据集转换DataSet Transformations

本文档深入研究了数据集上可用的转换。有关Flink Java API的一般介绍，请参阅编程指南 Programming Guide。

有关在具有密集索引的数据集中压缩元素，请参阅 Zip Elements Guide。

 

Map

Map转换在DataSet的每个元素上应用用户定义的map函数。它实现了一对一的映射，也就是说，函数必须返回一个元素。

以下代码将Integer对的DataSet转换为Integers的DataSet：

// MapFunction that adds two integer values
public class IntAdder implements MapFunction, Integer> {
  @Override
  public Integer map(Tuple2 in) {
    return in.f0 + in.f1;
  }
}

// [...]
DataSet> intPairs = // [...]
DataSet intSums = intPairs.map(new IntAdder());

FlatMap

FlatMap转换在DataSet的每个元素上应用用户定义的 flat-map函数。map函数的这种变体可以为每个输入数据元返回任意多个结果元素（包括none）。

以下代码将文本行的DataSet转换为单词的DataSet： 

// FlatMapFunction that tokenizes a String by whitespace characters and emits all String tokens.
public class Tokenizer implements FlatMapFunction {
  @Override
  public void flatMap(String value, Collector out) {
    for (String token : value.split("\\W")) {
      out.collect(token);
    }
  }
}

// [...]
DataSet textLines = // [...]
DataSet words = textLines.flatMap(new Tokenizer());

MapPartition

MapPartition在单个函数调用中转换一个并行分区。map-partition函数将分区作为Iterable获取，并且可以生成任意数量的结果值。每个分区中的元素数量取决于并行度和先前的算子操作。

以下代码将文本行DataSet数据集转换为每个分区的计数数据集 

public class PartitionCounter implements MapPartitionFunction {

  public void mapPartition(Iterable values, Collector out) {
    long c = 0;
    for (String s : values) {
      c++;
    }
    out.collect(c);
  }
}

// [...]
DataSet textLines = // [...]
DataSet counts = textLines.mapPartition(new PartitionCounter());

Filter

Filter转换在DataSet的每个元素上应用用户定义的过滤器函数，并仅保存函数返回true的元素。

以下代码从DataSet中删除所有小于零的整数：

// FilterFunction that filters out all Integers smaller than zero.
public class NaturalNumberFilter implements FilterFunction {
  @Override
  public boolean filter(Integer number) {
    return number >= 0;
  }
}

// [...]
DataSet intNumbers = // [...]
DataSet naturalNumbers = intNumbers.filter(new NaturalNumberFilter());

 重要提示:系统假设函数不会修改应用谓词的元素。违反这一假设可能导致不正确的结果。

 

元组数据集的Projection

Project转换删除或移动元组DataSet的Tuple字段。该project(int...)方法选择应由其索引保存的元组字段，并在输出元组中定义它们的顺序。

预测不需要定义用户函数。

以下代码显示了在DataSet上应用项目转换的不同方法：

DataSet> in = // [...]
// converts Tuple3 into Tuple2
DataSet> out = in.project(2,0);

使用类型提示进行Projection

请注意，Java编译器无法推断project 算子的返回类型。如果您使用一个操作算子的结果调用另一个算子，则可能会导致问题，project例如：

DataSet> ds = ....
DataSet> ds2 = ds.project(0).distinct(0);

通过提示返回类型的project 算子可以克服此问题，如下所示：

DataSet> ds2 = ds.>project(0).distinct(0);

分组数据集的转换

reduce操作可以对分组的数据集进行操作。可以通过多种方式指定分组使用的key:

• key值表达式
• key值选择器key-selector函数
• 一个或多个字段位置键key（仅限元组数据集）
• case类字段（仅限scala的case类）

请查看reduce示例，了解如何指定分组键。

 

Reduce分组数据集

应用于分组数据集的Reduce转换使用用户定义的Reduce函数将每个组简化为单个元素。对于每组输入元素，reduce函数依次将一对元素组合成一个元素，直到每组只剩下一个元素为止（Reduce做聚合的）。

注意，对于ReduceFunction，返回对象的键字段应该匹配输入值。这是因为reduce是隐式组合的，当传递给reduce操作符时，从combine操作符发出的对象再次按键分组。

 

Reduce由键表达式分组的DataSet

key表达式指定数据集每个元素的一个或多个字段。每个键表达式要么是公共字段的名称，要么是getter方法的名称。点可用于向下钻取对象。key表达式“*”选择所有字段。下面的代码展示了如何使用key表达式对POJO数据集进行分组，并使用reduce函数对其进行聚合。

// some ordinary POJO
public class WC {
  public String word;
  public int count;
  // [...]
}

// ReduceFunction that sums Integer attributes of a POJO
public class WordCounter implements ReduceFunction {
  @Override
  public WC reduce(WC in1, WC in2) {
    return new WC(in1.word, in1.count + in2.count);
  }
}

// [...]
DataSet words = // [...]
DataSet wordCounts = words
                         // DataSet grouping on field "word"
                         .groupBy("word")
                         // apply ReduceFunction on grouped DataSet
                         .reduce(new WordCounter());

Reduce由KeySelector函数分组的DataSet

key选择器函数从数据集的每个元素中提取键值key。提取的键值key用于对数据集进行分组。下面的代码展示了如何使用键选择器函数对POJO数据集进行分组，并使用reduce函数对其进行聚合。

 

// some ordinary POJO
public class WC {
  public String word;
  public int count;
  // [...]
}

// ReduceFunction that sums Integer attributes of a POJO
public class WordCounter implements ReduceFunction {
  @Override
  public WC reduce(WC in1, WC in2) {
    return new WC(in1.word, in1.count + in2.count);
  }
}

// [...]
DataSet words = // [...]
DataSet wordCounts = words
                         // DataSet grouping on field "word"
                         .groupBy(new SelectWord())
                         // apply ReduceFunction on grouped DataSet
                         .reduce(new WordCounter());

public class SelectWord implements KeySelector {
  @Override
  public String getKey(Word w) {
    return w.word;
  }
}

Reduce由字段位置键分组的DataSet（仅限元组数据集）

字段位置键指定用作分组键的元组数据集的一个或多个字段。以下代码显示如何使用字段位置键并应用reduce函数 

DataSet> tuples = // [...]
DataSet> reducedTuples = tuples
                                         // group DataSet on first and second field of Tuple
                                         .groupBy(0, 1)
                                         // apply ReduceFunction on grouped DataSet
                                         .reduce(new MyTupleReducer());

按case类字段分组的DataSetReduce

使用Case Classes时，您还可以使用字段名称指定分组键：

java没有case类。

scala：

case class MyClass(val a: String, b: Int, c: Double)
val tuples = DataSet[MyClass] = // [...]
// group on the first and second field
val reducedTuples = tuples.groupBy("a", "b").reduce { ... }

 

GroupReduce作用在分组数据集上

应用于分组数据集的GroupReduce转换为每个组调用用户定义的group-reduce函数。这与Reduce的区别在于，用户定义的函数一次获得整个组。该函数使用可迭代的方法调用组中的所有元素，并可以返回任意数量的结果元素。

GroupReduce根据指定键字段对数据集进行分组(仅适用于元组数据集)

下面的代码展示了如何从按整数分组的数据集中删除重复的字符串。

public class DistinctReduce
         implements GroupReduceFunction, Tuple2> {

  @Override
  public void reduce(Iterable> in, Collector> out) {

    Set uniqStrings = new HashSet();
    Integer key = null;

    // add all strings of the group to the set
    for (Tuple2 t : in) {
      key = t.f0;
      uniqStrings.add(t.f1);
    }

    // emit all unique strings.
    for (String s : uniqStrings) {
      out.collect(new Tuple2(key, s));
    }
  }
}

// [...]
DataSet> input = // [...]
DataSet> output = input
                           .groupBy(0)            // group DataSet by the first tuple field
                           .reduceGroup(new DistinctReduce());  // apply GroupReduceFunction

GroupReduce根据键表达式、键选择器函数或Case类字段对数据集进行分组

类似于Reduce转换中的键表达式 key expressions, 键选择器函数 key-selector functions，和案例类字段的 case class fields工作。

 

对已排序的组进行GroupReduce

group-reduce函数使用迭代器访问组的元素。可选地，迭代器可以按照指定的顺序分发分组的元素。在许多情况下，这可以帮助降低用户定义的group-reduce函数的复杂性，并提高其效率。

下面的代码展示了另一个示例，该示例如何删除按整数分组并按字符串排序的数据集中的重复字符串。

package org.apache.flink.examples.java.dataBatchAPI;
import org.apache.flink.api.common.functions.GroupReduceFunction;
import org.apache.flink.api.common.operators.Order;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.util.Collector;

public class SortGroupDemo {
   public static void main(String[] args) {
      try {
         final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
         env.setParallelism(1);

         Tuple2 tuple1 = new Tuple2<>(1, "bb");
         Tuple2 tuple2 = new Tuple2<>(4, "bb");
         Tuple2 tuple3 = new Tuple2<>(33, "cc");
         Tuple2 tuple4 = new Tuple2<>(4, "bb");
         Tuple2 tuple5 = new Tuple2<>(-5, "bb");
         Tuple2 tuple6 = new Tuple2<>(-5, "ff");
         Tuple2 tuple7 = new Tuple2<>(-1, "hh");
         Tuple2 tuple8 = new Tuple2<>(-3, "jj");

         DataSet> text = env.fromElements(tuple1, tuple2, tuple3, tuple4,
            tuple5, tuple6, tuple7, tuple8);
         DataSet> output = text
            .groupBy(0)                         // group DataSet by first field
            .sortGroup(1, Order.ASCENDING)      // sort groups on second tuple field
            .reduceGroup(new DistinctReduce());
         output.print();


      } catch (Exception e) {

      }

   }
}

class DistinctReduce
   implements GroupReduceFunction, Tuple2> {

   @Override
   public void reduce(Iterable> in, Collector> out) {
      Integer key = null;
      String comp = null;

      for (Tuple2 t : in) {
         key = t.f0;
         String next = t.f1;

         // check if strings are different
         if (comp == null || !next.equals(comp)) {
            out.collect(new Tuple2(key, next));
            comp = next;
         }
      }
   }
}

 输出：key值相同分到一组，一组中value相同的元素会被过滤。

注意:如果在reduce操作之前使用基于排序的操作算子执行策略来建立分组，那么GroupSort通常是无效的。

 

可组合的GroupReduceFunctions

与reduce函数相反，group-reduce函数不是可隐式组合的（隐式组合：reduce默认输入输出的数据类型必须相同）。为了使group-reduce函数可组合，必须实现GroupCombineFunction 接口。

Important:GroupCombineFunction接口的通用输入输出类型必须等于GroupReduceFunction的通用输入类型，如下例所示:

// Combinable GroupReduceFunction that computes a sum.
public class MyCombinableGroupReducer implements
  GroupReduceFunction, String>,
  GroupCombineFunction, Tuple2>
{
    //后执行
  @Override
  public void reduce(Iterable> in,
                     Collector out) {

    String key = null;
    int sum = 0;

    for (Tuple2 curr : in) {
      key = curr.f0;
      sum += curr.f1;
    }
    // concat key and sum and emit
    out.collect(key + "-" + sum);
  }

  //先执行
  @Override
  public void combine(Iterable> in,
                      Collector> out) {
    String key = null;
    int sum = 0;

    for (Tuple2 curr : in) {
      key = curr.f0;
      sum += curr.f1;
    }
    // emit tuple with key and sum
    out.collect(new Tuple2<>(key, sum));
  }
}

GroupCombine在分组数据集上的使用

GroupCombine变换是可组合GroupReduceFunction中的组合步骤的更一般的形式。从某种意义上说，它允许将输入类型I转换成任意输出类型O的组合。相反，GroupReduce中的组合步骤仅允许从输入类型I到输出类型I的组合。这是因为GroupReduceFunction中的reduce步骤需要输入类型I。

在一些应用中，期望在执行别的变换（例如，减小数据大小）之前将DataSet组合成中间格式。这可以通过CombineGroup转换以非常低的成本实现。

注意：分组数据集上的GroupCombine在内存中使用贪婪策略执行，该策略可能不会一次处理所有数据，而是以多个步骤处理。它也可以在各个分区上执行，而无需像GroupReduce转换那样进行数据交换。这个统计结果可能是局部汇总值，因此最后还是要调用GroupReduceFunction。

下面的示例演示如何使用CombineGroup转换实现另一种WordCount汇总统计。

 

package org.apache.flink.examples.java.dataBatchAPI;

import org.apache.flink.api.common.functions.FlatMapFunction;
import org.apache.flink.api.common.functions.GroupCombineFunction;
import org.apache.flink.api.common.functions.GroupReduceFunction;
import org.apache.flink.api.java.DataSet;
import org.apache.flink.api.java.ExecutionEnvironment;
import org.apache.flink.api.java.functions.KeySelector;
import org.apache.flink.api.java.operators.GroupCombineOperator;
import org.apache.flink.api.java.operators.GroupReduceOperator;
import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.examples.java.wordcount.util.WordCountData;
import org.apache.flink.util.Collector;

public class CombineGroupDemo {
   public static void main(String[] args) {
      try {
         ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

         DataSet text = WordCountData.getDefaultTextLineDataSet(env);
//       env.setParallelism(1);

         DataSet> combineGroup = text.flatMap(new FlatMapFunction() {
            @Override
            public void flatMap(String value, Collector out) throws Exception {
               String[] tokens = value.toLowerCase().split("\\W+");

               // emit the pairs
               for (String token : tokens) {
                  if (token.length() > 0) {
                     out.collect(token);
                  }
               }
            }
         }).groupBy((String value) -> value)
            .combineGroup(new GroupCombineFunction>() {
               @Override
               public void combine(Iterable words, Collector> out) throws Exception {
                  String key = null;
                  int count = 0;

                  for (String word : words) {
                     key = word;
                     count++;
                  }
                  // emit tuple with word and count
                  out.collect(new Tuple2(key, count));
               }
            });

         combineGroup.print();

         GroupReduceOperator, Object> output =
            combineGroup.groupBy(0)
               .reduceGroup(new GroupReduceFunction, Object>() {
            @Override
            public void reduce(Iterable> values, Collector