SELECT 分组、排序与分页

最新推荐文章于 2023-06-07 20:22:03 发布
最新推荐文章于 2023-06-07 20:22:03 发布
阅读量850 收藏
点赞数
分类专栏： go语言基础 go 实战开发 文章标签： 数据库 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48943299/article/details/129941315
版权

SELECT 分组、排序与分页

分组

常用的简单 SELECT 语句无疑包括了分组语法 GROUP BY 以及 分组后的条件过滤 HAVING，HAVING 的执行 由于在 WHERE、GROUP BY 和 聚合函数之后，所以 HAVING 也是支持聚合函数的 （DB中， 处理顺序是 WHERE - GROUP BY - 聚合函数 - HAVING；）。
image.png

GROUP BY 构造

同样限定 Column，这样就能执行校验 ；

// Selector 用于构造 SELECT 语句
type Selector[T any] struct {
	sb      strings.Builder
	args    []any
	table   string
	where   []Predicate
	model   *model.Model
	db      *DB
	columns []Selectable
	groupBy []Column  // 增加 group by
}

// GroupBy 设置 group by 子句
func (s *Selector[T]) GroupBy(cols ...Column) *Selector[T] {
	s.groupBy = cols
	return s
}

改造 Selector 增加对 group by 的判断

func (s *Selector[T]) Build() (*Query, error) {
	var (
		t   T
		err error
	)
	s.model, err = s.db.r.Get(&t)
	if err != nil {
		return nil, err
	}
	s.sb.WriteString("SELECT ")
	if err = s.buildColumns(); err != nil {
		return nil, err
	}
	s.sb.WriteString(" FROM ")
	if s.table == "" {
		s.sb.WriteByte('`')
		s.sb.WriteString(s.model.TableName)
		s.sb.WriteByte('`')
	} else {
		s.sb.WriteString(s.table)
	}

	// 构造 WHERE
	if len(s.where) > 0 {
		// 类似这种可有可无的部分，都要在前面加一个空格
		s.sb.WriteString(" WHERE ")
		// WHERE 是不允许用别名的
		if err = s.buildPredicates(s.where); err != nil {
			return nil, err
		}
	}

    // group by 分组
	if len(s.groupBy) > 0 {
		s.sb.WriteString(" GROUP BY ")
		for i, c := range s.groupBy {
			if i > 0 {
				s.sb.WriteByte(',')
			}
			if err = s.buildColumn(c, false); err != nil {
				return nil, err
			}
		}
	}

	s.sb.WriteString(";")
	return &Query{
		SQL:  s.sb.String(),
		Args: s.args,
	}, nil
}
HAVING 构造

HAVING 和 WHERE 其实非常像，但是也有区别： HAVING 的查询条件里面，可以使用聚合函数。 所以整体上，可以复用 WHERE 那部分代码

// Selector 用于构造 SELECT 语句
type Selector[T any] struct {
	sb      strings.Builder
	args    []any
	table   string
	where   []Predicate
	having  []Predicate // 增加 having
	model   *model.Model
	db      *DB
	columns []Selectable
	groupBy []Column
}

func (s *Selector[T]) Build() (*Query, error) {
	var (
		t   T
		err error
	)
	s.model, err = s.db.r.Get(&t)
	if err != nil {
		return nil, err
	}
	s.sb.WriteString("SELECT ")
	if err = s.buildColumns(); err != nil {
		return nil, err
	}
	s.sb.WriteString(" FROM ")
	if s.table == "" {
		s.sb.WriteByte('`')
		s.sb.WriteString(s.model.TableName)
		s.sb.WriteByte('`')
	} else {
		s.sb.WriteString(s.table)
	}

	// 构造 WHERE
	if len(s.where) > 0 {
		// 类似这种可有可无的部分，都要在前面加一个空格
		s.sb.WriteString(" WHERE ")
		p := s.where[0]
		for i := 1; i < len(s.where); i++ {
			p = p.And(s.where[i])
		}
		if err = s.buildExpression(p); err != nil {
			return nil, err
		}
	}

	if len(s.groupBy) > 0 {
		s.sb.WriteString(" GROUP BY ")
		for i, c := range s.groupBy {
			if i > 0 {
				s.sb.WriteByte(',')
			}
			if err = s.buildColumn(c, false); err != nil {
				return nil, err
			}
		}
	}

    // having 过滤
	if len(s.having) > 0 {
		s.sb.WriteString(" HAVING ")
		// HAVING 是可以用别名的
		p := s.having[0]
		for i := 1; i < len(s.having); i++ {
			p = p.And(s.having[i])
		}
		if err = s.buildExpression(p); err != nil {
			return nil, err
		}
	}

	s.sb.WriteString(";")
	return &Query{
		SQL:  s.sb.String(),
		Args: s.args,
	}, nil
}


func (s *Selector[T]) Having(ps ...Predicate) *Selector[T] {
	s.having = ps
	return s
}
HAVING 支持聚合函

基本上可以参考 Column 的设计，在 Aggregate 上也设计代表 >, >= , <, 的方法

// Aggregate 实现 Expression 接口
func (a Aggregate) expr() {}

// EQ 例如 C("id").Eq(12)
func (a Aggregate) EQ(arg any) Predicate {
	return Predicate{
		left:  a,
		op:    opEQ,
		right: exprOf(arg),
	}
}

func (a Aggregate) LT(arg any) Predicate {
	return Predicate{
		left:  a,
		op:    opLT,
		right: exprOf(arg),
	}
}

func (a Aggregate) GT(arg any) Predicate {
	return Predicate{
		left:  a,
		op:    opGT,
		right: exprOf(arg),
	}
}

** 提取 Aggregate 公共代码 **

func (s *Selector[T]) buildAggregate(a Aggregate, useAlias bool) error {
	s.sb.WriteString(a.fn)
	s.sb.WriteString("(`")
	fd, ok := s.model.FieldMap[a.arg]
	if !ok {
		return errs.NewErrUnknownField(a.arg)
	}
	s.sb.WriteString(fd.ColName)
	s.sb.WriteString("`)")
	if useAlias {
		s.buildAs(a.alias)
	}
	return nil
}

提取 Column 公共代码

func (s *Selector[T]) buildColumn(c Column, useAlias bool) error {
	s.sb.WriteByte('`')
	fd, ok := s.model.FieldMap[c.name]
	if !ok {
		return errs.NewErrUnknownField(c.name)
	}
	s.sb.WriteString(fd.ColName)
	s.sb.WriteByte('`')
	if useAlias {
		s.buildAs(c.alias)
	}
	return nil
}

提取 WHERE 和 HAVING 的公共部分

func (s *Selector[T]) buildPredicates(ps []Predicate) error {
	p := ps[0]
	for i := 1; i < len(ps); i++ {
		p = p.And(ps[i])
	}
	return s.buildExpression(p)
}

func (s *Selector[T]) Build() (*Query, error) {
	var (
		t   T
		err error
	)
	s.model, err = s.db.r.Get(&t)
	if err != nil {
		return nil, err
	}
	s.sb.WriteString("SELECT ")
	if err = s.buildColumns(); err != nil {
		return nil, err
	}
	s.sb.WriteString(" FROM ")
	if s.table == "" {
		s.sb.WriteByte('`')
		s.sb.WriteString(s.model.TableName)
		s.sb.WriteByte('`')
	} else {
		s.sb.WriteString(s.table)
	}

	// 构造 WHERE
	if len(s.where) > 0 {
		// 类似这种可有可无的部分，都要在前面加一个空格
		s.sb.WriteString(" WHERE ")
		// WHERE 是不允许用别名的
		if err = s.buildPredicates(s.where); err != nil {
			return nil, err
		}
	}

	if len(s.groupBy) > 0 {
		s.sb.WriteString(" GROUP BY ")
		for i, c := range s.groupBy {
			if i > 0 {
				s.sb.WriteByte(',')
			}
			if err = s.buildColumn(c, false); err != nil {
				return nil, err
			}
		}
	}
	// 构造 having
	if len(s.having) > 0 {
		s.sb.WriteString(" HAVING ")
		// HAVING 是可以用别名的
		if err = s.buildPredicates(s.having); err != nil {
			return nil, err
		}
	}

	s.sb.WriteString(";")
	return &Query{
		SQL:  s.sb.String(),
		Args: s.args,
	}, nil
}

**HAVING 中要不要支持直接用别名做查询条件？ **
现在还有一个问题要处理，在 HAVING 中使用 SELECT 中出现的别名 ，这里不会支持这种写法，因为它带来的收益 很有限，但是会极大的破坏代码的美感。

排序

ORDER BY

ORDER BY 语法也是在日常开发中常用的语法，本文的排序方法可以参考上面的分组方法的方式构建

// Selector 用于构造 SELECT 语句
type Selector[T any] struct {
	sb      strings.Builder
	args    []any
	table   string
	where   []Predicate
	having  []Predicate
	model   *model.Model
	db      *DB
	columns []Selectable
	groupBy []Column
	orderBy []OrderBy
	offset  int
	limit   int
}

func (s *Selector[T]) OrderBy(orderBys...OrderBy) *Selector[T] {
	s.orderBy = orderBys
	return s
}

func (s *Selector[T]) buildOrderBy() error {
	for idx, ob := range s.orderBy {
		if idx > 0 {
			s.sb.WriteByte(',')
		}
		err := s.buildColumn(ob.col, "")
		if err != nil {
			return err
		}
		s.sb.WriteByte(' ')
		s.sb.WriteString(ob.order)
	}
	return nil

分页

Offset 和 Limi

在 MySQL 中，典型的分页查询是 Limit x, y。x 是 偏移量，y 是目标数量。 例如 Limit 10, 20 是指从偏移量 10 开始往后取 20 条数据。 而实际上标准 SQL 的写法是 LIMIT y OFFSET
image.png

// Selector 用于构造 SELECT 语句
type Selector[T any] struct {
	sb      strings.Builder
	args    []any
	table   string
	where   []Predicate
	having  []Predicate
	model   *model.Model
	db      *DB
	columns []Selectable
	groupBy []Column
    orderBy []OrderBy
	offset  int
	limit   int
}

func (s *Selector[T]) Build() (*Query, error) {
	var (
		t   T
		err error
	)
	s.model, err = s.db.r.Get(&t)
	if err != nil {
		return nil, err
	}
	s.sb.WriteString("SELECT ")
	if err = s.buildColumns(); err != nil {
		return nil, err
	}
	s.sb.WriteString(" FROM ")
	if s.table == "" {
		s.sb.WriteByte('`')
		s.sb.WriteString(s.model.TableName)
		s.sb.WriteByte('`')
	} else {
		s.sb.WriteString(s.table)
	}

	// 构造 WHERE
	if len(s.where) > 0 {
		// 类似这种可有可无的部分，都要在前面加一个空格
		s.sb.WriteString(" WHERE ")
		// WHERE 是不允许用别名的
		if err = s.buildPredicates(s.where); err != nil {
			return nil, err
		}
	}

	if len(s.groupBy) > 0 {
		s.sb.WriteString(" GROUP BY ")
		for i, c := range s.groupBy {
			if i > 0 {
				s.sb.WriteByte(',')
			}
			if err = s.buildColumn(c, false); err != nil {
				return nil, err
			}
		}
	}

	if len(s.having) > 0 {
		s.sb.WriteString(" HAVING ")
		// HAVING 是可以用别名的
		if err = s.buildPredicates(s.having); err != nil {
			return nil, err
		}
	}
	// 构造 orderby
    if len(s.orderBy) > 0 {
		s.sb.WriteString(" ORDER BY ")
		if err = s.buildOrderBy(); err != nil {
			return nil, err
		}
	}

	if s.limit > 0 {
		s.sb.WriteString(" LIMIT ?")
		s.addArgs(s.limit)
	}

	if s.offset > 0 {
		s.sb.WriteString(" OFFSET ?")
		s.addArgs(s.offset)
	}

	s.sb.WriteString(";")
	return &Query{
		SQL:  s.sb.String(),
		Args: s.args,
	}, nil
}

func (s *Selector[T]) Offset(offset int) *Selector[T] {
	s.offset = offset
	return s
}

func (s *Selector[T]) Limit(limit int) *Selector[T] {
	s.limit = limit
	return s
}
vicent_uuid4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MySQL中select语句使用order按行排序
12-15
在实际应用中，`ORDER BY`经常与`GROUP BY`一起使用，对分组后的数据进行排序。此外，还可以使用`LIMIT`子句限制返回的行数，实现分页查询的效果。 例如，如果你想获取每个部门员工薪水的最高者，可以先按照部门...
select之分页查询
Lovely_red_scarf的博客
07-22 2542
应用场景 应用场景：当要显示的数据，一页显示不全，需要分页提交sql请求 语法 select 查询列表 from 表 【join type】 join 表2 on 连接条件 where 筛选条件 group by 分组字段 having 分组后的筛选 order by 排序的字段】 limit 【offset,】size; offset要显示条目的起始索引（起始索引从0开始） size 要显示的条目个数 特点： ①limit语句放在查询语句的最后 ②公式: 要显示的
MySQL分页查询的5种方法
热门推荐
九尾狐的yi巴的博客
12-15 1万+
MySQL分页查询的5种方法
MySQL-分页查询
cycyong的博客
04-18 5863
应用场景：当要显示的数据，一页显示不全，需要分页提交sql请求。
select查询之分页查询
weixin_43945486的博客
08-02 1562
分页查询 当要显示的数据，一页显示不完，需要分页提交sql请求 limit放在整个查询语句的最后 limit offset, size offset要显示条目的起始索引（从0开始） size 要显示的条目个数 公式 （当前页数-1）* 每页条数，每页条数 案例 有奖金的员工信息，并且工资较高的前10名显示出来 select * from employees where commission_pct is not null order by salary desc limit 0,10; ...
MySQL select 查询的分页和排序
weixin_44953227的博客
09-22 8588
排序 语法：order by 要排序的字段 ASC/DESC -- 排序: 升序 ASC, 降序 DESC -- order by 要排序的字段 怎么排 -- 查询的结构根据 分数 降序 排 SELECT stu.`gradeid`,`name`,`subject`,`grade` FROM `student` stu INNER JOIN `result` res ON stu.`gradeid` = res.`gradeid` INNER JOIN `subject` sub ON stu.g.
sql-view:重写使用otions对象嵌入过滤器，排序，分组或分页的select语句
05-10
重写使用otions对象嵌入过滤器，订单，组或分页的select语句。 对于MS Sql Server和postgres 安装 $ npm install --save sql-view 用法 var sqlView = require ( 'sql-view' ) ( 'postgres' ) ; // build(view, ...
sqlserver+group by分组查询分页存储过程
07-16
根据给定的SQL Server存储过程代码片段，我们可以深入解析与SQL Server中的`GROUP BY`分组查询、存储过程以及分页技术相关的知识点。 ### SQL Server中的`GROUP BY`分组查询 `GROUP BY`子句在SQL查询语言中用于将...
AspNetPager分页控件 存储过程
09-11
下面是一个示例存储过程 `usp_PagingLarge`，它接受几个参数，如表名、主键、要选择的字段、每页记录数、当前页数、过滤条件、分组依据和排序方式。这个存储过程的目的是动态构建SQL查询语句，以便根据给定的参数...
SQL之SELECT FROM
02-20
12. `SELECT name, age FROM student LIMIT 10, 5`：LIMIT子句用于分页显示，这里表示从第11条记录开始，显示5条记录（第3页，每页5条）。 13. `SELECT name, age FROM student LIMIT 2 OFFSET 11`：OFFSET用于设定...
如何vue使用ant design Vue中的select组件实现下拉分页加载数据，并解决存在的一个问题。
前端开发小白9527
04-20 6965
如何vue使用ant design Vue中的select组件实现下拉分页加载数据，并解决存在的一个问题。
MySQL查询之分页查询
十三阿哥的博客
05-04 421
语法格式： SELECT 字段列表 FROM 表 ；注意： 1. 偏移量从默认从0开始，； 2. 如果查询的是第一页，那么偏移量可以省略，直接写为 LIMIT 记录数； 3. 分页查询是数据库的方言，不同数据库有不同的实现，MySQL中是LIMIT。
iview爬坑之旅——select分组（optionGroup）展示，允许多选情况下，组内元素只能单选
一个女胖子的博客
08-23 1144
需求描述：下拉选框select支持分组（OptionGroup）多选，组内元素只能选择一个，（组外元素支持多选，组内元素支持单选，不支持多选）； 解决方案 根据on-select 和on-change返回值不同，并且on-select的返回优先于on-change的返回时间的原理，得到本次选中的元素和本次返回的结果。在根据当前选中的id找到当前元素的兄弟元素，将除自己的兄弟元素从选中的集合中删除，从而达到组内单选的效果； <Select v-model="runGroupTagList" style=
select下拉框分组展示插件的使用--(select-mania插件的使用)
小流至江河的博客
01-09 4452
一、概述 在web项目中很多地方用到下拉框，原生的下拉框比较丑陋，之前的文章中介绍过一款用来美化下拉框的插件可以参考： 手把手教你--jquery chosen插件的使用和API(html下拉框美化）。 有时业务需要下拉框内容是分组显示，如显示部门名称和部门下人员名称，则需要使用<select> 、<optgroup>、<option>同时使用来达到效果，...
如何对select元素中的选项进行逻辑分组
飘零雾雨的专栏
09-29 1419
不知道大家有没有这样的感觉，在select选项足够多的时候，被select中的选项弄得头昏眼花，想要找一个自己想要的选项实在是太困难了。其实是可以对select里面的选项进行逻辑分组的。可以想象得到，如果对select的选项进行了分组，这对于有大量选项的select肯定是有好处的。至少用户体验会好很多，方便大家，何乐而不为呢？［演示地址：http://www.doyoe.com/m
select 下拉框分组
iteye_13425的博客
05-15 768
&lt;select&gt;   &lt;optgroup label="Swedish Cars"&gt;     &lt;option value="volvo"&gt;Volvo&lt;/option&gt;     &lt;option value="saab"&gt;Saab&lt;/option&gt;   &lt;/opt
Element的Select分组全选模式
weixin_45785873的博客
06-07 2217
在一些业务场景中，我们可能需要让下拉选择，支持分组的同时，支持全选，Element中的Select支持分组，但不支持全选，Cascader 级联选择器支持分组，也支持全选，但是他的显示不在同一垂直方向。因此，去修改Select，是比较方便和有效的方法。
select的placeholder和分组效果
QDY5945的博客
10-20 198
<!DOCTYPE html> <html lang="zh"> <head> <meta charset="UTF-8" /> <meta nam...
HTML 中 SELECT 选项分组
kemy88的专栏
01-26 2691
  选择排序/显示方式      按价格 从低到高    按价格 从高到低    按剩余时间 从少到多    按剩余时间 从多到少        列表方式    图片方式    纯文字方式        每页显示20个    每页显示40个    每页显示80个  纯属个人收藏。。 
sql查询有分组，排序，分页，聚合函数时，他们的顺序是什么
最新发布
01-09
在SQL查询中，当涉及到分组、排序、分页和聚合函数时，它们的顺序如下： 1. 分组（GROUP BY）：首先根据指定的列对查询结果进行分组。这样可以将具有相同值的行分为一组。 2. 聚合函数（例如SUM、COUNT、AVG等）：在每个分组内，对指定的列进行聚合计算，生成聚合结果。 3. 排序（ORDER BY）：对聚合结果或查询结果进行排序。可以按照指定的列进行升序或降序排序。 4. 分页（LIMIT）：最后，根据指定的页数和每页的行数，对排序后的结果进行分页显示。 下面是一个示例SQL查询，演示了这些步骤的顺序： ```sql SELECT column1, column2, aggregate_function(column3) FROM table_name GROUP BY column1 ORDER BY column2 DESC LIMIT 10; ``` 该查询首先根据column1列进行分组，然后对每个分组内的column3列应用聚合函数。接下来，根据column2列进行降序排序，并最后限制结果集为前10行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值