MySQL系列复习（11）深入了解连接查询及原理

最新推荐文章于 2024-04-19 21:31:18 发布
最新推荐文章于 2024-04-19 21:31:18 发布
阅读量200 收藏
点赞数
分类专栏： 【数据库-MySQL】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MyronCham/article/details/109792039
版权

环境：mysql5.7.30，cmd命令中进行演示。
当我们查询的数据来源于多张表的时候，我们需要用到连接查询，连接查询使用率非常高。

目录

准备数据：

1、笛卡尔积

1.1、sql中笛卡尔积语法

2、内连接

2.1、示例1：有连接条件

2.2、示例2：无连接条件

2.3、组合条件进行查询

2.4、总结

3、外连接

4、左连接

4.1、示例1

4.2、示例2

5、右连接

5.1、示例

6、表连接的原理

6.1、示例1：内连接

6.2、示例2：左连接

7、使用java实现连接查询，加深理解

准备数据：

2张表：
t_team：组表。
t_employee：员工表，内部有个team_id引用组表的id。

drop table if exists t_team;
create table t_team(
 id int not null AUTO_INCREMENT PRIMARY KEY comment '组id',
 team_name varchar(32) not null default '' comment '名称'
) comment '组表';

drop table if exists t_employee;
create table t_employee(
 id int not null AUTO_INCREMENT PRIMARY KEY comment '部门id',
 emp_name varchar(32) not null default '' comment '员工名称',
 team_id int not null default 0 comment '员工所在组id'
) comment '员工表表';
insert into t_team values (1,'架构组'),(2,'测试组'),(3,'java组'),(4,'前端组');
insert into t_employee values (1,'myronJava',1),(2,'张三',2),(3,'李四',3),(4,'王五',0),(5,'赵六',0);

t_team 表4条记录，如下：

mysql> select * from t_team;
+----+-----------+
| id | team_name |
+----+-----------+
|  1 | 架构组    |
|  2 | 测试组    |
|  3 | java组    |
|  4 | 前端组    |
+----+-----------+
4 rows in set (0.00 sec)

t_employee 表5条记录，如下：

mysql> select * from t_employee;
+----+---------------+---------+
| id | emp_name      | team_id |
+----+---------------+---------+
|  1 | myronJava    |       1 |
|  2 | 张三          |       2 |
|  3 | 李四          |       3 |
|  4 | 王五          |       0 |
|  5 | 赵六          |       0 |
+----+---------------+---------+
5 rows in set (0.00 sec)

mysql>

1、笛卡尔积

介绍连接查询之前，我们需要先了解一下笛卡尔积。
笛卡尔积简单点理解：有两个集合A和B，笛卡尔积表示A集合中的元素和B集合中的元素任意相互关联产生的所有可能的结果。
假如A中有m个元素，B中有n个元素，A、B笛卡尔积产生的结果有m*n个结果，相当于循环遍历两个集合中的元素，任意组合。
java伪代码表示如下：

for(Object eleA : A){
    for(Object eleB : B){
        System.out.print(eleA+","+eleB);
    }
}

过程：拿A集合中的第1行，去匹配集合B中所有的行，然后再拿集合A中的第2行，去匹配集合B中所有的行，最后结果数量为m*n。

1.1、sql中笛卡尔积语法

select 字段 from 表1,表2[,表N];
或者
select 字段 from 表1 join 表2 [join 表N];
mysql> select * from t_team;
+----+-----------+
| id | team_name |
+----+-----------+
|  1 | 架构组    |
|  2 | 测试组    |
|  3 | java组    |
|  4 | 前端组    |
+----+-----------+
4 rows in set (0.00 sec)

mysql> select * from t_employee;
+----+-----------+---------+
| id | emp_name  | team_id |
+----+-----------+---------+
|  1 | myronJava |       1 |
|  2 | 张三      |       2 |
|  3 | 李四      |       3 |
|  4 | 王五      |       0 |
|  5 | 赵六      |       0 |
+----+-----------+---------+
5 rows in set (0.00 sec)

mysql> select * from t_team,t_employee;
+----+-----------+----+-----------+---------+
| id | team_name | id | emp_name  | team_id |
+----+-----------+----+-----------+---------+
|  1 | 架构组    |  1 | myronJava |       1 |
|  2 | 测试组    |  1 | myronJava |       1 |
|  3 | java组    |  1 | myronJava |       1 |
|  4 | 前端组    |  1 | myronJava |       1 |
|  1 | 架构组    |  2 | 张三      |       2 |
|  2 | 测试组    |  2 | 张三      |       2 |
|  3 | java组    |  2 | 张三      |       2 |
|  4 | 前端组    |  2 | 张三      |       2 |
|  1 | 架构组    |  3 | 李四      |       3 |
|  2 | 测试组    |  3 | 李四      |       3 |
|  3 | java组    |  3 | 李四      |       3 |
|  4 | 前端组    |  3 | 李四      |       3 |
|  1 | 架构组    |  4 | 王五      |       0 |
|  2 | 测试组    |  4 | 王五      |       0 |
|  3 | java组    |  4 | 王五      |       0 |
|  4 | 前端组    |  4 | 王五      |       0 |
|  1 | 架构组    |  5 | 赵六      |       0 |
|  2 | 测试组    |  5 | 赵六      |       0 |
|  3 | java组    |  5 | 赵六      |       0 |
|  4 | 前端组    |  5 | 赵六      |       0 |
+----+-----------+----+-----------+---------+
20 rows in set (0.00 sec)

mysql>

t_team表4条记录，t_employee表5条记录，笛卡尔积结果输出了20行记录。

2、内连接

语法：

select 字段 from 表1 inner join 表2 on 连接条件;
或
select 字段 from 表1 join 表2 on 连接条件;
或
select 字段 from 表1,表2 [where 关联条件];

内连接相当于在笛卡尔积的基础上加上了连接条件。

当没有连接条件的时候，内连接上升为笛卡尔积。

过程用java伪代码如下：

for(Object eleA : A){
    for(Object eleB : B){
        if(连接条件是否为true){
            System.out.print(eleA+","+eleB);
        }
    }
}

2.1、示例1：有连接条件

mysql> select t1.emp_name,t2.team_name from t_employee t1 inner join t_team t2
    -> on t1.team_id = t2.id;
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
| 张三      | 测试组    |
| 李四      | java组    |
+-----------+-----------+
3 rows in set (0.00 sec)

mysql> select t1.emp_name,t2.team_name from t_employee t1 join t_team t2 on
    -> t1.team_id = t2.id;
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
| 张三      | 测试组    |
| 李四      | java组    |
+-----------+-----------+
3 rows in set (0.00 sec)

mysql> select t1.emp_name,t2.team_name from t_employee t1, t_team t2 where
    -> t1.team_id = t2.id;
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
| 张三      | 测试组    |
| 李四      | java组    |
+-----------+-----------+
3 rows in set (0.00 sec)

mysql>

上面相当于获取了2个表的交集，查询出了两个表都有的数据。

2.2、示例2：无连接条件

无条件内连接，上升为笛卡尔积，如下：

mysql> select t1.emp_name,t2.team_name from t_employee t1 inner join t_team t2;
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
| myronJava | 测试组    |
| myronJava | java组    |
| myronJava | 前端组    |
| 张三      | 架构组    |
| 张三      | 测试组    |
| 张三      | java组    |
| 张三      | 前端组    |
| 李四      | 架构组    |
| 李四      | 测试组    |
| 李四      | java组    |
| 李四      | 前端组    |
| 王五      | 架构组    |
| 王五      | 测试组    |
| 王五      | java组    |
| 王五      | 前端组    |
| 赵六      | 架构组    |
| 赵六      | 测试组    |
| 赵六      | java组    |
| 赵六      | 前端组    |
+-----------+-----------+
20 rows in set (0.00 sec)

mysql>

2.3、组合条件进行查询

查询架构组的员工，3种写法

-- 方式1：on中使用了组合条件。
mysql> select t1.emp_name,t2.team_name from t_employee t1 inner join t_team t2
    -> on t1.team_id = t2.id and t2.team_name = '架构组';
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
+-----------+-----------+
1 row in set (0.00 sec)

-- 方式2：在连接的结果之后再进行过滤，相当于先获取连接的结果，然后使用where中的条件再对连接
结果进行过滤。
mysql> select t1.emp_name,t2.team_name from t_employee t1 inner join t_team t2
    -> on t1.team_id = t2.id where t2.team_name = '架构组';
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
+-----------+-----------+
1 row in set (0.00 sec)

-- 方式3：直接在where后面进行过滤。
mysql> select t1.emp_name,t2.team_name from t_employee t1, t_team t2 where
    -> t1.team_id = t2.id and t2.team_name = '架构组';
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
+-----------+-----------+
1 row in set (0.00 sec)

mysql>

2.4、总结

内连接建议使用第3种语法，简洁：

select 字段 from 表1, 表2 [where 关联条件];

3、外连接

外连接涉及到2个表，分为：主表和从表，要查询的信息主要来自于哪个表，谁就是主表。
外连接查询结果为主表中所有记录。如果从表中有和它匹配的，则显示匹配的值，这部分相当于内连接
查询出来的结果；如果从表中没有和它匹配的，则显示null。
最终：外连接查询结果 = 内连接的结果 + 主表中有的而内连接结果中没有的记录。
外连接分为2种：
左外链接：使用left join关键字，left join左边的是主表。
右外连接：使用right join关键字，right join右边的是主表。

4、左连接

语法：

select 列 from 主表 left join 从表 on 连接条件;

4.1、示例1

查询所有员工信息，并显示员工所在组，如下：

mysql> SELECT
    ->     t1.emp_name,
    ->     t2.team_name
    ->   FROM
    ->     t_employee t1
    ->   LEFT JOIN
    ->     t_team t2
    ->   ON
    ->     t1.team_id = t2.id;
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
| 张三      | 测试组    |
| 李四      | java组    |
| 王五      | NULL      |
| 赵六      | NULL      |
+-----------+-----------+
5 rows in set (0.00 sec)

mysql>

上面查询出了所有员工，员工team_id=0的，team_name为NULL。

4.2、示例2

查询员工姓名、组名、返回组名不为空的记录，如下：

mysql> SELECT
    ->     t1.emp_name,
    ->     t2.team_name
    ->   FROM
    ->     t_employee t1
    ->   LEFT JOIN
    ->     t_team t2
    ->   ON
    ->     t1.team_id = t2.id
    ->   WHERE
    ->     t2.team_name IS NOT NULL;
+-----------+-----------+
| emp_name  | team_name |
+-----------+-----------+
| myronJava | 架构组    |
| 张三      | 测试组    |
| 李四      | java组    |
+-----------+-----------+
3 rows in set (0.02 sec)

mysql>

上面先使用内连接获取连接结果，然后再使用where对连接结果进行过滤。

5、右连接

语法：

select 列 from 从表 right join 主表 on 连接条件;

5.1、示例

我们使用右连接来实现上面左连接实现的功能，如下：

mysql> SELECT
    ->     t2.team_name,
    ->     t1.emp_name
    ->   FROM
    ->     t_team t2
    ->   RIGHT JOIN
    ->     t_employee t1
    ->   ON
    ->     t1.team_id = t2.id;
+-----------+-----------+
| team_name | emp_name  |
+-----------+-----------+
| 架构组    | myronJava |
| 测试组    | 张三      |
| java组    | 李四      |
| NULL      | 王五      |
| NULL      | 赵六      |
+-----------+-----------+
5 rows in set (0.00 sec)

mysql> SELECT
    ->     t2.team_name,
    ->     t1.emp_name
    ->   FROM
    ->     t_team t2
    ->   RIGHT JOIN
    ->     t_employee t1
    ->   ON
    ->     t1.team_id = t2.id
    ->   WHERE
    ->     t2.team_name IS NOT NULL;
+-----------+-----------+
| team_name | emp_name  |
+-----------+-----------+
| 架构组    | myronJava |
| 测试组    | 张三      |
| java组    | 李四      |
+-----------+-----------+
3 rows in set (0.00 sec)

mysql>

6、表连接的原理

准备数据：

drop table if exists test1;
create table test1(
 a int
);
drop table if exists test2;
create table test2(
 b int
);
insert into test1 values (1),(2),(3);
insert into test2 values (3),(4),(5);
mysql> select * from test1;
+------+
| a    |
+------+
|    1 |
|    2 |
|    3 |
+------+
3 rows in set (0.00 sec)

mysql> select * from test2;
+------+
| b    |
+------+
|    3 |
|    4 |
|    5 |
+------+
3 rows in set (0.00 sec)

mysql>

6.1、示例1：内连接

mysql> select * from test1 t1, test2 t2;
+------+------+
| a    | b    |
+------+------+
|    1 |    3 |
|    2 |    3 |
|    3 |    3 |
|    1 |    4 |
|    2 |    4 |
|    3 |    4 |
|    1 |    5 |
|    2 |    5 |
|    3 |    5 |
+------+------+
9 rows in set (0.00 sec)

mysql> select * from test1 t1, test2 t2 where t1.a=t2.b;
+------+------+
| a    | b    |
+------+------+
|    3 |    3 |
+------+------+
1 row in set (0.00 sec)

mysql>

6.2、示例2：左连接

mysql> select * from test1 t1 left join test2 t2 on t1.a=t2.b;
+------+------+
| a    | b    |
+------+------+
|    3 |    3 |
|    1 | NULL |
|    2 | NULL |
+------+------+
3 rows in set (0.00 sec)

mysql> select * from test1 t1 left join test2 on t1.a>10;
+------+------+
| a    | b    |
+------+------+
|    1 | NULL |
|    2 | NULL |
|    3 | NULL |
+------+------+
3 rows in set (0.00 sec)

mysql> select * from test1 t1 left join test2 t2 on 1=1;
+------+------+
| a    | b    |
+------+------+
|    1 |    3 |
|    2 |    3 |
|    3 |    3 |
|    1 |    4 |
|    2 |    4 |
|    3 |    4 |
|    1 |    5 |
|    2 |    5 |
|    3 |    5 |
+------+------+
9 rows in set (0.00 sec)

mysql>

上面的左连接第一个好理解。
第2个sql连接条件 t1.a>10 ，这个条件只关联了test1表，再看看结果，是否可以理解？不理解的继续
向下看，我们用java代码来实现连接查询。
第3个sql中的连接条件1=1值为true，返回结果为笛卡尔积。

7、使用java实现连接查询，加深理解

下面是一个简略版的实现

package com.myron.sql;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;
public class Test1 {
  public static class Table1 {
    int a;
    public int getA() {
      return a;
   }
    public void setA(int a) {
      this.a = a;
   }
    public Table1(int a) {
      this.a = a;
   }
    @Override
    public String toString() {
      return "Table1{" +
          "a=" + a +
          '}';
   }
    public static Table1 build(int a) {
      return new Table1(a);
   }
 }
  public static class Table2 {
    int b;
    public int getB() {
      return b;
   }
    public void setB(int b) {
      this.b = b;
   }
    public Table2(int b) {
      this.b = b;
   }
    public static Table2 build(int b) {
      return new Table2(b);
   }
    @Override
    public String toString() {
      return "Table2{" +
          "b=" + b +
          '}';
   }
 }
  public static class Record<R1, R2> {
    R1 r1;
    R2 r2;
    public R1 getR1() {
      return r1;
   }
    public void setR1(R1 r1) {
      this.r1 = r1;
   }
    public R2 getR2() {
      return r2;
   }
    public void setR2(R2 r2) {
      this.r2 = r2;
   }
    public Record(R1 r1, R2 r2) {
      this.r1 = r1;
      this.r2 = r2;
   }
    @Override
    public String toString() {
      return "Record{" +
          "r1=" + r1 +
          ", r2=" + r2 +
          '}';
   }
    public static <R1, R2> Record<R1, R2> build(R1 r1, R2 r2) {
      return new Record(r1, r2);
   }
 }
  public static enum JoinType {
    innerJoin, leftJoin
 }
  public static interface Filter<R1, R2> {
    boolean accept(R1 r1, R2 r2);
 }
  public static <R1, R2> List<Record<R1, R2>> join(List<R1> table1, List<R2>
table2, JoinType joinType, Filter<R1, R2> onFilter, Filter<R1, R2> whereFilter)
{
    if (Objects.isNull(table1) || Objects.isNull(table2) || joinType ==
null) {
      return new ArrayList<>();
   }
    List<Record<R1, R2>> result = new CopyOnWriteArrayList<>();
    for (R1 r1 : table1) {
      List<Record<R1, R2>> onceJoinResult = joinOn(r1, table2, onFilter);
      result.addAll(onceJoinResult);
   }
    if (joinType == JoinType.leftJoin) {
      List<R1> r1Record =
result.stream().map(Record::getR1).collect(Collectors.toList());
      List<Record<R1, R2>> leftAppendList = new ArrayList<>();
      for (R1 r1 : table1) {
        if (!r1Record.contains(r1)) {
          leftAppendList.add(Record.build(r1, null));
       }
     }
      result.addAll(leftAppendList);
   }
    if (Objects.nonNull(whereFilter)) {
      for (Record<R1, R2> record : result) {
        if (!whereFilter.accept(record.r1, record.r2)) {
          result.remove(record);
       }
    }
   }
    return result;
 }
  public static <R1, R2> List<Record<R1, R2>> joinOn(R1 r1, List<R2> table2,
Filter<R1, R2> onFilter) {
    List<Record<R1, R2>> result = new ArrayList<>();
    for (R2 r2 : table2) {
      if (Objects.nonNull(onFilter) ? onFilter.accept(r1, r2) : true) {
        result.add(Record.build(r1, r2));
     }
   }
    return result;
 }
  @Test
  public void innerJoin() {
    List<Table1> table1 = Arrays.asList(Table1.build(1), Table1.build(2),
Table1.build(3));
    List<Table2> table2 = Arrays.asList(Table2.build(3), Table2.build(4),
Table2.build(5));
    join(table1, table2, JoinType.innerJoin, null,
null).forEach(System.out::println);
    System.out.println("-----------------");
    join(table1, table2, JoinType.innerJoin, (r1, r2) -> r1.a == r2.b,
null).forEach(System.out::println);
 }
  @Test
  public void leftJoin() {
    List<Table1> table1 = Arrays.asList(Table1.build(1), Table1.build(2),
Table1.build(3));
    List<Table2> table2 = Arrays.asList(Table2.build(3), Table2.build(4),
Table2.build(5));
    join(table1, table2, JoinType.leftJoin, (r1, r2) -> r1.a == r2.b,
null).forEach(System.out::println);
    System.out.println("-----------------");
    join(table1, table2, JoinType.leftJoin, (r1, r2) -> r1.a > 10,
null).forEach(System.out::println);
 }
}

代码中的 innerJoin() 方法模拟了下面的sql：

mysql> select * from test1 t1,test2 t2;
+------+------+
| a    | b    |
+------+------+
|    1 |    3 |
|    2 |    3 |
|    3 |    3 |
|    1 |    4 |
|    2 |    4 |
|    3 |    4 |
|    1 |    5 |
|    2 |    5 |
|    3 |    5 |
+------+------+
9 rows in set (0.00 sec)

mysql> select * from test1 t1,test2 t2 where t1.a = t2.b;
+------+------+
| a    | b    |
+------+------+
|    3 |    3 |
+------+------+
1 row in set (0.00 sec)

mysql>

运行一下 innerJoin() 输出如下：

Record{r1=Table1{a=1}, r2=Table2{b=3}}
Record{r1=Table1{a=1}, r2=Table2{b=4}}
Record{r1=Table1{a=1}, r2=Table2{b=5}}
Record{r1=Table1{a=2}, r2=Table2{b=3}}
Record{r1=Table1{a=2}, r2=Table2{b=4}}
Record{r1=Table1{a=2}, r2=Table2{b=5}}
Record{r1=Table1{a=3}, r2=Table2{b=3}}
Record{r1=Table1{a=3}, r2=Table2{b=4}}
Record{r1=Table1{a=3}, r2=Table2{b=5}}
-----------------
Record{r1=Table1{a=3}, r2=Table2{b=3}}

对比一下sql和java的结果，输出的结果条数、数据基本上一致，唯一不同的是顺序上面不一样，顺序为
何不一致，稍微介绍。
代码中的 leftJoin() 方法模拟了下面的sql：

mysql> select * from test1 t1 left join test2 t2 on t1.a = t2.b;
+------+------+
| a    | b    |
+------+------+
|    3 |    3 |
|    1 | NULL |
|    2 | NULL |
+------+------+
3 rows in set (0.00 sec)

mysql>  select * from test1 t1 left join test2 t2 on t1.a>10;
+------+------+
| a    | b    |
+------+------+
|    1 | NULL |
|    2 | NULL |
|    3 | NULL |
+------+------+
3 rows in set (0.00 sec)

mysql>

运行 leftJoin() ，结果如下：

Record{r1=Table1{a=3}, r2=Table2{b=3}}
Record{r1=Table1{a=1}, r2=null}
Record{r1=Table1{a=2}, r2=null}
-----------------
Record{r1=Table1{a=1}, r2=null}
Record{r1=Table1{a=2}, r2=null}
Record{r1=Table1{a=3}, r2=null}

效果和sql的效果完全一致，可以对上。
现在我们来讨论java输出的顺序为何和sql不一致？

上面java代码中两个表的连接查询使用了嵌套循环，外循环每执行一次，内循环的表都会全部遍历一次，如果放到mysql中，就相当于内表（被驱动表）全部扫描了一次（一次全表io读取操作），主表（外循环）如果有n条数据，那么从表就需要全表扫描n次，表的数据是存储在磁盘中，每次全表扫描都需要做io操作，io操作是最耗时间的，如果mysql按照上面的java方式实现，那效率肯定很低。
那mysql是如何优化的呢？

msql内部使用了一个内存缓存空间，就叫他 join_buffer 吧，先把外循环的数据放到join_buffer 中，然后对从表进行遍历，从表中取一条数据和 join_buffer 的数据进行比较，然后从表中再取第2条和 join_buffer 数据进行比较，直到从表遍历完成，使用这方方式来减少从表的io扫描次数，当 join_buffer 足够大的时候，大到可以存放主表所有数据，那么从表只需
要全表扫描一次（即只需要一次全表io读取操作）。mysql中这种方式叫做 Block Nested Loop 。
java代码改进一下，来实现join_buffer的过程。

java代码改进版本

package com.myron.sql;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.stream.Collectors;
import com.myron.sql.Test1.*;
public class Test2 {
  public static int joinBufferSize = 10000;
  public static List<?> joinBufferList = new ArrayList<>();
   public static <R1, R2> List<Record<R1, R2>> join(List<R1> table1, List<R2>
table2, JoinType joinType, Filter<R1, R2> onFilter, Filter<R1, R2> whereFilter)
{
    if (Objects.isNull(table1) || Objects.isNull(table2) || joinType ==
null) {
      return new ArrayList<>();
   }
    List<Test1.Record<R1, R2>> result = new CopyOnWriteArrayList<>();
    int table1Size = table1.size();
    int fromIndex = 0, toIndex = joinBufferSize;
    toIndex = Integer.min(table1Size, toIndex);
    while (fromIndex < table1Size && toIndex <= table1Size) {
      joinBufferList = table1.subList(fromIndex, toIndex);
      fromIndex = toIndex;
      toIndex += joinBufferSize;
      toIndex = Integer.min(table1Size, toIndex);
      List<Record<R1, R2>> blockNestedLoopResult =
blockNestedLoop((List<R1>) joinBufferList, table2, onFilter);
      result.addAll(blockNestedLoopResult);
   }
    if (joinType == JoinType.leftJoin) {
      List<R1> r1Record =
result.stream().map(Record::getR1).collect(Collectors.toList());
      List<Record<R1, R2>> leftAppendList = new ArrayList<>();
      for (R1 r1 : table1) {
        if (!r1Record.contains(r1)) {
          leftAppendList.add(Record.build(r1, null));
       }
     }
      result.addAll(leftAppendList);
   }
    if (Objects.nonNull(whereFilter)) {
      for (Record<R1, R2> record : result) {
        if (!whereFilter.accept(record.r1, record.r2)) {
          result.remove(record);
       }
     }
   }
    return result;
 }
  public static <R1, R2> List<Record<R1, R2>> blockNestedLoop(List<R1>
joinBufferList, List<R2> table2, Filter<R1, R2> onFilter) {
    List<Record<R1, R2>> result = new ArrayList<>();
    for (R2 r2 : table2) {
      for (R1 r1 : joinBufferList) {
        if (Objects.nonNull(onFilter) ? onFilter.accept(r1, r2) : true)
{
          result.add(Record.build(r1, r2));
       }
     }
   }
    return result;
 }

 @Test
  public void innerJoin() {
    List<Table1> table1 = Arrays.asList(Table1.build(1), Table1.build(2),
Table1.build(3));
    List<Table2> table2 = Arrays.asList(Table2.build(3), Table2.build(4),
Table2.build(5));
    join(table1, table2, JoinType.innerJoin, null,
null).forEach(System.out::println);
    System.out.println("-----------------");
    join(table1, table2, JoinType.innerJoin, (r1, r2) -> r1.a == r2.b,
null).forEach(System.out::println);
 }
  @Test
  public void leftJoin() {
    List<Table1> table1 = Arrays.asList(Table1.build(1), Table1.build(2),
Table1.build(3));
    List<Table2> table2 = Arrays.asList(Table2.build(3), Table2.build(4),
Table2.build(5));
    join(table1, table2, JoinType.leftJoin, (r1, r2) -> r1.a == r2.b,
null).forEach(System.out::println);
    System.out.println("-----------------");
    join(table1, table2, JoinType.leftJoin, (r1, r2) -> r1.a > 10,
null).forEach(System.out::println);
 }
}

执行 innerJoin() ，输出：

Record{r1=Table1{a=1}, r2=Table2{b=3}}
Record{r1=Table1{a=2}, r2=Table2{b=3}}
Record{r1=Table1{a=3}, r2=Table2{b=3}}
Record{r1=Table1{a=1}, r2=Table2{b=4}}
Record{r1=Table1{a=2}, r2=Table2{b=4}}
Record{r1=Table1{a=3}, r2=Table2{b=4}}
Record{r1=Table1{a=1}, r2=Table2{b=5}}
Record{r1=Table1{a=2}, r2=Table2{b=5}}
Record{r1=Table1{a=3}, r2=Table2{b=5}}
-----------------
Record{r1=Table1{a=3}, r2=Table2{b=3}}

执行 leftJoin() ，输出：

Record{r1=Table1{a=3}, r2=Table2{b=3}}
Record{r1=Table1{a=1}, r2=null}
Record{r1=Table1{a=2}, r2=null}
-----------------
Record{r1=Table1{a=1}, r2=null}
Record{r1=Table1{a=2}, r2=null}
Record{r1=Table1{a=3}, r2=null}

结果和sql的结果完全一致。

 

 

 

一棵树～
关注
专栏目录
深入剖析原理！mysql远程连接数据库服务器
m0_56824583的博客
06-07 160
前言: 金九银十过了金三银四还会远嘛，本文后面分享面试题给正准备跳槽，准备找工作的你，这次面试字节跳动也是做了很多的准备，还好顺利拿到了offer，特分享一下这次的4面技术面真题，可能有些记不全了，但多少也能够给一些正在面试字节或计划面试字节的朋友提供帮助。 之前学校活动有去过字节跳动公司总部参观，所以一直以来就蛮想进入字节工作的，被字节的企业文化和工作氛围所影响。字节作为发展速度最快的互联网公司，旗下的很多产品的用户都比肩BAT了，所以自己也算是字节的死忠粉了。 这次字节跳动的面试，给我的感触很深，意识到
复习整理，深度学习Mysql，数据库系统实现等内容的笔记.zip
02-23
4. MySQL安装与配置：涵盖了Windows、Linux等平台的安装步骤及基本设置。 5. 数据库创建与管理：创建数据库、选择数据库、删除数据库以及表的创建、修改、删除等操作。 二、MySQL高级特性 1. 触发器：在特定事件...
mysql中的if [not] exists
一缕阳光的博客
07-12 1万+
最近在MySQL数据库的基础上开发分布式的数据库，需要支持一个if [not] exists语法。学习了SQL语法解析部分，总结下： 1、在MySQL中，创建表时支持create table if not exists db.table_name .... create table if not exists test1 ( c1 int primary key, c2 varchar(50) )engine = innodb; 如果要创建的表存在，则直接返回，不在重新创建该表。
mysql中的drop table if exists
少猿的博客
08-12 18万+
一般drop table if exists是数据库里面的，后面接表名如：drop table if exists xxx_book意思就是：如果数据库中存在xxx_book表，就把它从数据库中drop掉。 　　备份sql中一般都有这样的语句，如果是数据库中有这个表，先drop掉，然后create表，然后再进行数据插入。 ...
MySQL系列复习（5）DML常⻅操作
myroncham的博客
10-12 344
目录 1、插入操作 1.1、插入单行2种方式 1.1.1、方式1：insert into 表名[(字段,字段)] values (值,值); 1.1.2、方式2：insert into 表名 set 字段 = 值,字段 = 值; 1.2、批量插⼊2种⽅式 1.2.1、方式1：insert into 表名 [(字段,字段)] values (值,值),(值,值),(值,值); 1.2.2、方式2：insert into 表 [(字段,字段)] 2、数据更新 2.1、单表更新 2.1.1、语
【MySQL系列4】深入分析MySQL中事务以及MVCC的实现原理
2401_84010402的博客
04-19 826
其实我投简历的时候，都不太敢投递阿里。因为在阿里一面前已经过了字节的三次面试，投阿里的简历一直没被捞，所以以为简历就挂了。对比我的面经和其他大佬的面经，自己真的是运气好。别人8成实力，我可能8成运气。所以对我而言，我要继续加倍努力，弥补自己技术上的不足，以及与科班大佬们基础上的差距。希望自己能继续保持学习的热情，继续努力走下去。
数据库MySQL详解
热门推荐
卓越无关环境，保持空杯心态——靡不有初，鲜克有终
07-24 18万+
全网最详细MySQL教程，2023持续更新中
快速复习MySQL基本知识
qq_48304465的博客
04-09 1348
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、MySQL操作四大板块预备知识1.DDL(操作数据库和表)2.DML(对表中数据进行增删改)2.1添加数据2.2删除数据2.3更新数据3.DQL(对表中数据进行查询)3.1排序查询3.2分组查询3.3分页查询4.DCL(对数据库进行权限控制)4.1约束二、数据库设计1.数据表之间的关系2.连接查询三、事务总结 前言 MySQL作为当下热门的关系型数据库操作系统，MySQL也是程序开发必备技术之一。其开源免费的条件，也为学.
MySQL_执行原理_(索引合并&链接查询&查询成本计算）
d495435207的博客
12-01 606
mysql 索引合并&链接查询&查询成本计算
MySQL系列---实践总结
lipviolet的博客
03-16 1053
基础术语 数据库：DB（简称），database（全称） 数据库管理系统：DBMS（简称），database management system（全称） DBMS大致分类： 关系型：Oracle/Mysql/Sql server/Db2—服务按核收费/开源免费/微软产品/ibm产品 非关型：redis/hbase/mongdb/neo4j—内存缓存/列存储/文档存储/图存储 客户端软件：多用navicat 命令分类 初登 登录：mysql -uname -p Enter password：xxx
OUC2024年大数据原理与应用复习重点
最新发布
06-27
### OUC2024年大数据原理与应用复习重点解析 #### 一、大数据概述 1. **大数据定义及4V特点**： - **定义**：大数据是指那些规模庞大到无法通过传统数据处理工具有效处理的数据集合。 - **4V特点**： - **数据...
解决linux mysql命令 bash: mysql: command not found 的方法
myroncham的博客
09-29 4万+
linux上安装mysql登录报错： 有以下几种错误原因： 1、如果你是使用的 rpm 的安装方式安装的，那么可能的情况就是你没有安装 client 包。2、如果你已经安装了还是报这个错的话，那么你可以再重装一遍。(本人将client包重新安装后登录成功) 3、系统默认会查找/usr/bin下的命令，如果这个命令不在这个目录下，当然会找不到命令，我们需要做的就是映射一个链接到/usr/bin...
MySQL七种日志总结
myroncham的博客
07-15 4048
mysql日志
MySQL5.7创建数据库与添加用户、删除用户及授权、保证数据库账号安全
myroncham的博客
09-23 3438
MySQL安装启动成功后，首先我们需要创建数据库，然后创建一个用户去操作这个数据库。 1、创建数据库 // 登录MySQL客户端：mysql -h [ip] -u[username] -p[password] C:\Users\Administrator>mysql -h 127.0.0.1 -uroot -p"root" // 创建数据库，指定字符集 mysql> CREATE DATABASE `apollodb` DEFAULT CHARACTER SET utf8 COLLATE
MySQL系列复习（7）select条件查询
myroncham的博客
10-16 914
环境：mysql5.7.25，cmd命令中进⾏演⽰。 电商中：我们想查看某个⽤户所有的订单，或者想查看某个⽤户在某个时间段内所有的订单，此时我们需要对订单表数据进⾏筛选，按照⽤户、时间进⾏过滤，得到我们期望的结果。 此时我们需要使⽤条件查询来对指定表进⾏操作，我们需要了解sql中的条件查询常见的玩法。 1、条件查询语法 语法：select 列名 from 表名 where 列 运算符 值 说明：注意关键字where，where后⾯跟上⼀个或者多个条件，条件是对前⾯数据的过滤，只有满⾜where后⾯条件的
MySQL系列复习（1）MySQL简介，安装，基础使用，数据库规范
myroncham的博客
10-10 757
1、简介 1.1、概述 MySQL是一个关系型数据库管理系统，由瑞典MySQL AB公司开发，目前属于Oracle公司。 MySQL是一种关联数据库管理系统，将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。 Mysql是开源的，所以你不需要支付额外的费用。 Mysql是可以定制的，采用了GPL协议，你可以修改源码来开发自己的Mysql系统。 Mysql支持大型的数据库。可以处理拥有上千万条记录的大型数据库。 MySQL使用标准的SQL数据语言形式。 Mysql可以
MySQL添加索引
myroncham的博客
09-18 687
-- 1.添加PRIMARY KEY（主键索引） ALTER TABLE `table_name` ADD PRIMARY KEY (`column`) ; -- 2.添加UNIQUE(唯一索引) ALTER TABLE `table_name` ADD UNIQUE (`column`); -- 3.添加INDEX(普通索引) ALTER ...
MySQL系列复习（12）子查询【重点】
myroncham的博客
11-23 572
目录 1、子查询概念 2、子查询分类 2.1、按结果集的行列数不同分为4种 2.2、按子查询出现在主查询中的不同位置分 3、准备数据 4、select后面的子查询 4.1、示例1 4.2、示例2 5、from后面的子查询 5.1、示例1 6、where和having后面的子查询 6.1、特点 6.2、mysql中的in、any、some、all 6.3、标量子查询 6.3.1、一般标量子查询 6.3.2、多个标量子查询 6.3.3、子查询+分组函数 6.3.4、错误的标量
数据库原理实验指南：MySQL环境与数据定义
- 查询实验可能涵盖SELECT语句，包括简单的查询、连接查询、分组查询和嵌套查询。 - 视图操作涉及创建、修改和删除视图，提供数据的不同视图。 - 完整性实验可能涉及设置主键、外键等约束，确保数据的准确性和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值