精华内容
下载资源
问答
  • SQL中GROUP BY用法示例

    千次阅读 2018-11-15 16:36:03
    SQL中GROUP BY用法示例 概述 GROUP BY我们可以先从字面上来理解,GROUP表示分组,BY后面写字段名,就表示根据哪个字段进行分组,如果有用Excel比较多的话,GROUP BY比较类似Excel里面的透视表。 GROUP BY必须得...

    SQL中GROUP BY用法示例

    概述
    GROUP BY我们可以先从字面上来理解,GROUP表示分组,BY后面写字段名,就表示根据哪个字段进行分组,如果有用Excel比较多的话,GROUP BY比较类似Excel里面的透视表。
    GROUP BY必须得配合聚合函数来用,分组之后你可以计数(COUNT),求和(SUM),求平均数(AVG)等

    常用聚合函数
    count() 计数
    sum() 求和
    avg() 平均数
    max() 最大值
    min() 最小值

    举例一:查询某一天的各个平台的订单总数
    SELECT count(*) as 总数,platform FROM mk_order WHERE created_at between '2018-11-14 00:00:00’and ‘2018-11-14 23:59:59’ group by platform order by ‘count’ desc
    查询某一天的各个平台的订单总数

    举例二:查询examine_status=1(审核通过)的所有会员
    SELECT COUNT(*) as 会员总数 FROM mk_user WHERE deleted_at is null and examine_status=‘1’
    查询examine_status=1(审核通过)的所有会员

    展开全文
  • 文章目录Spark代码可读性与性能优化——示例六(GroupBy、ReduceByKey)0. 需求:统计历年全国高考生中数学成绩前100名1. 数据示例2. 存在问题的代码示例3. 如何解决代码中的问题?4. 最终代码,以及附其他代码 ...

    Spark代码可读性与性能优化——示例六(GroupBy、ReduceByKey)

    1. 普通常见优化示例

    1.1 错误示例 groupByKey

    import org.apache.spark.{SparkConf, SparkContext}
    
    object GroupNormal {
    
      def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setAppName("GroupNormal")
        val sc = new SparkContext(conf)
    
        // 数据可能有几亿条,此处只做模拟示例
        val dataRDD = sc.parallelize(List(
          ("hello", 2),
          ("java", 7),
          ("where", 1),
          ("rust", 2),
          // 中间还有很多数据,不做展示
          ("scala", 1),
          ("java", 1),
          ("black", 9)
        ))
    
        // 做一个词频统计
        val result = dataRDD.groupByKey()
          .mapValues(_.sum)
          .sortBy(_._2, false)
    
        result.take(10).foreach(println)
    
        sc.stop()
      }
    
    }
    

    1.2 正确示例 reduceByKey

        // 修改此部分groupByKey代码为reduceByKey
        val result = dataRDD
          .reduceByKey(_ + _)
          .sortBy(_._2, false)
    
        result.take(10).foreach(println)
    

    2. 高级优化

    2.0. 需求:统计历年全国高考生中数学成绩前100名

    2.1 数据示例

    idchinesemathenglishyear
    34123121211151342018
    52312111031311142010
    …………………………
    23423541341051242014
    • 共计约2亿条数据
    • 数据存于Hive中,表名tb_student_score,id值(唯一)代表学生,chinese代表语文,math代表数学,english代表英语

    2.2 存在问题的代码示例

    import org.apache.spark.SparkConf
    import org.apache.spark.sql.SparkSession
    
    /**
      * 数据分组错误示例
      *
      * @author ALion
      * @version 2019/5/15 22:33
      */
    object GroupDemo {
    
      def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setAppName("GroupDemo")
        val spark = SparkSession.builder()
          .config(conf)
          .enableHiveSupport()
          .getOrCreate()
    
        // 获取原始数据
        val studentDF = spark.sql(
          """
            |SELECT * 
            |FROM tb_student_score
            |WHERE id IS NOT NULL AND math IS NOT NULL AND year IS NOT NULL
          """.stripMargin)
        
        // 开始进行分析
        val resultRDD = studentDF.rdd
          .map(row => {
            val id = row.getLong(row.fieldIndex("id"))
            val math = row.getInt(row.fieldIndex("math"))
            val year = row.getInt(row.fieldIndex("year"))
    
            (year, (id, math))
          })
          .groupByKey() // 按年分组
          .mapValues(_.toSeq.sortWith(_._2 > _._2).take(100)) // 根据math对每个人进行降序排序,最后获取前100的人
        
        // 触发Action,展示部分统计结果
        resultRDD.take(10).foreach(println)
    
        spark.stop()
      }
    
    }
    
    • 首先,可以肯定的是代码逻辑毫无问题,能够满足业务需求。
    • 其次,这部分代码又存在很大的性能问题:
      1. spark.sql("SELECT * FROM tb_student_score")这种形势读取表中数据较慢,有更快的方式
      2. groupByKey处,发生shuffle,大量数据被分到对应的年份的节点中,然后每个节点使用单线程在各年对应的所有数据中对学生进行排序,最后获取前100名
      3. groupByKey处的shuffle可能发生数据倾斜,可能存在部分年份的数据不全或参考人数较少,而部分年份数据较多
    • 另外,直接使用SQL的方案已附在文章末尾

    2.3 如何解决代码中的问题?

    • 首先,读取表可以采用DataFrame的API,指定Schema,能够加速表的读取
    	val tbSchema = StructType(Array(
    	  StructField("id", LongType, true),
    	  StructField("chinese", IntegerType, true),
    	  StructField("math", IntegerType, true),
    	  StructField("english", IntegerType, true),
    	  StructField("year", IntegerType, true)
    	))
    	
    	// 获取原始数据
    	val studentDF = spark.read.schema(tbSchema).table("tb_student_score")
    	      .where("id IS NOT NULL AND math IS NOT NULL AND year IS NOT NULL")
    
    • 其次,关于groupBy发生shuffle的问题以及排序的问题。似乎数据如果不按年份分组,针对每年所有的分数统一排序,就没有其他办法。因为待排序的数据不在一起好像就不能完整的排序啊?那还怎么谈取前100名啊?
    • 其实不然,想想我们是不是可以先在每个数据分块本地排序一次获取前100名,最后将所有的前100汇总,进行一次总的排序获取总的前100名?这样的话,充分利用了每个分块的并行计算,提前做了部分排序,当数据shuffle的时候每个分块数据就只有100条,最后汇总进行一次排序的数据量就非常小了!其实这就是归并排序的思想,感兴趣的朋友可以搜索‘归并排序’看看。
    • 优化后的示例代码如下:
    	// 开始进行分析
        val resultRDD = studentDF.rdd
          .mapPartitions {
            // 自己实现时,如果为了性能更好,不建议这样的函数式写法
            // 这里只是为了方便看
            _.map { row =>
              val id = row.getLong(row.fieldIndex("id"))
              val math = row.getInt(row.fieldIndex("math"))
              val year = row.getInt(row.fieldIndex("year"))
    
              (year, (id, math))
            }.toArray
              .groupBy(_._1) // 先在每个分块前,获取历年的数学前100名,减少后续groupBy的shuffle数据量
              .mapValues(_.map(_._2).sortWith(_._2 > _._2).take(100))
              .toIterator
          }.groupByKey() // 最后获取所有分块的前100名,再次排序,计算总的前100名
           .mapValues(_.flatten.toSeq.sortWith(_._2 > _._2).take(100))
        
        // 触发Action,展示部分统计结果
        resultRDD.take(10).foreach(println)
    
    • 上述代码,已经完成功能实现。那么,这样的代码是否是最好的呢?答案是否定的。因为当前的排序是针对每个分块(Partition)的,一个Executor上有多个分块,每个分块有前100条数据需要shuffle,显然如果一个Executor一共只有100条数据需要shuffle才是最理想的!如果我们能有办法同时操纵每个Executor上的所有数据,获取前100条数据,那该多好啊!

    • 我们想要的排序流程示意图如下:
      在这里插入图片描述

    • 然而,Spark并没提供一个类似mapPartition的可以对Executor上所有分块统一操作的算子(不然的话,我们就可以像mapPartion那样统计每Executor的前100名了)。不过我们有一个算子reduceByKey,它会在每个节点合并数据后再shuffle到一个节点进行最后的合并,这种行为似乎与我们需要的逻辑类似,不过好像又有那么一点不一样。

    • 你可能会说reduceByKey是合并,而我们的需求是排序啊!!!是的,这看上去似乎有点矛盾。

    • 事实上,这样是行得通的:

      1. 首先,让我们假想有这样一个集合类型A(内部是可排序的,并且只能拥有前100的数据,多余的会被删除)
      2. 接着,把每个元素(id,math)转换成含有一个元素的集合A
      3. 最后,使用reduceByKey,将每个集合依次相加合并!!!没错!就是合并!这样最后一个集合就是包含前100名的集合了。
    • 这样一个集合类型A,似乎在Scala、Java中不存在,不过有一个TreeSet能保证内部有序,我们可以在数据合并后手动提取前100,这样就可以了(另外,你也可以自己实现这样一个集合:3)

    • 第一步,先将id和math转为一个对象,并为这个对象实现equals、hashCode、compareTo方法,保证后续在TreeSet中的排序不会出问题。另外,再实现一个toString方法,方便我们查看打印效果!:)

      • Person.class 代码 (因为Java比较易懂、易写这几个方法,这里优先采用Java的形式,后面会附上Scala对应的实现类)
      public class Person implements Comparable<Person>, Serializable {
      
          private long id;
      
          private int math;
      
          public Person(long id, int math) {
              this.id = id;
              this.math = math;
          }
      
          @Override
          public int compareTo(Person person) {
              int result = person.math - this.math; // 降序
              if (result == 0) {
                  result = person.id - this.id > 0 ? 1 : -1;
              }
              return result;
          }
      
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
      
              Person person = (Person) o;
      
              return id == person.id;
          }
      
          @Override
          public int hashCode() {
              return (int) (id ^ (id >>> 32));
          }
      
          @Override
          public String toString() {
              return "Person{" +
                      "id='" + id + '\'' +
                      ", math=" + math +
                      '}';
          }
      
      }
      
      • TreeSet 使用示例
      import scala.collection.immutable.TreeSet
      
      object Demo {
      
        def main(args: Array[String]): Unit = {
          val set = TreeSet[Person](
            new Person(1231232L, 108),
            new Person(3214124L, 116),
            new Person(1321313L, 121),
            new Person(6435235L, 125)
          )
      
          // 获取前3名
          for (elem <- set.take(3)) {
            println(s"--> elem = $elem")
          }
        }
      
      }
      
    • 第二步,将原先的id、math封装为TreeSet

    	studentDF.rdd
          .map(row => {
            val id = row.getLong(row.fieldIndex("id"))
            val math = row.getInt(row.fieldIndex("math"))
            val year = row.getInt(row.fieldIndex("year"))
    
            (year, TreeSet(new Person(id, math)))
          })
    
    • 最后,使用reduceByKey合并所有数据,得到前100名的结果
        val resultRDD = studentDF.rdd
          .map(row => {
            val id = row.getLong(row.fieldIndex("id"))
            val math = row.getInt(row.fieldIndex("math"))
            val year = row.getInt(row.fieldIndex("year"))
    
            (year, TreeSet(new Person(id, math)))
          })
          .reduceByKey((set1, set2) => set1 ++ set2 take 100)  // 依次合并2个Set,并只保留前100
    
        resultRDD.take(10).foreach(println)
    
    • Nice!!! 这样,我们就同时解决了排序问题和数据倾斜问题!
    • 进一步优化(aggregateByKey)
      • 细心的朋友应该已经发现了,reduceByKey之前的map为每条的数据都生成了一个TreeSet,这样会大大增加内存消耗。
      • 其实,我们只想要每个节点放一个可变的TreeSet(并且还能一直只存前100)。这样内存消耗就会更小!
      • 那么我们该如何做呢?设计一个MyTreeSet,采用aggregateByKey复用同一个Set,简略的示例如下:
      • MyTreeSet(简易实现,针对mutable.TreeSet封装)
        import scala.collection.mutable
        
        class MyTreeSet[A](firstNum: Int, elem: Seq[A])(implicit val ord: Ordering[A]) {
        
          val set: mutable.TreeSet[A] = mutable.TreeSet[A](elem: _*)
        
          def +=(elem: A): MyTreeSet[A] = {
            this add elem
        
            this
          }
        
          def add(elem: A): Unit = {
            set.add(elem)
        
            // 删除排在最后的多余元素
            check10Size()
          }
        
          def ++=(that: MyTreeSet[A]) : MyTreeSet[A] = {
            that.set.foreach(e => this add e)
        
            this
          }
        
          def check10Size(): Unit = {
            // 如果超过了firstNum个,就删除
            if (set.size > firstNum) {
              set -= set.last
            }
          }
        
          override def toString: String = set.toString
        }
        
        object MyTreeSet {
        
          def apply[A](elem: A*)(implicit ord: Ordering[A]): MyTreeSet[A] = new MyTreeSet[A](10, elem) // 默认保留前10
          
          def apply[A](firstNum: Int, elem: A*)(implicit ord: Ordering[A]): MyTreeSet[A] = new MyTreeSet[A](firstNum, elem)
          
        }
        
      • Spark部分代码
          val resultRDD = studentDF.rdd
              .map(row => {
                val id = row.getLong(row.fieldIndex("id"))
                val math = row.getInt(row.fieldIndex("math"))
                val year = row.getInt(row.fieldIndex("year"))
        
                (year, new Person(id, math))
              }).aggregateByKey(MyTreeSet[Person](100)) (
                  (set, v) => set += v,
                  (set1, set2) => set1 ++= set2
              )
        

    2.4 最终代码,以及其他附件代码

    • 最终代码
      import org.apache.spark.SparkConf
      import org.apache.spark.sql.SparkSession
      import org.apache.spark.sql.types.{IntegerType, LongType, StructField, StructType}
      
      import scala.collection.immutable.TreeSet
      
      object GroupDemo3 {
      
        def main(args: Array[String]): Unit = {
          val conf = new SparkConf().setAppName("GroupDemo")
          val spark = SparkSession.builder()
            .config(conf)
            .enableHiveSupport()
            .getOrCreate()
      
          val tbSchema = StructType(Array(
            StructField("id", LongType, true),
            StructField("chinese", IntegerType, true),
            StructField("math", IntegerType, true),
            StructField("english", IntegerType, true),
            StructField("year", IntegerType, true)
          ))
      
          // 获取原始数据
          val studentDF = spark.read.schema(tbSchema).table("tb_student_score")
            .where("id IS NOT NULL AND math IS NOT NULL AND year IS NOT NULL")
      
          // 开始进行分析
          val resultRDD = studentDF.rdd
            .map(row => {
              val id = row.getLong(row.fieldIndex("id"))
              val math = row.getInt(row.fieldIndex("math"))
              val year = row.getInt(row.fieldIndex("year"))
      
              (year, new Person(id, math))
            }).aggregateByKey(MyTreeSet[Person](100)) (
                (set, v) => set += v,
                (set1, set2) => set1 ++= set2
            ) // 依次合并2个Set,并只保留前100
      
          // 触发Action,展示部分统计结果
          resultRDD.take(10).foreach(println)
      
          spark.stop()
        }
      
      }
      
    • Person的Scala实现
      class PersonScala(val id: Long, val math: Int) extends Ordered[PersonScala]  with Serializable {
      
        override def compare(that: PersonScala): Int = {
          var result = that.math - this.math // 降序
          if (result == 0)
            result = if (that.id - this.id > 0) 1 else -1
          result
        }
      
        override def equals(obj: Any): Boolean = {
          obj match {
            case person: PersonScala => this.id == person.id
            case _ => false
          }
        }
      
        override def hashCode(): Int = (id ^ (id >>> 32)).toInt
      
        override def toString: String = "Person{" + "id=" + id + ", math=" + math + '}'
      
      }
      
      object PersonScala {
      
        def apply(id: Long, math: Int): PersonScala = new PersonScala(id, math)
      
      }
      
    • 示例——使用SQL获取历年数学的前100名(简单,但性能一般,且存在数据倾斜的可能)
        def main(args: Array[String]): Unit = {
          val conf = new SparkConf().setAppName("GroupDemo")
          val spark = SparkSession.builder()
            .config(conf)
            .enableHiveSupport()
            .getOrCreate()
          
          // 使用sql分析
          val resultDF = spark.sql(
            """
              |SELECT year,id,math
              |FROM (
              | SELECT year,id,math,ROW_NUMBER() OVER (PARTITION BY year ORDER BY math DESC) rank 
              | FROM tb_student_score
              |) g
              |WHERE g.rank <= 100
            """.stripMargin)
          
          // 触发Action,展示部分统计结果
          resultDF.show()
      
          spark.stop()
        }
      
    展开全文
  • SQL中GROUP BY/left join用法示例

    千次阅读 2019-11-06 15:58:20
    SQL中GROUP BY用法示例 概述 GROUP BY我们可以先从字面上来理解,GROUP表示分组,BY后面写字段名,就表示根据哪个字段进行分组,如果有用Excel比较多的话,GROUP BY比较类似Excel里面的透视表。 GROUP BY必须得配合...

    SQL中GROUP BY用法示例

    原文链接:https://www.jianshu.com/p/9f0a49c04bce

    概述

    GROUP BY我们可以先从字面上来理解,GROUP表示分组,BY后面写字段名,就表示根据哪个字段进行分组,如果有用Excel比较多的话,GROUP BY比较类似Excel里面的透视表。
    GROUP BY必须得配合聚合函数来用,分组之后你可以计数(COUNT),求和(SUM),求平均数(AVG)等。
    聚合函数目前只能对数值型(int,float)进行计算,非数值型(字符串)可以自定义函数计算

    常用聚合函数

    count() 计数
    sum() 求和
    avg() 平均数
    max() 最大值
    min() 最小值

    语法

    SELECT column_name, aggregate_function(column_name)
    FROM table_name
    WHERE column_name operator value
    GROUP BY column_name;
    

    例子

    下图是员工在职时间表 dept_emp共四个字段,分别是emp_no(员工编号),dept_no(部门编号),from_date(起始时间),to_date(结束时间),记录了员工在某一部门所处时间段,to_date等于9999-01-01的表示目前还在职。
    员工任职时间表
    如果想统计每个部门有多少名在职员工,步骤如下:
    1.筛选在职员工 where to_date=‘9999-01-01’;
    2.对部门进行分组group by dept_no
    3.对员工进行计数 count(emp_no)

    SELECT
      dept_no as 部门,
      count(emp_no) as 人数
    FROM
      dept_emp 
    WHERE
      to_date = '9999-01-01' 
    GROUP BY
      dept_no
    

    结果
    在这里插入图片描述

    进一步获取部门编号对应的部门名称

    另外一张表departments具有字段dept_name、dept_no

    SELECT
        ( SELECT d.dept_name FROM departments d WHERE de.dept_no = d.dept_no ) AS 部门,
        count( de.emp_no ) AS 人数 
    FROM
        dept_emp de 
    WHERE
        de.to_date = '9999-01-01' 
    GROUP BY
        de.dept_no
    

    结果
    在这里插入图片描述

    HAVING

    where是聚合前的筛选,having是聚合后对筛选
    举个例子:
    每个部门人数都有了,那如果我们想要进一步知道员工人数大于30000的部门是哪些,这个时候就得用到HAVING了。
    语句如下:

    SELECT
        ( SELECT d.dept_name FROM departments d WHERE de.dept_no = d.dept_no ) AS 部门,
        count( de.emp_no ) AS 人数 
    FROM
        dept_emp de 
    WHERE
        de.to_date = '9999-01-01' 
    GROUP BY
        de.dept_no
    HAVING
        count( de.emp_no ) > 30000 
    

    结果
    在这里插入图片描述

    联合

    现在有一张表titles,共有4个字段,分别是emp_no(员工编号),title(职位),from_date(起始时间),to_date(结束时间),记录的是员工在某个时间段内职位名称,因为会存在升职,转岗之类的,里面emp_no可能会对应多个职位,我们现在要取到所有员工最近的职位信息,包括离职员工。

    本文介绍两种方法去实现结果:

    方法一

    嵌套一个group by、聚合函数max()子查询获取最近的职位信息。

    思路
    1.通过对emp_no分组取每个emp_no对应的最大的from_date;

    SELECT
        emp_no,
        max( from_date ) AS max_date 
    FROM
        titles 
    GROUP BY
        emp_no
    

    在这里插入图片描述
    2.通过查询出来的最大的from_date取筛选最近的的一条职位信息。

    SELECT
        t.emp_no,
        t.title 
    FROM
        titles t
        LEFT JOIN ( SELECT emp_no, max( from_date ) AS max_date FROM titles GROUP BY emp_no ) et 
    ON t.emp_no = et.emp_no AND t.from_date = et.max_date
    

    嵌套语句编写时先测试最里层的结果

    展开全文
  • python中groupby()函数讲解与示例

    万次阅读 多人点赞 2017-12-10 10:15:50
    python中groupby()函数讲解与示例
    # -*- coding: utf-8 -*-
    import pandas as pd
    import  numpy as np
    
    df = pd.DataFrame({'key1':list('aabba'),
                      'key2': ['one','two','one','two','one'],
                      'data1': ['1','3','5','7','9'],
                      'data2': ['2','4','6','8','10']})
    print df
    
    grouped = df.groupby(['key1']).size()      #按key1的值分组,并统计个数
    print grouped
    print '++++++++++++++'
    
    grouped1 = df['data1'].astype(float).groupby(df['key1']).mean()     #先将data1转换成浮点型,然后分组求均值
    print grouped1
    print type(grouped1)       #series类型
    print '++++++++++++++++++'
    
    df['add'] = ['AA','BB',"CC",'DD','EE']       #dataframe追加一列
    print df
    grouped2=df.groupby(['key1','key2']).size()      #按两列属性分组
    #注意若groupby前面用df的形式则后面参数直接用['key1']的形式
    print grouped2
    print type(grouped2)
    print '++++++++++++++++++'
    
    grouped3=df['data1'].astype(float).groupby([df['key1'],df['add']]).mean()  #按key1与key2分组,求data1这一列均值
    #注意若groupby前面用df['data1']的形式则后面参数必须用df['key1']的形式
    print grouped3
    print type(grouped3)          #series
    
    
    
    
    运行结果如下:
      data1 data2 key1 key2
    0     1     2    a  one
    1     3     4    a  two
    2     5     6    b  one
    3     7     8    b  two
    4     9    10    a  one
    key1
    a    3
    b    2
    dtype: int64
    ++++++++++++++
    key1
    a    4.333333
    b    6.000000
    Name: data1, dtype: float64
    <class 'pandas.core.series.Series'>
    ++++++++++++++++++
      data1 data2 key1 key2 add
    0     1     2    a  one  AA
    1     3     4    a  two  BB
    2     5     6    b  one  CC
    3     7     8    b  two  DD
    4     9    10    a  one  EE
    key1  key2
    a     one     2
          two     1
    b     one     1
          two     1
    dtype: int64
    <class 'pandas.core.series.Series'>
    ++++++++++++++++++
    key1  add
    a     AA     1.0
          BB     3.0
          EE     9.0
    b     CC     5.0
          DD     7.0
    Name: data1, dtype: float64
    <class 'pandas.core.series.Series'>
    
    展开全文
  • mysql中group by的使用示例------聚合分组.pdf
  • GROUP BY 子句的语法和使用示例

    千次阅读 2018-07-26 10:56:21
    GROUP BY 用于归纳汇总相关数据。 GROUP BY 子句可以直接在FROM之后,也可以在WHERE条件后面。 GROUP BY子句经常和函数一起使用。(COUNT,AVG,SUM等)。 GROUP BY是统计数据时候常用的子句,使用的时候有几点...
  • MySQL中group_concat函数,完整的语法如下: 代码如下:group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’]) 基本查询 代码如下:select * from aa; 代码如下:+——+——+|...
  • SQL中GROUP BY语句介绍

    万次阅读 多人点赞 2018-12-27 10:21:16
    本文主要介绍 SQL(Structured Query Language)中 GROUP BY 语句的相关知识,同时通过用法示例介绍 GROUP BY 语句的常见用法。 1 概述 GROUP BY 语句通常用于配合聚合函数(如 COUNT()、MAX() 等),根据一个或多...
  • # select site as '数目' from demo group by site having count(*)=1; 说明:count(*)=1 表示筛选出分组后,组内元素个数为1的组。
  • 主要介绍了详解partition bygroup by对比,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 功能:将group by产生的同一个分组中的值连接起来,返回一个字符串结果。 函数语法: group_concat( [DISTINCT] 要连接的字段 [Order BY 排序字段 ASC/DESC] [Separator ‘分隔符’] ) 示例 查询文章列表,将同一...
  • 基本共识:进行groupby时,groupby中的字段可以不出现在select中,但是select中只能有groupby中的字段和函数. 但如下示例sql,依然能正常执行: 数据表: 执行如下sql,发现能正常执行,而且groupby后默认取每组第一条...
  • Group BY

    2015-07-29 17:28:33
    Group By”从字面意义上理解就是根据“By”指定的规则对数据进行分组,所谓的分组就是将一个“数据集”划分成若干个“小区域”,然后针对若干个“小区域”进行数据处理。 2、原始表 3、简单Group By 示例...
  • order by:全局排序 order by 会对数据进行一次全局排序,所以说,只要hive的sql中指定了order by,那么所有的数据都会到同一个reducer进行处理(不管有多少map,也不管文件有多少的block只会启动一个reducer)。 ...
  • MySQL优化GROUP BY方案

    2020-12-15 12:27:56
    执行GROUP BY子句的最一般的方法:先扫描整个表,然后创建一个新的临时表,表中每个组的所有行应为连续的,最后使用该临时表来找到组并应用聚集函数(如果有聚集函数)。在某些情况中,MySQL通过访问索引就可以得到...
  • postgreSQL GROUP BY

    千次阅读 2016-09-06 09:37:20
    postgreSQL GROUP BY HAVING

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 105,004
精华内容 42,001
关键字:

bygroup示例