SELECT JOIN

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

SELECT JOIN

SQL 语法分析

JOIN 查询有点像我们的 Expression，就是可以 查询套查询无限套下去。

MySQL

image.png
image.png

SQLite

image.png
image.png
image.png

PostgreSQL

和 MySQL、SQLite 也差不多
image.png

JOIN 语法总结

** JOIN 语法有两种形态 **
image.png

  • JOIN … ON
  • JOIN … USING：USING 后面使用的是列

** JOIN 本身有：**

  • INNER JOIN， JOIN
  • LEFT JOIN，RIGHT JOIN

也就是说 JOIN 的结构大概可以描述成下面这几种，而且还可以嵌套。

  • 表 JOIN 表
  • （表 JOIN 表） JOIN 表
  • 表 JOIN 子查询
  • 子查询 JOIN 子查询

开源实例

Beego JOIN 查询

** Beego 的 JOIN 查询主要出现在两个地方 ：**
QueryBuilder 接口设计了 InnerJoin、LeftJoin 和 RightJoin 三个方法
image.png
Beego 本身支持一对一、一对多和多对多的关联关 系，所以如果设置了正确的关联关系，那么 Beego 在部分情况下会生成 JOIN 查

GROM JOIN 查询

GORM中 JOIN 查询主要是为了所谓的 Preload 而服务的
image.png

相关接口与方法的设计

实现简单的 JOIN 其实不怎么复杂，主要功能包括起别名、选择列、复杂一点的是 JOIN 可以嵌套。
常用的 JOIN 结构大概就是下面这几个：

  • 表 A JOIN 表 B ON …
  • 表 A AS 新名字 JOIN 表 B AS 新名字 ON …
  • 表 A JOIN (表 B JOIN 表 C ON …) ON …

之前处理 FROM 后面那个位置的时候是直接用的数据库表名，但是那个位置其实可以放的玩意有表名、JOIN、子查询，这明摆了是要有一个抽象的，官方文档也告诉你了，叫 table_references（这里叫表表达式）。但是这三种对象的处理方式肯定是不一样的，语句形态差的都很远，基本没有共同点。

TableReference 抽象

  • Table： 代表普通的表
  • Join：代表 JOIN 查询
  • Subquery：子查询

image.png

type TableReference interface {
	tableAlias() string
}

TableReference 可以在将来有需要的时候 不断增加方法。

JoinBuilder 和 Join 定义

image.png

var _ TableReference = Join{}

type JoinBuilder struct {
    left TableReference
    right TableReference
    typ string
}

type Join struct {
    left TableReference
    right TableReference
    typ string
    on []Predicate
    using []string
}

func (j Join) tableAlias() string {
	return ""
}

JoinBuilder 里面的 On 和 Using 是终结方法，也就是 直接返回了 Join , 这种设计可以避免用户同时调用 On 或者 Using。

func (j *JoinBuilder) On(ps...Predicate) Join {
	return Join {
		left: j.left,
		right: j.right,
		on: ps,
		typ: j.typ,
	}
}

func (j *JoinBuilder) Using(cs...string) Join {
	return Join {
		left: j.left,
		right: j.right,
		using: cs,
		typ: j.typ,
	}
}

JOIN 本身也可以进一步 JOIN，所以我们 同样需要在 Join 上面定义类似的方法。 同样地，子查询也可以用来构造 JOIN 查 询。

func (j Join) Join(target TableReference) *JoinBuilder {
	return &JoinBuilder{
		left:  j,
		right: target,
		typ:   "JOIN",
	}
}

func (j Join) LeftJoin(target TableReference) *JoinBuilder {
	return &JoinBuilder{
		left:  j,
		right: target,
		typ:   "LEFT JOIN",
	}
}

func (j Join) RightJoin(target TableReference) *JoinBuilder {
	return &JoinBuilder{
		left:  j,
		right: target,
		typ:   "RIGHT JOIN",
	}
}

Table ( 普通表 )

Table 代表一个普通的表，它也是 JOIN 查询的起点

type Table struct {
	entity any
	alias string
}

func TableOf(entity any) Table {
	return Table{
		entity: entity,
	}
}

func (t Table) tableAlias() string {
	return t.alias
}

func (t Table) As(alias string) Table {
	return Table {
		entity: t.entity,
		alias: alias,
	}
}

func (t Table) Join(target TableReference) *JoinBuilder {
	return &JoinBuilder{
		left: t,
		right: target,
		typ: "JOIN",
	}
}

func (t Table) LeftJoin(target TableReference) *JoinBuilder {
	return &JoinBuilder{
		left: t,
		right: target,
		typ: "LEFT JOIN",
	}
}

func (t Table) RightJoin(target TableReference) *JoinBuilder {
	return &JoinBuilder{
		left: t,
		right: target,
		typ: "RIGHT JOIN",
	}
}

重构 Selector

将 From 改为接收一个 TableReference 作为 输入，后续 subquery 同样可以复用这个方法。

func (s *Selector[T]) From(tbl TableReference) *Selector[T] {
	s.table = tbl
	return s
}
  • case nil : 如果用户没有调用 From 方法
  • case Table：用户传入了一个普通的表
  • case Join：是一个 Join 查询
func (s *Selector[T]) buildTable(table TableReference) error {
	switch tab := table.(type) {
	case nil:
		s.quote(s.model.TableName)
	case Table:
		m, err := s.r.Get(tab.entity)
		if err != nil {
			return err
		}
		s.quote(m.TableName)
		if tab.alias != "" {
			s.sb.WriteString(" AS ")
			s.quote(tab.alias)
		}
	case Join:
		return s.buildJoin(tab)
	default:
		return errs.NewErrUnsupportedExpressionType(tab)
	}
	return nil
}

func (s *Selector[T]) buildJoin(tab Join) error {
	s.sb.WriteByte('(')
	if err := s.buildTable(tab.left); err != nil {
		return err
	}
	s.sb.WriteString(" ")
	s.sb.WriteString(tab.typ)
	s.sb.WriteString(" ")
	if err := s.buildTable(tab.right); err != nil {
		return err
	}
	if len(tab.using) > 0 {
		s.sb.WriteString(" USING (")
		for i, col := range tab.using {
			if i > 0 {
				s.sb.WriteByte(',')
			}
			err := s.buildColumn(Column{name: col}, false)
			if err != nil {
				return err
			}
		}
		s.sb.WriteString(")")
	}
	if len(tab.on) > 0 {
		s.sb.WriteString(" ON ")
		err := s.buildPredicates(tab.on)
		if err != nil {
			return err
		}
	}
	s.sb.WriteByte(')')
	return nil
}

重构列校验逻辑

在原本不支持 JOIN 查询的时候，只需要 看一下操作的元数据里面有没有这个列。在支持了 JOIN 之后，那么所有的列、聚合函 数都可能有一个拥有者（owner）。 例如** t1.col1 其中 t1 就是 col1 的拥有者**。 那么校验逻辑就是：

  • **如果用户指定了表，那么就检查指定的表上 面有没有这个列 **
  • 如果没有指定表，就走老逻辑，也就是右图 case nil 的分支
func (s *Selector[T]) buildColumns() error {
	if len(s.columns) == 0 {
		s.sb.WriteByte('*')
		return nil
	}
	for i, c := range s.columns {
		if i > 0 {
			s.sb.WriteByte(',')
		}
		switch val := c.(type) {
		case Column:
            // buildColumn 方法
			if err := s.buildColumn(val, true); err != nil {
				return err
			}
		case Aggregate:
			if err := s.buildAggregate(val, true); err != nil {
				return err
			}
		case RawExpr:
			s.raw(val)
		default:
			return errs.NewErrUnsupportedSelectable(c)
		}
	}
	return nil
}

buildColumn 方法

func (s *Selector[T]) buildColumn(c Column, useAlias bool) error {
	err := s.builder.buildColumn(c.table, c.name)
	if err != nil {
		return err
	}
	if useAlias {
		s.buildAs(c.alias)
	}
	return nil
}

// buildColumn 构造列
// 如果 table 没有指定，我们就用 model 来判断列是否存在
func (b *builder) buildColumn(table TableReference, fd string) error {
	var alias string
	if table != nil {
		alias = table.tableAlias()
	}
	if alias != "" {
		b.quote(alias)
		b.sb.WriteByte('.')
	}
	colName, err := b.colName(table, fd)
	if err != nil {
		return err
	}
	b.quote(colName)
	return nil
}

func (b *builder) colName(table TableReference, fd string) (string, error) {
	switch tab := table.(type) {
	case nil:
		fdMeta, ok := b.model.FieldMap[fd]
		if !ok {
			return "", errs.NewErrUnknownField(fd)
		}
		return fdMeta.ColName, nil
	case Table:
		m, err := b.r.Get(tab.entity)
		if err != nil {
			return "", err
		}
		fdMeta, ok := m.FieldMap[fd]
		if !ok {
			return "", errs.NewErrUnknownField(fd)
		}
		return fdMeta.ColName, nil
	case Join:
		colName, err := b.colName(tab.left, fd)
		if err != nil {
			return colName, nil
		}
		return b.colName(tab.right, fd)
	default:
		return "", errs.NewErrUnsupportedExpressionType(tab)
	}
}

总结

  • GORM 的 Preload 是什么？本质上就是一个 JOIN 查询，并且严格来说，在 Go 语言里面是很难实现 lazy load的。GORM 的 Preload 就是通过 Join 把相关的数据都查询出来，并且组装成结构体 ；
  • WHERE、ON 和 HAVING 的区别：在 JOIN 查询里面，一般的建议 都是尽量把条件放到 ON 上面，这样 JOIN 生成的中间数据要少很多；
  • JOIN 的执行原理：可以近似理解为一个双重循环 。
vicent_uuid4
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
经典连接查询示例
雁南飞的专栏
07-05 1933
--查询分析器中执行：--建表table1,table2：create table table1(id int,name varchar(10))create table table2(id int,score int)insert into table1 select 1,leeinsert into table1 select 2,zhanginsert into table1 sel
SELECT 语句详解
fangsi1994_的博客
07-30 1046
一、实验简介 1.1 实验内容 SQL 中最常用的 SELECT 语句，用来在表中选取数据，本节实验中将通过一系列的动手操作详细学习 SELECT 语句的用法。 1.2 实验知识点 SELECT 基本语法 数学符号条件 AND OR IN 通配符 排序 SQL 内置函数和计算 子查询与连接查询 Your MySQL connection id is 42 Server v...
在 SELECT 查询中使用 JOIN 联接
weixin_34186931的博客
02-27 548
　　在 SELECT 语句中，如果 FROM 子句引用了多个表源或视图，可以使用 JOIN 指示指定的联接操作应在指定的表源或视图之间执行。一、交叉联接：CROSS JOIN 　　交叉联接将执行一个叉积（迪卡尔乘积），将一个表的每一行与另一个表的所有行进行匹配，生成一个虚拟表。如果一个表有5行，另一个表有6行，结果生成的虚拟表一共得到 5*6=30 行。（1） ANSI SQL-89 语法SELE...
SQL 基础：Select语句，各种join，union用法
depe16540458的博客
09-29 392
一、基本的SELECT语句 1. “*”的注意事项：在SELECT语句中，用*来选取所有的列，这是一个应该抵制的习惯。 虽然节省了输入列名的时间，但是也意味着获得的数据比真正需要的数据多的多。相应的，也会降低应用程序的性能及网络性能。 良好的规则是只选所需。 2. join子句 join是用来定义如何从多个表中选取数据并组合...
[ Hive ] Select查询.Join连接
jason_bone_的博客
04-07 1330
1 DQL-Select查询数据 1.1 语法树 [WITH CommonTableExpression (, CommonTableExpression)*] SELECT [ALL | DISTINCT] select_expr, select_expr, ... FROM table_reference [WHERE where_condition] [GROUP BY col_list] [ORDER BY col_list] [CLUSTER BY col_list
select语句详解（包括JOIN的用法等）
热门推荐
foreverhuylee的专栏
06-11 1万+
SELECT语句  (p106)    SELECT语句用来从数据库中检索满足特定条件的记录。一个SELECT语句主要包含如下几部分： 从哪个或哪些表或视图中提取数据 选取表中的哪些列 选择满足什么条件的数据 查询结果以什么顺序显示
SELECT执行顺序
张小牙的博客
01-22 639
关于SELECT执行顺序的问题! 收藏  最近准备数据库DBA的面试，碰到考察select语句执行顺序的问题，见附，回头查询了下王珊老师的《数据库系统概论》，里面给SELECT的定义格式为： SELECT[ALL|DISTINCT][，]… FROM[，]… [WHERE] [GROUP BY][HAVING] [ORDER BY][ASC|DESC] 文中其对SELECT语句的含义解释为
SELECT JOINS
01-20
SELECT JOIN 的用法，一眼明了
PostgreSQL SELECT 语句
12-16
- **JOIN操作**：允许合并两个或更多表中的数据，例如INNER JOIN, LEFT JOIN, RIGHT JOIN, FULL OUTER JOIN等。 - **子查询**：在SELECT语句中嵌套另一个查询，用于获取满足特定条件的数据。 了解并熟练掌握这些...
sql join on 用法
09-11
`SELECT * FROM table1 [LEFT/RIGHT/INNER] JOIN table2 ON table1.column_name = table2.column_name` 其中，`table1` 和 `table2` 是要连接的两个表，`column_name` 是连接的字段名，`LEFT/RIGHT/INNER` 是连接...
sql left join 命令详解
09-11
例如，在描述中的例子中，`SELECT * FROM a INNER JOIN b ON a.aid = b.bid`只会返回aid和bid相等的行，即： ``` 1 a1 b1 2 a2 b2 ``` 然而，LEFT JOIN的工作方式略有不同。当执行`SELECT * FROM a LEFT JOIN b ON...
SQL中的left join right join
09-11
SELECT * FROM 部门 INNER JOIN 组织 ON 部门.组织编号 = 组织.编号 ``` 这个查询等同于带有WHERE子句的简单SELECT语句： ```sql SELECT * FROM 部门, 组织 WHERE 部门.组织编号 = 组织.编号 ``` 2. LEFT ...
SQL语法（DQL)：SELECT 多表查询之Join与Union
qq_45269163的博客
07-05 1041
用于实现列的合并，结果中的列来自于多张表。实现两份数据集合操作【交集、差集、全集】
select语句中的join
weixin_30726161的博客
03-13 459
join的功能就是把两表连接起来，然后用双方关联上的字段。 有4种join t1: id a b 1 2 3 2 5 5 3 5 7 t2: ...
MySQL数据库联合查询（select ... join）的三种方式示例
simple大鱼
01-19 8774
MySQL数据库联合查询的三种方式示例 1.内连接：inner join 2.左链接：left join 3.右链接：right join –第一步：创建两个表person、car，并且插入测试数据。 create table person( id_card varchar(18) unique key, name varchar(32) not null ); ±---------±-----...
ASP之SELECT JOIN
～憧雨泉～的专栏
07-06 1693
ASP之SELECT JOIN 所属分类： 网络编程 更新日期：2004-2-8 22:41:48 阅读次数：353   Join JOIN连接组合两个表中的字段记录，包括三种： INNER JOIN运算式：连接组合两个表中的字段记录。 LEFT JOIN运算式：连接组合两个表中的字段记录，并将包含了LEFT JOIN左边表中的全部记录。 RIGHT JOIN运算式：连接组合
【SQL】之select-多表查询：7种join | sql99语法新特性
null
04-13 2233
多表查询 -- 多表查询 SELECT employee_id,department_name FROM employees,departments #1.两个表的连接条件 WHERE employees.`department_id`=departments.`department_id`; #2.如果查询语句中出现了多个表中都存在的字段，则必须指明此字段所在的表： SELECT employees.employee_id,departments.department_name,employees.d
SQL JOIN 时 USING 和 ON 的异同
houzhizhen的专栏
09-28 974
另外一点是不需要在关联字段前面加限定。如以下语句 SELECT 中的 film_id 不需要加上。ON 是更加普遍的用法，可以连接表 On 一个字段，多个字段，甚至一个条件表达式。在数据表做 join 时，即可以用 using，也可以用 on。USING 在两张表关联的字段名正好相同的时候有用。是不允许的，因为会照成歧义（两张表里都有）。时，关联的字段仅出现一次；注意SELECT 部分的。时，关联的字段出现两次。
OAuth2.0 or Spring Session or 单点登录流程
最新发布
qq_53374893的博客
07-20 302
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
select join on
05-30
`SELECT` 和 `JOIN ON` 都是 SQL 中的关键字。 `SELECT` 用于选择要查询的数据列，语法为： ```sql SELECT column1, column2, ... FROM table_name; ``` `JOIN ON` 用于将两个或多个表连接起来，并指定连接条件，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值