面包芯语

深入理解SQL中的GroupingSets语句

原创 元闰子的邀请 2022-07-03 12:17
构建AI未来，Arm计算平台无处不在 如何增强电动汽车的实时控制能力？

前言

SQL 中 Group By 语句大家都很熟悉，根据指定的规则对数据进行分组，常常和聚合函数一起使用。

比如，考虑有表 dealer，表中数据如下：

id (Int)city (String)car_model (String)quantity (Int)
100FremontHonda Civic10
100FremontHonda Accord15
100FremontHonda CRV7
200DublinHonda Civic20
200DublinHonda Accord10
200DublinHonda CRV3
300San JoseHonda Civic5
300San JoseHonda Accord8

如果执行 SQL 语句 SELECT id, sum(quantity) FROM dealer GROUP BY id ORDER BY id，会得到如下结果：

+---+-------------+
| id|sum(quantity)|
+---+-------------+
|100|           32|
|200|           33|
|300|           13|
+---+-------------+

上述 SQL 语句的意思就是对数据按 id 列进行分组，然后在每个分组内对 quantity 列进行求和。

Group By 语句除了上面的简单用法之外，还有更高级的用法，常见的是 Grouping Sets、RollUp 和 Cube，它们在 OLAP 时比较常用。其中，RollUp 和 Cube 都是以 Grouping Sets 为基础实现的，因此，弄懂了 Grouping Sets，也就理解了 RollUp 和 Cube 。

本文首先简单介绍 Grouping Sets 的用法，然后以 Spark SQL 作为切入点，深入解析 Grouping Sets 的实现机制。

Spark SQL 是 Apache Spark 大数据处理框架的一个子模块，用来处理结构化信息。它可以将 SQL 语句翻译多个任务在 Spark 集群上执行，允许用户直接通过 SQL 来处理数据，大大提升了易用性。

Grouping Sets 简介

Spark SQL 官方文档中 SQL Syntax 一节对 Grouping Sets 语句的描述如下：

Groups the rows for each grouping set specified after GROUPING SETS. （... 一些举例） This clause is a shorthand for a UNION ALLwhere each leg of the UNION ALL operator performs aggregation of each grouping set specified in the GROUPING SETS clause. （... 一些举例）

也即，Grouping Sets 语句的作用是指定几个 grouping set 作为 Group By 的分组规则，然后再将结果联合在一起。它的效果和，先分别对这些 grouping set 进行 Group By 分组之后，再通过 Union All 将结果联合起来，是一样的。

比如，对于 dealer 表，Group By Grouping Sets ((city, car_model), (city), (car_model), ()) 和 Union All((Group By city, car_model), (Group By city), (Group By car_model), 全局聚合) 的效果是相同的：

先看 Grouping Sets 版的执行结果：

spark-sql> SELECT city, car_model, sum(quantity) AS sum FROM dealer 
         > GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) 
         > ORDER BY city, car_model;
+--------+------------+---+
|    city|   car_model|sum|
+--------+------------+---+
|    null|        null| 78|
|    null|Honda Accord| 33|
|    null|   Honda CRV| 10|
|    null| Honda Civic| 35|
|  Dublin|        null| 33|
|  Dublin|Honda Accord| 10|
|  Dublin|   Honda CRV|  3|
|  Dublin| Honda Civic| 20|
| Fremont|        null| 32|
| Fremont|Honda Accord| 15|
| Fremont|   Honda CRV|  7|
| Fremont| Honda Civic| 10|
|San Jose|        null| 13|
|San Jose|Honda Accord|  8|
|San Jose| Honda Civic|  5|
+--------+------------+---+

再看 Union All 版的执行结果：

spark-sql> (SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model) UNION ALL 
         > (SELECT city, NULL as car_model, sum(quantity) AS sum FROM dealer GROUP BY city) UNION ALL 
         > (SELECT NULL as city, car_model, sum(quantity) AS sum FROM dealer GROUP BY car_model) UNION ALL 
         > (SELECT NULL as city, NULL as car_model, sum(quantity) AS sum FROM dealer) 
         > ORDER BY city, car_model;
+--------+------------+---+
|    city|   car_model|sum|
+--------+------------+---+
|    null|        null| 78|
|    null|Honda Accord| 33|
|    null|   Honda CRV| 10|
|    null| Honda Civic| 35|
|  Dublin|        null| 33|
|  Dublin|Honda Accord| 10|
|  Dublin|   Honda CRV|  3|
|  Dublin| Honda Civic| 20|
| Fremont|        null| 32|
| Fremont|Honda Accord| 15|
| Fremont|   Honda CRV|  7|
| Fremont| Honda Civic| 10|
|San Jose|        null| 13|
|San Jose|Honda Accord|  8|
|San Jose| Honda Civic|  5|
+--------+------------+---+

两版的查询结果完全一样。

Grouping Sets 的执行计划

从执行结果上看，Grouping Sets 版本和 Union All 版本的 SQL 是等价的，但 Grouping Sets 版本更加简洁。

那么，Grouping Sets 仅仅只是 Union All 的一个缩写，或者语法糖吗？

为了进一步探究 Grouping Sets 的底层实现是否和 Union All 是一致的，我们可以来看下两者的执行计划。

首先，我们通过 explain extended 来查看 Union All 版本的 Optimized Logical Plan:

spark-sql> explain extended (SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model) UNION ALL (SELECT city, NULL as car_model, sum(quantity) AS sum FROM dealer GROUP BY city) UNION ALL (SELECT NULL as city, car_model, sum(quantity) AS sum FROM dealer GROUP BY car_model) UNION ALL (SELECT NULL as city, NULL as car_model, sum(quantity) AS sum FROM dealer) ORDER BY city, car_model;
== Parsed Logical Plan ==
...
== Analyzed Logical Plan ==
...
== Optimized Logical Plan ==
Sort [city#93 ASC NULLS FIRST, car_model#94 ASC NULLS FIRST], true
+- Union false, false
   :- Aggregate [city#93, car_model#94], [city#93, car_model#94, sum(quantity#95) AS sum#79L]
   :  +- Project [city#93, car_model#94, quantity#95]
   :     +- HiveTableRelation [`default`.`dealer`, ..., Data Cols: [id#92, city#93, car_model#94, quantity#95], Partition Cols: []]
   :- Aggregate [city#97], [city#97, null AS car_model#112, sum(quantity#99) AS sum#81L]
   :  +- Project [city#97, quantity#99]
   :     +- HiveTableRelation [`default`.`dealer`, ..., Data Cols: [id#96, city#97, car_model#98, quantity#99], Partition Cols: []]
   :- Aggregate [car_model#102], [null AS city#113, car_model#102, sum(quantity#103) AS sum#83L]
   :  +- Project [car_model#102, quantity#103]
   :     +- HiveTableRelation [`default`.`dealer`, ..., Data Cols: [id#100, city#101, car_model#102, quantity#103], Partition Cols: []]
   +- Aggregate [null AS city#114, null AS car_model#115, sum(quantity#107) AS sum#86L]
      +- Project [quantity#107]
         +- HiveTableRelation [`default`.`dealer`, ..., Data Cols: [id#104, city#105, car_model#106, quantity#107], Partition Cols: []]
== Physical Plan ==
...

从上述的 Optimized Logical Plan 可以清晰地看出 Union All 版本的执行逻辑：

  1. 执行每个子查询语句，计算得出查询结果。其中，每个查询语句的逻辑是这样的：
  • 在 HiveTableRelation 节点对 dealer 表进行全表扫描。
  • 在 Project 节点选出与查询语句结果相关的列，比如对于子查询语句 SELECT NULL as city, NULL as car_model, sum(quantity) AS sum FROM dealer，只需保留 quantity 列即可。
  • 在 Aggregate 节点完成 quantity 列对聚合运算。在上述的 Plan 中，Aggregate 后面紧跟的就是用来分组的列，比如 Aggregate [city#902] 就表示根据 city 列来进行分组。
  • 在 Union 节点完成对每个子查询结果的联合。
  • 最后，在 Sort 节点完成对数据的排序，上述 Plan 中 Sort [city#93 ASC NULLS FIRST, car_model#94 ASC NULLS FIRST] 就表示根据 city 和 car_model 列进行升序排序。

    • 接下来，我们通过 explain extended 来查看 Grouping Sets 版本的 Optimized Logical Plan：

    spark-sql> explain extended SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) ORDER BY city, car_model;
    == Parsed Logical Plan ==
    ...
    == Analyzed Logical Plan ==
    ...
    == Optimized Logical Plan ==
    Sort [city#138 ASC NULLS FIRST, car_model#139 ASC NULLS FIRST], true
    +- Aggregate [city#138, car_model#139, spark_grouping_id#137L], [city#138, car_model#139, sum(quantity#133) AS sum#124L]
       +- Expand [[quantity#133, city#131, car_model#132, 0], [quantity#133, city#131, null, 1], [quantity#133, null, car_model#132, 2], [quantity#133, null, null, 3]], [quantity#133, city#138, car_model#139, spark_grouping_id#137L]
          +- Project [quantity#133, city#131, car_model#132]
             +- HiveTableRelation [`default`.`dealer`, org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe, Data Cols: [id#130, city#131, car_model#132, quantity#133], Partition Cols: []]
    == Physical Plan ==
    ...

    从 Optimized Logical Plan 来看，Grouping Sets 版本要简洁很多！具体的执行逻辑是这样的：

    1. 在 HiveTableRelation 节点对 dealer 表进行全表扫描。
    2. 在 Project 节点选出与查询语句结果相关的列。
    3. 接下来的 Expand 节点是关键，数据经过该节点后，多出了 spark_grouping_id 列。从 Plan 中可以看出来，Expand 节点包含了 Grouping Sets 里的各个 grouping set 信息，比如 [quantity#133, city#131, null, 1] 对应的就是 (city) 这一 grouping set。而且，每个 grouping set 对应的 spark_grouping_id 列的值都是固定的，比如 (city) 对应的 spark_grouping_id 为 1。
    4. 在 Aggregate 节点完成 quantity 列对聚合运算，其中分组的规则为 city, car_model, spark_grouping_id。注意，数据经过 Aggregate 节点后，spark_grouping_id 列被删除了！
    5. 最后，在 Sort 节点完成对数据的排序。

    从 Optimized Logical Plan 来看，虽然 Union All 版本和 Grouping Sets 版本的效果一致，但它们的底层实现有着巨大的差别。

    其中，Grouping Sets 版本的 Plan 中最关键的是 Expand 节点，目前，我们只知道数据经过它之后，多出了 spark_grouping_id 列。而且从最终结果来看，spark_grouping_id只是 Spark SQL 的内部实现细节，对用户并不体现。那么：

    1. Expand 的实现逻辑是怎样的，为什么能达到 Union All 的效果？
    2. Expand 节点的输出数据是怎样的？
    3. spark_grouping_id 列的作用是什么？

    通过 Physical Plan，我们发现 Expand 节点对应的算子名称也是 Expand:

    == Physical Plan ==
    AdaptiveSparkPlan isFinalPlan=false
    +- Sort [city#138 ASC NULLS FIRST, car_model#139 ASC NULLS FIRST], true, 0
       +- Exchange rangepartitioning(city#138 ASC NULLS FIRST, car_model#139 ASC NULLS FIRST, 200), ENSURE_REQUIREMENTS, [plan_id=422]
          +- HashAggregate(keys=[city#138, car_model#139, spark_grouping_id#137L], functions=[sum(quantity#133)], output=[city#138, car_model#139, sum#124L])
             +- Exchange hashpartitioning(city#138, car_model#139, spark_grouping_id#137L, 200), ENSURE_REQUIREMENTS, [plan_id=419]
                +- HashAggregate(keys=[city#138, car_model#139, spark_grouping_id#137L], functions=[partial_sum(quantity#133)], output=[city#138, car_model#139, spark_grouping_id#137L, sum#141L])
                   +- Expand [[quantity#133, city#131, car_model#132, 0], [quantity#133, city#131, null, 1], [quantity#133, null, car_model#132, 2], [quantity#133, null, null, 3]], [quantity#133, city#138, car_model#139, spark_grouping_id#137L]
                      +- Scan hive default.dealer [quantity#133, city#131, car_model#132], HiveTableRelation [`default`.`dealer`, ..., Data Cols: [id#130, city#131, car_model#132, quantity#133], Partition Cols: []]

    带着前面的几个问题，接下来我们深入 Spark SQL 的 Expand 算子源码寻找答案。

    Expand 算子的实现

    Expand 算子在 Spark SQL 源码中的实现为 ExpandExec 类（Spark SQL 中的算子实现类的命名都是 XxxExec 的格式，其中 Xxx 为具体的算子名，比如 Project 算子的实现类为 ProjectExec），核心代码如下：

    /**
     * Apply all of the GroupExpressions to every input row, hence we will get
     * multiple output rows for an input row.
     * @param projections The group of expressions, all of the group expressions should
     *                    output the same schema specified bye the parameter `output`
     * @param output      The output Schema
     * @param child       Child operator
     */
    case class ExpandExec(
        projections: Seq[Seq[Expression]],
        output: Seq[Attribute],
        child: SparkPlan    )
      extends UnaryExecNode with CodegenSupport {

      ...
      // 关键点1，将child.output，也即上游算子输出数据的schema，
      // 绑定到表达式数组exprs，以此来计算输出数据
      private[this] val projection =
        (exprs: Seq[Expression]) => UnsafeProjection.create(exprs, child.output)

      // doExecute()方法为Expand算子执行逻辑所在
      protected override def doExecute(): RDD[InternalRow] = {
        val numOutputRows = longMetric("numOutputRows")

        // 处理上游算子的输出数据，Expand算子的输入数据就从iter迭代器获取
        child.execute().mapPartitions { iter =>
          // 关键点2，projections对应了Grouping Sets里面每个grouping set的表达式，
          // 表达式输出数据的schema为this.output, 比如 (quantity, city, car_model, spark_grouping_id)
          // 这里的逻辑是为它们各自生成一个UnsafeProjection对象，通过该对象的apply方法就能得出Expand算子的输出数据
          val groups = projections.map(projection).toArray
          new Iterator[InternalRow] {
            private[this] var result: InternalRow = _
            private[this] var idx = -1  // -1 means the initial state
            private[this] var input: InternalRow = _

            override final def hasNext: Boolean = (-1 < idx && idx < groups.length) || iter.hasNext

            override final def next(): InternalRow = {
              // 关键点3，对于输入数据的每一条记录，都重复使用N次，其中N的大小对应了projections数组的大小，
              // 也即Grouping Sets里指定的grouping set的数量
              if (idx <= 0) {
                // in the initial (-1) or beginning(0) of a new input row, fetch the next input tuple
                input = iter.next()
                idx = 0
              }
              // 关键点4，对输入数据的每一条记录，通过UnsafeProjection计算得出输出数据，
              // 每个grouping set对应的UnsafeProjection都会对同一个input计算一遍
              result = groups(idx)(input)
              idx += 1

              if (idx == groups.length && iter.hasNext) {
                idx = 0
              }

              numOutputRows += 1
              result
            }
          }
        }
      }
      ...
    }

    ExpandExec 的实现并不复杂，想要理解它的运作原理，关键是看懂上述源码中提到的 4 个关键点。

    关键点 1 和 关键点 2 是基础，关键点 2 中的 groups 是一个 UnsafeProjection[N] 数组类型，其中每个 UnsafeProjection 代表了 Grouping Sets 语句里指定的 grouping set，它的定义是这样的：

    // A projection that returns UnsafeRow.
    abstract class UnsafeProjection extends Projection {
      override def apply(row: InternalRow): UnsafeRow
    }

    // The factory object for `UnsafeProjection`.
    object UnsafeProjection
        extends CodeGeneratorWithInterpretedFallback[Seq[Expression], UnsafeProjection] {
      // Returns an UnsafeProjection for given sequence of Expressions, which will be bound to
      // `inputSchema`.
      def create(exprs: Seq[Expression], inputSchema: Seq[Attribute]): UnsafeProjection = {
        create(bindReferences(exprs, inputSchema))
      }
      ...
    }

    UnsafeProjection 起来了类似列投影的作用，其中， apply 方法根据创建时的传参 exprs 和 inputSchema，对输入记录进行列投影，得出输出记录。

    比如，前面的 GROUPING SETS ((city, car_model), (city), (car_model), ())例子，它对应的 groups 是这样的：

    其中，AttributeReference 类型的表达式，在计算时，会直接引用输入数据对应列的值；Iteral 类型的表达式，在计算时，值是固定的。

    关键点 3 和 关键点 4 是 Expand 算子的精华所在，ExpandExec 通过这两段逻辑，将每一个输入记录，扩展（Expand）成 N 条输出记录。

    关键点 4 中 groups(idx)(input) 等同于 groups(idx).apply(input)。

    还是以前面 GROUPING SETS ((city, car_model), (city), (car_model), ()) 为例子，效果是这样的：

    到这里，我们已经弄清楚 Expand 算子的工作原理，再回头看前面提到的 3 个问题，也不难回答了：

    1. Expand 的实现逻辑是怎样的，为什么能达到 Union All 的效果？

      如果说 Union All 是先聚合再联合，那么 Expand 就是先联合再聚合。Expand 利用 groups 里的 N 个表达式对每条输入记录进行计算，扩展成 N 条输出记录。后面再聚合时，就能达到与 Union All 一样的效果了。

    2. Expand 节点的输出数据是怎样的？

      在 schema 上，Expand 输出数据会比输入数据多出 spark_grouping_id 列；在记录数上，是输入数据记录数的 N 倍。

    3. spark_grouping_id 列的作用是什么？

      spark_grouping_id 给每个 grouping set 进行编号，这样，即使在 Expand 阶段把数据先联合起来，在 Aggregate 阶段（把 spark_grouping_id 加入到分组规则）也能保证数据能够按照每个 grouping set 分别聚合，确保了结果的正确性。

    查询性能对比

    从前文可知，Grouping Sets 和 Union All 两个版本的 SQL 语句有着一样的效果，但是它们的执行计划却有着巨大的差别。下面，我们将比对两个版本之间的执行性能差异。

    spark-sql 执行完 SQL 语句之后会打印耗时信息，我们对两个版本的 SQL 分别执行 10 次，得到如下信息：

    // Grouping Sets 版本执行10次的耗时信息
    // SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY GROUPING SETS ((city, car_model), (city), (car_model), ()) ORDER BY city, car_model;
    Time taken: 0.289 seconds, Fetched 15 row(s)
    Time taken: 0.251 seconds, Fetched 15 row(s)
    Time taken: 0.259 seconds, Fetched 15 row(s)
    Time taken: 0.258 seconds, Fetched 15 row(s)
    Time taken: 0.296 seconds, Fetched 15 row(s)
    Time taken: 0.247 seconds, Fetched 15 row(s)
    Time taken: 0.298 seconds, Fetched 15 row(s)
    Time taken: 0.286 seconds, Fetched 15 row(s)
    Time taken: 0.292 seconds, Fetched 15 row(s)
    Time taken: 0.282 seconds, Fetched 15 row(s)

    // Union All 版本执行10次的耗时信息
    // (SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY city, car_model) UNION ALL (SELECT city, NULL as car_model, sum(quantity) AS sum FROM dealer GROUP BY city) UNION ALL (SELECT NULL as city, car_model, sum(quantity) AS sum FROM dealer GROUP BY car_model) UNION ALL (SELECT NULL as city, NULL as car_model, sum(quantity) AS sum FROM dealer) ORDER BY city, car_model;
    Time taken: 0.628 seconds, Fetched 15 row(s)
    Time taken: 0.594 seconds, Fetched 15 row(s)
    Time taken: 0.591 seconds, Fetched 15 row(s)
    Time taken: 0.607 seconds, Fetched 15 row(s)
    Time taken: 0.616 seconds, Fetched 15 row(s)
    Time taken: 0.64 seconds, Fetched 15 row(s)
    Time taken: 0.623 seconds, Fetched 15 row(s)
    Time taken: 0.625 seconds, Fetched 15 row(s)
    Time taken: 0.62 seconds, Fetched 15 row(s)
    Time taken: 0.62 seconds, Fetched 15 row(s)

    可以算出，Grouping Sets 版本的 SQL 平均耗时为 0.276s；Union All 版本的 SQL 平均耗时为 0.616s，是前者的 2.2 倍！

    所以，Grouping Sets 版本的 SQL 不仅在表达上更加简洁，在性能上也更加高效。

    RollUp 和 Cube

    Group By 的高级用法中，还有 RollUp 和 Cube 两个比较常用。

    首先，我们看下 RollUp 语句。

    Spark SQL 官方文档中 SQL Syntax 一节对 RollUp 语句的描述如下：

    Specifies multiple levels of aggregations in a single statement. This clause is used to compute aggregations based on multiple grouping sets. ROLLUP is a shorthand for GROUPING SETS. （... 一些例子）

    官方文档中，把 RollUp 描述为 Grouping Sets 的简写，等价规则为：RollUp(A, B, C) == Grouping Sets((A, B, C), (A, B), (A), ())。

    比如，Group By RollUp(city, car_model) 就等同于 Group By Grouping Sets((city, car_model), (city), ())。

    下面，我们通过 expand extended 看下 RollUp 版本 SQL 的 Optimized Logical Plan：

    spark-sql> explain extended SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY ROLLUP(city, car_model) ORDER BY city, car_model;
    == Parsed Logical Plan ==
    ...
    == Analyzed Logical Plan ==
    ...
    == Optimized Logical Plan ==
    Sort [city#2164 ASC NULLS FIRST, car_model#2165 ASC NULLS FIRST], true
    +- Aggregate [city#2164, car_model#2165, spark_grouping_id#2163L], [city#2164, car_model#2165, sum(quantity#2159) AS sum#2150L]
       +- Expand [[quantity#2159, city#2157, car_model#2158, 0], [quantity#2159, city#2157, null, 1], [quantity#2159, null, null, 3]], [quantity#2159, city#2164, car_model#2165, spark_grouping_id#2163L]
          +- Project [quantity#2159, city#2157, car_model#2158]
             +- HiveTableRelation [`default`.`dealer`, ..., Data Cols: [id#2156, city#2157, car_model#2158, quantity#2159], Partition Cols: []]
    == Physical Plan ==
    ...

    从上述 Plan 可以看出，RollUp 底层实现用的也是 Expand 算子，说明 RollUp 确实是基于 Grouping Sets 实现的。 而且 Expand [[quantity#2159, city#2157, car_model#2158, 0], [quantity#2159, city#2157, null, 1], [quantity#2159, null, null, 3]] 也表明 RollUp 符合等价规则。

    下面，我们按照同样的思路，看下 Cube 语句。

    Spark SQL 官方文档中 SQL Syntax 一节对 Cube 语句的描述如下：

    CUBE clause is used to perform aggregations based on combination of grouping columns specified in the GROUP BYclause. CUBE is a shorthand for GROUPING SETS. (... 一些例子)

    同样，官方文档把 Cube 描述为 Grouping Sets 的简写，等价规则为：Cube(A, B, C) == Grouping Sets((A, B, C), (A, B), (A, C), (B, C), (A), (B), (C), ())。

    比如，Group By Cube(city, car_model) 就等同于 Group By Grouping Sets((city, car_model), (city), (car_model), ())。

    下面，我们通过 expand extended 看下 Cube 版本 SQL 的 Optimized Logical Plan：

    spark-sql> explain extended SELECT city, car_model, sum(quantity) AS sum FROM dealer GROUP BY CUBE(city, car_model) ORDER BY city, car_model;
    == Parsed Logical Plan ==
    ...
    == Analyzed Logical Plan ==
    ...
    == Optimized Logical Plan ==
    Sort [city#2202 ASC NULLS FIRST, car_model#2203 ASC NULLS FIRST], true
    +- Aggregate [city#2202, car_model#2203, spark_grouping_id#2201L], [city#2202, car_model#2203, sum(quantity#2197) AS sum#2188L]
       +- Expand [[quantity#2197, city#2195, car_model#2196, 0], [quantity#2197, city#2195, null, 1], [quantity#2197, null, car_model#2196, 2], [quantity#2197, null, null, 3]], [quantity#2197, city#2202, car_model#2203, spark_grouping_id#2201L]
          +- Project [quantity#2197, city#2195, car_model#2196]
             +- HiveTableRelation [`default`.`dealer`, ..., Data Cols: [id#2194, city#2195, car_model#2196, quantity#2197], Partition Cols: []]
    == Physical Plan ==
    ...

    从上述 Plan 可以看出，Cube 底层用的也是 Expand 算子，说明 Cube 确实基于 Grouping Sets 实现，而且也符合等价规则。

    所以，RollUp 和 Cube 可以看成是 Grouping Sets 的语法糖，在底层实现和性能上是一样的。

    最后

    本文重点讨论了 Group By 高级用法 Groupings Sets 语句的功能和底层实现。

    虽然 Groupings Sets 的功能，通过 Union All 也能实现，但前者并非后者的语法糖，它们的底层实现完全不一样。Grouping Sets 采用的是先联合再聚合的思路，通过 spark_grouping_id 列来保证数据的正确性；Union All 则采用先聚合再联合的思路。Grouping Sets 在 SQL 语句表达和性能上都有更大的优势。

    Group By 的另外两个高级用法 RollUp 和 Cube 则可以看成是 Grouping Sets 的语法糖，它们的底层都是基于 Expand 算子实现，在性能上与直接使用 Grouping Sets 是一样的，但在 SQL 表达上更加简洁。

    文章配图

    可以在 用Keynote画出手绘风格的配图 中找到文章的绘图方法。

    参考

    [1] Spark SQL Guide, Apache Spark

    [2] apache spark 3.3 版本源码, Apache Spark, GitHub

    更多文章请关注微信公众号：元闰子的邀请

    登录阅读全文
    免责声明： 该内容由专栏作者授权发布或作者转载，目的在于传递更多信息，并不代表本网赞同其观点，本站亦不保证或承诺内容真实性等。若内容或图片侵犯您的权益，请及时联系本站删除。侵权投诉联系：  nick.zong@aspencore.com！
    元闰子的邀请
    评论
    • 国产高性能CPU--米尔瑞芯微RK3576赋能AIoT、工业、智能显示终端
      随着市场需求不断的变化，各行各业对CPU的要求越来越高，特别是近几年流行的 AIOT，为了有更好的用户体验，CPU的算力就要求更高了。今天为大家推荐由米尔基于瑞芯微RK3576处理器推出的MYC-LR3576核心板及开发板。关于RK3576处理器国产CPU，是这些年的骄傲，华为手机全国产化，国人一片呼声，再也不用卡脖子了。RK3576处理器，就是一款由国产是厂商瑞芯微，今年第二季推出的全新通用型的高性能SOC芯片，这款CPU到底有多么的高性能，下面看看它的几个特性：8核心6 TOPS超强算力双千
      米尔电子嵌入式 2025-01-03 17:04 49浏览
    • 德鲁克著作的解读：从“人”与“事”看管理的本质
      彼得·德鲁克被誉为“现代管理学之父”，他的管理思想影响了无数企业和管理者。然而，关于他的书籍分类，一种流行的说法令人感到困惑：德鲁克一生写了39本书，其中15本是关于管理的，而其中“专门写工商企业或为企业管理者写的”只有两本——《为成果而管理》和《创新与企业家精神》。这样的表述广为流传，但深入探讨后却发现并不完全准确。让我们一起重新审视这一说法，解析其中的矛盾与根源，进而重新认识德鲁克的管理思想及其著作的真正价值。从《创新与企业家精神》看德鲁克的视角《创新与企业家精神》通常被认为是一本专为企业管
      优思学院 2025-01-06 12:03 84浏览
    • Linux系统更换开机logo方法教程，触觉智能RK3562开发板演示
      本文介绍Linux系统更换开机logo方法教程，通用RK3566、RK3568、RK3588、RK3576等开发板，触觉智能RK3562开发板演示，搭载4核A53处理器，主频高达2.0GHz；内置独立1Tops算力NPU，可应用于物联网网关、平板电脑、智能家居、教育电子、工业显示与控制等行业。制作图片开机logo图片制作注意事项（1）图片必须为bmp格式；（2）图片大小不能大于4MB；（3）BMP位深最大是32，建议设置为8；（4）图片名称为logo.bmp和logo_kernel.bmp；开机
      Industio_触觉智能 2025-01-06 10:43 75浏览
    • PLC组态的方式与比较
      PLC组态方式主要有三种，每种都有其独特的特点和适用场景。下面来简单说说： 1. 硬件组态   定义：硬件组态指的是选择适合的PLC型号、I/O模块、通信模块等硬件组件，并按照实际需求进行连接和配置。    灵活性：这种方式允许用户根据项目需求自由搭配硬件组件，具有较高的灵活性。    成本：可能需要额外的硬件购买成本，适用于对系统性能和扩展性有较高要求的场合。 2. 软件组态   定义：软件组态主要是通过PLC
      丙丁先生 2025-01-06 09:23 71浏览
    • 硅电容系列一：硅电容概述
      这篇内容主要讨论三个基本问题，硅电容是什么，为什么要使用硅电容，如何正确使用硅电容？1.  硅电容是什么首先我们需要了解电容是什么？物理学上电容的概念指的是给定电位差下自由电荷的储藏量，记为C，单位是F，指的是容纳电荷的能力，C=εS/d=ε0εrS/4πkd（真空）=Q/U。百度百科上电容器的概念指的是两个相互靠近的导体，中间夹一层不导电的绝缘介质。通过观察电容本身的定义公式中可以看到，在各个变量中比较能够改变的就是εr，S和d，也就是介质的介电常数，金属板有效相对面积以及距离。当前
      知白 2025-01-06 12:04 121浏览
    • 如何区分315MHz和433MHz遥控模块？
      每日可见的315MHz和433MHz遥控模块，你能分清楚吗？众所周知，一套遥控设备主要由发射部分和接收部分组成，发射器可以将控制者的控制按键经过编码，调制到射频信号上面，然后经天线发射出无线信号。而接收器是将天线接收到的无线信号进行解码，从而得到与控制按键相对应的信号，然后再去控制相应的设备工作。当前，常见的遥控设备主要分为红外遥控与无线电遥控两大类，其主要区别为所采用的载波频率及其应用场景不一致。红外遥控设备所采用的射频信号频率一般为38kHz，通常应用在电视、投影仪等设备中；而无线电遥控设备
      华普微HOPERF 2025-01-06 15:29 100浏览
    • Matter 标准：破生态枷锁，启家居智能新时代
      在智能家居领域中，Wi-Fi、蓝牙、Zigbee、Thread与Z-Wave等无线通信协议是构建短距物联局域网的关键手段，它们常在实际应用中交叉运用，以满足智能家居生态系统多样化的功能需求。然而，这些协议之间并未遵循统一的互通标准，缺乏直接的互操作性，在进行组网时需要引入额外的网关作为“翻译桥梁”，极大地增加了系统的复杂性。 同时，Apple HomeKit、SamSung SmartThings、Amazon Alexa、Google Home等主流智能家居平台为了提升市占率与消费者
      华普微HOPERF 2025-01-06 17:23 102浏览
    • 国产固态继电器如何满足物联网应用的需求
      物联网(IoT)的快速发展彻底改变了从智能家居到工业自动化等各个行业。由于物联网系统需要高效、可靠且紧凑的组件来处理众多传感器、执行器和通信设备，国产固态继电器(SSR)已成为满足中国这些需求的关键解决方案。本文探讨了国产SSR如何满足物联网应用的需求，重点介绍了它们的优势、技术能力以及在现实场景中的应用。了解物联网中的固态继电器固态继电器是一种电子开关设备，它使用半导体而不是机械触点来控制负载。与传统的机械继电器不同，固态继电器具有以下优势：快速切换：确保精确快速的响应，这对于实时物联网系统至
      克里雅半导体科技 2025-01-03 16:11 181浏览
    • 带驱动隔离器的自动化生产设备的未来
      自动化已成为现代制造业的基石，而驱动隔离器作为关键组件，在提升效率、精度和可靠性方面起到了不可或缺的作用。随着工业技术不断革新，驱动隔离器正助力自动化生产设备适应新兴趋势，并推动行业未来的发展。本文将探讨自动化的核心趋势及驱动隔离器在其中的重要角色。自动化领域的新兴趋势智能工厂的崛起智能工厂已成为自动化生产的新标杆。通过结合物联网（IoT）、人工智能（AI）和机器学习（ML），智能工厂实现了实时监控和动态决策。驱动隔离器在其中至关重要，它确保了传感器、执行器和控制单元之间的信号完整性，同时提供高
      腾恩科技-彭工 2025-01-03 16:28 169浏览
    • MCU应用第008篇 Eclipse环境下MCU寄存器描述文件的存储位置
          为控制片内设备并且查询其工作状态，MCU内部总是有一组特殊功能寄存器（SFR，Special Function Register）。    使用Eclipse环境调试MCU程序时，可以利用 Peripheral Registers Viewer来查看SFR。这个小工具是怎样知道某个型号的MCU有怎样的寄存器定义呢？它使用一种描述性的文本文件——SVD文件。这个文件存储在下面红色字体的路径下。    例：南京沁恒  &n
      电子知识打边炉 2025-01-04 20:04 89浏览
    • 光耦合器如何增强医疗设备的安全性
      光耦合器，也称为光隔离器，是一种利用光在两个隔离电路之间传输电信号的组件。在医疗领域，确保患者安全和设备可靠性至关重要。在众多有助于医疗设备安全性和效率的组件中，光耦合器起着至关重要的作用。这些紧凑型设备经常被忽视，但对于隔离高压和防止敏感医疗设备中的电气危害却是必不可少的。本文深入探讨了光耦合器的功能、其在医疗应用中的重要性以及其实际使用示例。什么是光耦合器？它通常由以下部分组成：LED（发光二极管）：将电信号转换为光。光电探测器（例如光电晶体管）：检测光并将其转换回电信号。这种布置确保输入和
      腾恩科技-彭工 2025-01-03 16:27 171浏览
    • 封闭式电机行业发展现状及市场潜力分析报告
      根据Global Info Research项目团队最新调研，预计2030年全球封闭式电机产值达到1425百万美元，2024-2030年期间年复合增长率CAGR为3.4%。 封闭式电机是一种电动机，其外壳设计为密闭结构，通常用于要求较高的防护等级的应用场合。封闭式电机可以有效防止外部灰尘、水分和其他污染物进入内部，从而保护电机的内部组件，延长其使用寿命。 环洋市场咨询机构出版的调研分析报告【全球封闭式电机行业总体规模、主要厂商及IPO上市调研报告，2025-2031】研究全球封闭式电机总体规
      GIRtina 2025-01-06 11:10 89浏览
    我要评论
    0
    点击右上角，分享到朋友圈 我知道啦
    请使用浏览器分享功能 我知道啦