HPI P3BAN2004CL【齿轮泵】

最新推荐文章于 2023-10-31 10:43:05 发布
最新推荐文章于 2023-10-31 10:43:05 发布
阅读量142 收藏
点赞数
文章标签： php 爬虫 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KLD_guo/article/details/121579559
版权

HPI齿轮泵 P3BAN2004HL10B02N C5076750
HPI齿轮泵P3BAN2004CL10B02N  C5081285

准备数据

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,'路人甲Java',1),(2,'张三',2),(3,'李四',3),(4,'王五',0),(5,'赵六',0);123456789101112131415

t_team表4条记录，如下：

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

t_employee表5条记录，如下：

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

笛卡尔积

介绍连接查询之前，我们需要先了解一下笛卡尔积。

笛卡尔积简单点理解：有两个集合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);
    }
}12345

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

sql中笛卡尔积语法

select 字段 from 表1,表2[,表N];或者select 字段 from 表1 join 表2 [join 表N];123

示例：

mysql> select * from t_team,t_employee;+----+-----------+----+---------------+---------+| id | team_name | id | emp_name      | team_id |+----+-----------+----+---------------+---------+|  1 | 架构组    |  1 | 路人甲Java    |       1 ||  2 | 测试组    |  1 | 路人甲Java    |       1 ||  3 | java组    |  1 | 路人甲Java    |       1 ||  4 | 前端组    |  1 | 路人甲Java    |       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)1234567891011121314151617181920212223242526

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

内连接

语法：

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

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

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

过程用java伪代码如下：

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

示例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 |+---------------+-----------+| 路人甲Java    | 架构组    || 张三          | 测试组    || 李四          | 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 |+---------------+-----------+| 路人甲Java    | 架构组    || 张三          | 测试组    || 李四          | 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 |+---------------+-----------+| 路人甲Java    | 架构组    || 张三          | 测试组    || 李四          | java组    |+---------------+-----------+3 rows in set (0.00 sec)1234567891011121314151617181920212223242526272829

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

示例2：无连接条件

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

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

示例3：组合条件进行查询

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

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 |+---------------+-----------+| 路人甲Java    | 架构组    |+---------------+-----------+1 row in set (0.00 sec)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 |+---------------+-----------+| 路人甲Java    | 架构组    |+---------------+-----------+1 row 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 and t2.team_name = '架构组';+---------------+-----------+| emp_name      | team_name |+---------------+-----------+| 路人甲Java    | 架构组    |+---------------+-----------+1 row in set (0.00 sec)1234567891011121314151617181920212223

上面3中方式解说。

方式1：on中使用了组合条件。

方式2：在连接的结果之后再进行过滤，相当于先获取连接的结果，然后使用where中的条件再对连接结果进行过滤。

方式3：直接在where后面进行过滤。

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

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

外连接

外连接涉及到2个表，分为：主表和从表，要查询的信息主要来自于哪个表，谁就是主表。

外连接查询结果为主表中所有记录。如果从表中有和它匹配的，则显示匹配的值，这部分相当于内连接查询出来的结果；如果从表中没有和它匹配的，则显示null。

最终：外连接查询结果 = 内连接的结果 + 主表中有的而内连接结果中没有的记录。
外连接分为2种：
左外链接：使用left join关键字，left join左边的是主表。
右外连接：使用right join关键字，right join右边的是主表。

左连接

语法

select 列 from 主表 left join 从表 on 连接条件;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 |+---------------+-----------+| 路人甲Java    | 架构组    || 张三          | 测试组    || 李四          | java组    || 王五          | NULL      || 赵六          | NULL      |+---------------+-----------+5 rows in set (0.00 sec)12345678910111213141516171819

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

示例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 |+---------------+-----------+| 路人甲Java    | 架构组    || 张三          | 测试组    || 李四          | java组    |+---------------+-----------+3 rows in set (0.00 sec)12345678910111213141516171819

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

右连接

语法

select 列 from 从表 right join 主表 on 连接条件;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      |+-----------+---------------+| 架构组    | 路人甲Java    || 测试组    | 张三          || 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      |+-----------+---------------+| 架构组    | 路人甲Java    || 测试组    | 张三          || java组    | 李四          |+-----------+---------------+3 rows in set (0.00 sec)123456789101112131415161718192021222324252627282930313233343536373839

理解表连接原理

准备数据

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)1234567891011121314151617181920212223242526272829

我们来写几个连接，看看效果。

示例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)1234567891011121314151617181920212223

9条数据正常。

示例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 t2 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)1234567891011121314151617181920212223242526272829303132333435

上面的左连接第一个好理解。 liaoning/

第2个sql连接条件t1.a>10，这个条件只关联了test1表，再看看结果，是否可以理解？不理解的继续向下看，我们用java代码来实现连接查询。

第3个sql中的连接条件1=1值为true，返回结果为笛卡尔积。

java代码实现连接查询

package com.itsoku.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);
    }
}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176

代码中的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)1234567891011121314151617181920212223

运行一下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}}1234567891011

对比一下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)12345678910111213141516171819

运行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}1234567

效果和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.itsoku.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.itsoku.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);
    }
}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990

执行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}}1234567891011

执行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}1234567

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

扩展

表连接中还可以使用前面学过的group by、having、order by、limit。

这些关键字相当于在表连接的结果上在进行操作，大家下去可以练习一下，加深理解。

KLD_guo
关注
signature=2115bd79e3ad7a14f6ec4efd5feb6a3c,infi-20200730
weixin_29254029的博客
05-29 2万+
0001113148-20-000027.txt : 202007300001113148-20-000027.hdr.sgml : 2020073020200730190313ACCESSION NUMBER:0001113148-20-000027CONFORMED SUBMISSION TYPE:8-KPUBLIC DOCUMENT COUNT:16CONFORMED PERIOD OF R...
【PWN】House of Lore&House of Rabbit
u014377094的博客
05-04 3908
House of lore House of lore是一种利用small bin的利用方法。 前面我们通过修改unsorted bin与large bin的bk(bk_nextsize)位来造成对”任意“地址的更改。unsorted bin由于修改后，如果无法妥善处理bk指向的chunk的size位、bk位，会造成unsorted bin无法再使用，largebin由于是通过fd_nextsize来便利的，所以下次放入影响会小，而下次取出，假如可取出比修改的chunk小的chunk，还可以继续使用。以
【docker】Error : Conflict. The container name XXXXXl is already in use by container
u013938578的博客
02-18 1万+
问题描述： 执行： docker run --name mysql -p 3306:3306 -v /root/bo/data/mysql:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -it wzj/mysql docker: Error response from daemon: Conflict. The container name "/m...
Large bin attack
abelxu
11-26 1953
0x01 large bin Large bins 中一共包括 63 个 bin，index为64~126，每个 bin 中的 chunk 的大小不一致，而是处于一定区间范围内。（本文讨论的代码和结构都是在glibc2.23 64位的情况） 1.largebin的一些结构 在largebin的处理过程中会用到fd_next和bk_nextsize来加快chunk的处理。 struct malloc_chunk { INTERNAL_SIZE_T prev_size; /* Size of
LBR_iiwa_14_R820代码解析
魂淡林的博客
03-22 2790
-- This is a threaded script, and is just an example! --rmlMoveToJointPositions 是一个阻塞函数 只有线程子脚本能够使用 function sysCall_threadmain() --Put some initialization code here: jointHandles={-1,-1,-1...
hpi.rar_HPI DSP_dsp hpi_hpi
09-20
标题中的"hpi.rar_HPI_DSP_dsp_hpi_hpi"提到了几个关键术语：HPI、DSP以及HPI和DSP的结合。这表明压缩包内容可能包含与HPI（High Performance Interface，高性能接口）和DSP（Digital Signal Processing，数字信号...
hpi.rar_dsp hpi_hpi
09-19
标题中的"hpi.rar_dsp hpi_hpi"指的是一个关于HPI（Host Processor Interface）协议在ARM9处理器S3C2410和DSP（Digital Signal Processor）TMS320C6713之间的应用。这个压缩包包含了实现HPI交互的核心程序，通过"Hpi...
hpi.rar_arm HPI_arm dsp hpi_dsp HPI STM320DM642_hpi_hpi driver
09-19
标题中的"hpi.rar_arm HPI_arm dsp hpi_dsp HPI STM320DM642_hpi_hpi driver"揭示了这个压缩包文件的主要内容是关于HPI(High Performance Interface)驱动，特别针对ARM处理器和DSP(Digital Signal Processor)642芯片...
hpi.rar_hpi
09-24
【标题】"hpi.rar_hpi" 涉及的核心技术是HPI（Host Processor Interface），这是一种用于在不同处理器之间进行高效通信的接口标准。在这个压缩包中，我们主要探讨的是如何利用HPI驱动源码来实现DM642（一款TMS320C64...
HPI.rar_hpi
09-24
标题 "HPI.rar_hpi" 暗示我们关注的主题是关于使用PIC18f6XXX系列单片机与DSP5402之间的通信，这种通信是通过HPI（Hardware Port Interface，硬件端口接口）协议进行的。HPI是一种在微控制器和数字信号处理器之间...
wLHK-Dedecms漏洞整理.pdf
09-20
wLHK-Dedecms漏洞整理.pdf
Shell脚本实现生成SSL自签署证书
sakura379的博客
05-08 3277
这篇文章主要介绍了Shell脚本实现生成SSL自签署证书,本文直接给出实现代码,代码中包含大量注释,需要的朋友可以参考下 启用 apache 的 mod_ssl 之后需要有证书才能正常运作。写了个脚本来操作。首先要确定机器上已经有 openssl 。 复制代码 代码如下: #!/bin/sh ssl 证书输出的根目录。 sslOutputRoot="/etc/apache_ssl" if [ $...
log event entry exceeded max_allowed_packet； Increase max_allowed_packet on master
娜然的专栏
09-01 3294
mysql从库io进程停止，发错如下： Got fatal error 1236 from master when reading data from binary log: 'log event entry exceeded max_allowed_packet; Increase max_allowed_packet on master; the first event 'xxxx-master-binlog.000504' at 4212238517, the last event read fro
P5119 [USACO18DEC] Convention S提交5.80k通过2.31k时间限制1.00s内存限制125.00MB返回题目
最新发布
m0_74969835的博客
10-31 248
【代码】P5119 [USACO18DEC] Convention S提交5.80k通过2.31k时间限制1.00s内存限制125.00MB返回题目。
Understanding and Analyzing Application Crash Reports
diaoju3333的博客
12-04 753
Introduction When an application crashes, acrash reportis created and stored on the device. Crash reports describe the conditions under which the application terminated, in most cases includin...
AFL(American Fuzzy Lop)-afl-fuzz.c
Sizaif's 小屋
05-10 792
转载AFL(American Fuzzy Lop)源码详细解读（1） AFL(American Fuzzy Lop)源码详细解读（1） 多亏大佬们的文章，对读源码帮助很大： https://eternalsakura13.com/2020/08/23/afl/ http://rk700.github.io/ 最近在读AFL的源码，主要是主文件 afl-fuzz.c， 里面还是有很多细节需要注意，对一些重要的函数做了详细解读，部分函数大概知道是做什么的就可以了。其中还有些小问题没有理解，欢迎有兴趣的同学纠正.
Vulnhub Bsides Vancouver 2018
zhaji001
01-02 4124
简介：  靶机下载URL: https://www.vulnhub.com/entry/bsides-vancouver-2018-workshop,231/#release 虚拟机需要使用Virtualbox 直接导入VM, 攻击机器使用kali linux 如果你为了方便可不使用桥接模式，直接设置VM和kali在同一IP即可。如果在环境中有太多的机器就不太好分辨目标IP。 0x001 信...
靶机：BSides-Vancouver-2018-Workshop
AzVoidSUN的博客
06-30 521
靶机说明 靶机用ValualBox创建，目标是在其上获得root级访问。 目标 Boot to root：获得root权限和Flag。 运行环境 靶机：通过ValualBox打开虚拟机，网络连接方式设置为主机模式（host-only），或者将虚拟机、Kali机都桥接到物理机的无线网卡。测试中使用VMWare导入虚机会无法获得IP，使用ValualBox可正常获得IP。 攻击机：同网段下有Windows攻击机（物理机），安装有Nmap、Burpsuit、Wireshark、Sqlmap、nc、Hydra、Py
Linux 命令split 详解（参数详解）
热门推荐
phantom_dapeng的博客
03-26 1万+
在Linux上输入：split --help 或者 man split 可以看到相应的英文说明Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default size is 1000 lines, and default PREFIX is `x'.  With no INPUT, or when INPUT is -, ...
HPI驱动的通用ATCA系统管理软件开发探讨
本研究论文聚焦于"基于HPI的通用ATCA系统管理软件开发研究"这一主题。ATCA（Advanced Telecommunications Computing Architecture），即高级电信计算架构，作为一种高性能、模块化且可扩展的电信级硬件平台，在3G、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值