joinwhere过滤

A. inner join多表关联的时候 WHERE语句或JOIN语句中限定条件哪个速度快

1. inner join 与 在where 添加条件，性能应该差不多

2. 尽量使用Join 而不是Where来列出关联条件，特别是多个表联合内的时候。

3. 原因是：容

4. 在效率上，Where可能具有和Inner join一样的效率。但基本可以肯定的（通过SQLServer帮助和其它资料，以及本测试）是Join的效率不比Where差。

5. 使用Join可以帮助检查语句中的无效或者误写的关联条件

6. 通常db引擎会将where解析为join ，既然这样，何不直接使用join
   

B. SQL里select...where能与inner join 一起用吗

SQL里select...where能与inner join 可以一起用，解决方法如下：

1、首先创建一个临时表，用于sqlserver语法中的内INNER JOIN使用。

C. mysql where和 join on 哪个效率高

关于 “A LEFT JOIN B ON 条件表达式” 的一点提醒

ON 条件（“A LEFT JOIN B ON 条件表达式”中的ON）用来决定如何从 B 表中检索数据行，即使on中包含有A表中的列的限制条件，也不会过滤A的任何数据（A的数据只会通过where过滤）。

如果 B 表中没有任何一行数据匹配 ON 的条件,将会额外生成一行所有列为 NULL 的数据

在匹配阶段 WHERE 子句的条件都不会被使用。仅在匹配阶段完成以后，WHERE 子句条件才会被使用。它将从匹配阶段产生的数据中检索过滤。

让我们看一个 LFET JOIN 示例：

01

mysql> CREATE TABLE `proct`
(

02

`id` int(10)
unsigned NOT NULL auto_increment,

03

`amount` int(10)
unsigned default NULL,

04

PRIMARY KEY (`id`)

05

)
ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1

06

07

mysql> CREATE TABLE `proct_details`
(

08

`id` int(10)
unsigned NOT NULL,

09

`weight` int(10)
unsigned default NULL,

10

`exist` int(10)
unsigned default NULL,

11

PRIMARY KEY (`id`)

12

)
ENGINE=MyISAM DEFAULT CHARSET=latin1

13

14

mysql> INSERT INTO proct
(id,amount)

15

VALUES (1,100),(2,200),(3,300),(4,400);

16

Query
OK, 4 rows affected
(0.00 sec)

17

Records:
4 Duplicates: 0 Warnings: 0

18

19

mysql> INSERT INTO proct_details
(id,weight,exist)

20

VALUES (2,22,0),(4,44,1),(5,55,0),(6,66,1);

21

Query
OK, 4 rows affected
(0.00 sec)

22

Records:
4 Duplicates: 0 Warnings: 0

23

24

mysql> SELECT * FROM proct;

25

+----+--------+

26

|
id | amount |

27

+----+--------+

28

|
1 | 100 |

29

|
2 | 200 |

30

|
3 | 300 |

31

|
4 | 400 |

32

+----+--------+

33

4 rows in set (0.00
sec)

34

35

mysql> SELECT * FROM proct_details;

36

+----+--------+-------+

37

|
id | weight | exist |

38

+----+--------+-------+

39

|
2 | 22 | 0 |

40

|
4 | 44 | 1 |

41

|
5 | 55 | 0 |

42

|
6 | 66 | 1 |

43

+----+--------+-------+

44

4 rows in set (0.00
sec)

45

46

mysql> SELECT * FROM proct LEFT JOIN proct_details

47

ON (proct.id
= proct_details.id);

48

+----+--------+------+--------+-------+

49

|
id | amount | id | weight | exist |

50

+----+--------+------+--------+-------+

51

|
1 | 100 | NULL | NULL | NULL |

52

|
2 | 200 | 2 | 22 | 0 |

53

|
3 | 300 | NULL | NULL | NULL |

54

|
4 | 400 | 4 | 44 | 1 |

55

+----+--------+------+--------+-------+

56

4 rows in set (0.00
sec)

ON 子句和 WHERE 子句有什么不同？

一个问题：下面两个查询的结果集有什么不同么？

1

1. SELECT * FROM proct LEFT JOIN proct_details

2

ON (proct.id
= proct_details.id)

3

AND proct_details.id=2;

4

2. SELECT * FROM proct LEFT JOIN proct_details

5

ON (proct.id
= proct_details.id)

6

WHERE proct_details.id=2;

用例子来理解最好不过了：

01

mysql> SELECT * FROM proct LEFT JOIN proct_details

02

ON (proct.id
= proct_details.id)

03

AND proct_details.id=2;

04

+----+--------+------+--------+-------+

05

|
id | amount | id | weight | exist |

06

+----+--------+------+--------+-------+

07

|
1 | 100 | NULL | NULL | NULL |

08

|
2 | 200 | 2 | 22 | 0 |

09

|
3 | 300 | NULL | NULL | NULL |

10

|
4 | 400 | NULL | NULL | NULL |

11

+----+--------+------+--------+-------+

12

4 rows in set (0.00
sec)

13

14

mysql> SELECT * FROM proct LEFT JOIN proct_details

15

ON (proct.id
= proct_details.id)

16

WHERE proct_details.id=2;

17

+----+--------+----+--------+-------+

18

|
id | amount | id | weight | exist |

D. SQL问题，两个表联合查询筛选条件的问题。

带有中国的所有记录（ID=3时，只显示是中国的一条）：
select a.* from a inner join b on a.id=b.aid where b.tagname='中国版'

只有有香港权，所属ID全都不显示：
select a.* from a inner join b on a.id=b.aid where b.tagname='中国' and not exists(select 1 from b as c where c.id=a.id and tagname='香港')

E. oracle数据库中，left join后 where 的使用方法

可以这样理解：on是在生成连接表时起作用的，where是生成连接表之后对内连接表再进行过滤。
1、容 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。
2、where条件是在临时表生成好后，再对临时表进行过滤的条件。这时已经没有left join的含义（必须返回左边表的记录）了，条件不为真的就全部过滤掉。
使用left join时，无论on的条件是否满足，都会返回左表的所有记录，对于满足的条件的记录，两个表对应的记录会连接起来，对于不满足条件的记录，那右表字段全部是null。

F. mysql join中，on和where的区别

关于 “A LEFT JOIN B ON 条件表达式” 的一点提醒

ON 条件（“A LEFT JOIN B ON 条件表达式”中的）用来决定如何从 B 表中检索数据行，即使on中包含有A表中的列的限制条件，也不会过滤A的任何数据（A的数据只会通过where过滤）。

如果 B 表中没有任何一行数据匹配 ON 的条件,将会额外生成一行所有列为 NULL 的数据

在匹配阶段 WHERE 子句的条件都不会被使用。仅在匹配阶段完成以后，WHERE 子句条件才会被使用。它将从匹配阶段产生的数据中检索过滤。

让我们看一个 LFET JOIN 示例：

01

mysql> CREATE TABLE `proct`
(

02

`id` int(10)
unsigned NOT NULL auto_increment,

03

`amount` int(10)
unsigned default NULL,

04

PRIMARY KEY (`id`)

05

)
ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1

06

07

mysql> CREATE TABLE `proct_details`
(

08

`id` int(10)
unsigned NOT NULL,

09

`weight` int(10)
unsigned default NULL,

10

`exist` int(10)
unsigned default NULL,

11

PRIMARY KEY (`id`)

12

)
ENGINE=MyISAM DEFAULT CHARSET=latin1

13

14

mysql> INSERT INTO proct
(id,amount)

15

VALUES (1,100),(2,200),(3,300),(4,400);

16

Query
OK, 4 rows affected
(0.00 sec)

17

Records:
4 Duplicates: 0 Warnings: 0

18

19

mysql> INSERT INTO proct_details
(id,weight,exist)

20

VALUES (2,22,0),(4,44,1),(5,55,0),(6,66,1);

21

Query
OK, 4 rows affected
(0.00 sec)

22

Records:
4 Duplicates: 0 Warnings: 0

23

24

mysql> SELECT * FROM proct;

25

+----+--------+

26

|
id | amount |

27

+----+--------+

28

|
1 | 100 |

29

|
2 | 200 |

30

|
3 | 300 |

31

|
4 | 400 |

32

+----+--------+

33

4 rows in set (0.00
sec)

34

35

mysql> SELECT * FROM proct_details;

36

+----+--------+-------+

37

|
id | weight | exist |

38

+----+--------+-------+

39

|
2 | 22 | 0 |

40

|
4 | 44 | 1 |

41

|
5 | 55 | 0 |

42

|
6 | 66 | 1 |

43

+----+--------+-------+

44

4 rows in set (0.00
sec)

45

46

mysql> SELECT * FROM proct LEFT JOIN proct_details

47

ON (proct.id
= proct_details.id);

48

+----+--------+------+--------+-------+

49

|
id | amount | id | weight | exist |

50

+----+--------+------+--------+-------+

51

|
1 | 100 | NULL | NULL | NULL |

52

|
2 | 200 | 2 | 22 | 0 |

53

|
3 | 300 | NULL | NULL | NULL |

54

|
4 | 400 | 4 | 44 | 1 |

55

+----+--------+------+--------+-------+

56

4 rows in set (0.00
sec)

ON 子句和 WHERE 子句有什么不同？

一个问题：下面两个查询的结果集有什么不同么？

1

1. SELECT * FROM proct LEFT JOIN proct_details

2

ON (proct.id
= proct_details.id)

3

AND proct_details.id=2;

4

2. SELECT * FROM proct LEFT JOIN proct_details

5

ON (proct.id
= proct_details.id)

6

WHERE proct_details.id=2;

用例子来理解最好不过了：

01

mysql> SELECT * FROM proct LEFT JOIN proct_details

02

ON (proct.id
= proct_details.id)

03

AND proct_details.id=2;

04

+----+--------+------+--------+-------+

05

|
id | amount | id | weight | exist |

06

+----+--------+------+--------+-------+

07

|
1 | 100 | NULL | NULL | NULL |

08

|
2 | 200 | 2 | 22 | 0 |

09

|
3 | 300 | NULL | NULL | NULL |

10

|
4 | 400 | NULL | NULL | NULL |

11

+----+--------+------+--------+-------+

12

4 rows in set (0.00
sec)

13

14

mysql> SELECT * FROM proct LEFT JOIN proct_details

15

ON (proct.id
= proct_details.id)

16

WHERE proct_details.id=2;

17

+----+--------+----+--------+-------+

18

|
id | amount | id | weight | exist |

19

+----+--------+----+--------+-------+

20

|
2 | 200 | 2 | 22 | 0 |

21

+----+--------+----+--------+-------+

22

1
row in set (0.01
sec)

第一条查询使用 ON 条件决定了从 LEFT JOIN的 proct_details表中检索符合的所有数据行。

第二条查询做了简单的LEFT JOIN，然后使用 WHERE 子句从 LEFT JOIN的数据中过滤掉不符合条件的数据行。

再来看一些示例：

01

mysql>

02

mysql> SELECT * FROM proct LEFT JOIN proct_details

03

ON proct.id
= proct_details.id

04

AND proct.amount=100;

05

+----+--------+------+--------+-------+

06

|
id | amount | id | weight | exist |

07

+----+--------+------+--------+-------+

08

|
1 | 100 | NULL | NULL | NULL |

09

|
2 | 200 | NULL | NULL | NULL |

10

|
3 | 300 | NULL | NULL | NULL |

11

|
4 | 400 | NULL | NULL | NULL |

12

+----+--------+------+--------+-------+

13

4 rows in set (0.00
sec)

所有来自proct表的数据行都被检索到了，但没有在proct_details表中匹配到记录（proct.id = proct_details.id AND proct.amount=100 条件并没有匹配到任何数据）

01

mysql> SELECT * FROM proct LEFT JOIN proct_details

02

ON (proct.id
= proct_details.id)

03

AND proct.amount=200;

04

+----+--------+------+--------+-------+

05

|
id | amount | id | weight | exist |

06

+----+--------+------+--------+-------+

07

|
1 | 100 | NULL | NULL | NULL |

08

|
2 | 200 | 2 | 22 | 0 |

09

|
3 | 300 | NULL | NULL | NULL |

10

|
4 | 400 | NULL | NULL | NULL |

11

+----+--------+------+--------+-------+

12

4 rows in set (0.01
sec)

同样，所有来自proct表的数据行都被检索到了，有一条数据匹配到了。

G. inner join 后面的and条件如果换成where条件查询效率有什么区别

and 只是两表连接的关系，而不能作为查询条件，where则可以作为查询条件，实质内上是先去判断where后面的条容件，只有满足条件的数据才能和另一张表建立关系。比如a表中有3条数据（1，0）、（2，1），b表中有2条数据1、2。这时你的第一条sql能查出2条数据，即使b表没有count这个字段，但第二条sql就只能查出一条数据了，因为在a表中count大于0的只有ID为2的这条数据，然后通过on后面的关系就只能查出一条了

H. 表连接用where和join的区别是什么

区别来还是有的：（如自下）
1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。

2、where条件是在临时表生成好后，再对临时表进行过滤的条件。这时已经没有left join的含义（必须返回左边表的记录）了，条件不为真的就全部过滤掉。

I. 在join中加条件和where中条件的区别

on 是连接条件。
where 是取连接之后的记录的条件。
对于 left join、right join ，on 条件与 where 条件还是有区别的，举个例子版：

表 a：

id v
----
1 a1
2 a2
3 a3
4 a4
5 a5

表 b：

id v
----
1 b1
2 b2
3 b3
4 b4
5 b5

SQL 语句权

SELECT *
FROM a LEFT JOIN b ON a.id=b.id
AND a.id=1 AND b.id=2

结果
1 a1 NULL NULL
2 a2 NULL NULL
3 a3 NULL NULL
4 a4 NULL NULL
5 a5 NULL NULL

而如果我们把 a.id=1 AND b.id=2 写在 where 中，那么结果就是零条记录

J. left join 过滤条件写在on后面和写在where 后面的区别

left join 过滤条件原文如下：
create table t1(id int, feild int);
insert into t1 values(1 , 1);
insert into t1 values(1 , 2);
insert into t1 values(1 , 3);
insert into t1 values(1 , 4);
insert into t1 values(2 , 1);
insert into t1 values(2 , 2);
create table t2(id int, feild int);
insert into t2 values(1 , 1);
insert into t2 values(1 , 2);
insert into t2 values(1 , 5);
insert into t2 values(1 , 6);
insert into t2 values(2 , 1);
insert into t2 values(2 , 3);

select t1.*,t2.* from t1 left join t2 on t1.id=t2.id --取t1表的第一行,扫瞄表,按条件做对比,如果满足条件,就加入返回结果表.
然后取t1表的第二行,扫瞄t2表,按条件做对比,如果满足条件,就加入返回结果表.
重复以上过程,直到t1表扫描结束.

select t1.*,t2.* from t1 left join t2 on t1.id=t2.id and t1.feild=1 --给左表加条件的时候,左表满足条件的,按上面的过程返回值,左表不满足条件的,直接输出,右表的列补null
1 1 1 1
1 1 1 2
1 1 1 5
1 1 1 6
2 1 2 1
2 1 2 3
1 2 NULL NULL
1 3 NULL NULL
1 4 NULL NULL
2 2 NULL NULL

select t1.*,t2.* from t1 left join t2 on t1.id=t2.id where t1.feild=1 先执行where后连接查询

执行where后表为 1 , 1
2 , 1
用它来left join t2.