in与exist not in与not exist 的区别

合集下载

ORACLE中IN和EXISTS的区别

ORACL‎E中IN‎和EXIS‎T S的区别‎EX‎I STS的‎执行流程‎‎s elec‎t * f‎r om t‎1 whe‎r e ex‎i sts ‎( sel‎e ct n‎u ll f‎r om t‎2 whe‎r e y ‎= x )‎可以理解‎为:‎f or x‎in (‎sele‎c t * ‎f rom ‎t1 )‎ loo‎p‎ if‎( ex‎i sts ‎( sel‎e ct n‎u ll f‎r om t‎2 whe‎r e y ‎= x.x‎)‎ t‎h en‎‎ OUT‎P UT T‎H E RE‎C ORD‎‎end ‎i f‎e nd l‎o op对‎于in 和‎exis‎t s的性能‎区别：‎如果子查‎询得出的结‎果集记录较‎少，主查询‎中的表较大‎且又有索引‎时应该用i‎n,反之如‎果外层的主‎查询记录较‎少，子查询‎中的表大，‎又有索引时‎使用exi‎s ts。

‎其实我‎们区分in‎和exis‎t s主要是‎造成了驱动‎顺序的改变‎（这是性能‎变化的关键‎），如果是‎e xist‎s，那么以‎外层表为驱‎动表，先被‎访问，如果‎是IN，那‎么先执行子‎查询，所以‎我们会以驱‎动表的快速‎返回为目标‎，那么就会‎考虑到索引‎及结果集的‎关系了‎‎‎‎‎‎另外IN时‎不对NUL‎L进行处理‎如：s‎e lect‎1 fr‎o m du‎a l wh‎e re n‎u ll ‎i n (0‎,1,2,‎n ull)‎为空‎2.NOT‎IN 与‎N OT E‎X ISTS‎:‎NOT‎EXIS‎T S的执行‎流程se‎l ect ‎.....‎fr‎o m ro‎l lup ‎Rwhe‎r e no‎t exi‎s ts (‎sele‎c t 'F‎o und'‎from‎titl‎e T‎‎‎‎‎‎ whe‎r e R.‎s ourc‎e_id ‎= T.T‎i tle_‎I D);‎可以理解为‎:for‎x in‎( se‎l ect ‎* fro‎m rol‎l up )‎‎ loo‎p‎‎ if ‎( not‎exis‎t s ( ‎t hat ‎q uery‎) ) ‎t hen‎‎‎‎OUTP‎U T‎‎ en‎d if;‎‎ end‎;注意‎:NOT ‎E XIST‎S与 N‎O T IN‎不能完全‎互相替换，‎看具体的需‎求。

SQL语句中exists和in的区别

SQL语句中exists和in的区别转⾃https:///liyasong/p/sql_in_exists.html 和 /lick4050312/article/details/4476333表展⽰查询中涉及到的两个表，⼀个user和⼀个order表，具体表的内容如下： user表： order表：in ⼀、确定给定的值是否与⼦查询或列表中的值相匹配。

in在查询的时候，⾸先查询⼦查询的表，然后将内表和外表做⼀个笛卡尔积，然后按照条件进⾏筛选。

所以相对内表⽐较⼩的时候，in的速度较快。

具体sql语句如下：1 SELECT2 *3 FROM4 `user`5 WHERE6 `user`.id IN (7 SELECT8 `order`.user_id9 FROM10 `order`11 ) 这条语句很简单，通过⼦查询查到的user_id 的数据，去匹配user表中的id然后得到结果。

该语句执⾏结果如下：它的执⾏流程是什么样⼦的呢？让我们⼀起来看⼀下。

⾸先，在数据库内部，查询⼦查询，执⾏如下代码：SELECT`order`.user_idFROM`order` 执⾏完毕后，得到结果如下：此时，将查询到的结果和原有的user表做⼀个笛卡尔积，结果如下：此时，再根据我们的user.id IN er_id的条件，将结果进⾏筛选（既⽐较id列和user_id 列的值是否相等，将不相等的删除）。

最后，得到两条符合条件的数据。

⼆、select * from A where id in(select id from B)以上查询使⽤了in语句,in()只执⾏⼀次,它查出B表中的所有id字段并缓存起来.之后,检查A表的id是否与B表中的id相等,如果相等则将A表的记录加⼊结果集中,直到遍历完A表的所有记录. 它的查询过程类似于以下过程List resultSet=[]; Array A=(select * from A); Array B=(select id from B);for(int i=0;i<A.length;i++) { for(int j=0;j<B.length;j++) { if(A[i].id==B[j].id) { resultSet.add(A[i]); break; } } } return resultSet;可以看出,当B表数据较⼤时不适合使⽤in(),因为它会B表数据全部遍历⼀次. 如:A表有10000条记录,B表有1000000条记录,那么最多有可能遍历10000*1000000次,效率很差. 再如:A表有10000条记录,B表有100条记录,那么最多有可能遍历10000*100次,遍历次数⼤⼤减少,效率⼤⼤提升.结论:in()适合B表⽐A表数据⼩的情况exists ⼀、指定⼀个⼦查询，检测⾏的存在。

SQL中EXISTS的用法

SQL中EXISTS的⽤法⽐如在Northwind数据库中有⼀个查询为SELECT c.CustomerId,CompanyName FROM Customers cWHERE EXISTS(SELECT OrderID FROM Orders o WHERE o.CustomerID=c.CustomerID)这⾥⾯的EXISTS是如何运作呢？⼦查询返回的是OrderId字段，可是外⾯的查询要找的是CustomerID和CompanyName字段，这两个字段肯定不在OrderID⾥⾯啊，这是如何匹配的呢？EXISTS⽤于检查⼦查询是否⾄少会返回⼀⾏数据，该⼦查询实际上并不返回任何数据，⽽是返回值True或FalseEXISTS 指定⼀个⼦查询，检测⾏的存在。

语法： EXISTS subquery参数： subquery 是⼀个受限的 SELECT 语句 (不允许有 COMPUTE ⼦句和 INTO 关键字)。

结果类型： Boolean 如果⼦查询包含⾏，则返回 TRUE ，否则返回 FLASE 。

例表A：TableIn例表B：TableEx（⼀）. 在⼦查询中使⽤ NULL 仍然返回结果集select * from TableIn where exists(select null)等同于： select * from TableIn（⼆）. ⽐较使⽤ EXISTS 和 IN 的查询。

注意两个查询返回相同的结果。

select * from TableIn where exists(select BID from TableEx where BNAME=TableIn.ANAME)select * from TableIn where ANAME in(select BNAME from TableEx)（三）. ⽐较使⽤ EXISTS 和 = ANY 的查询。

注意两个查询返回相同的结果。

select * from TableIn where exists(select BID from TableEx where BNAME=TableIn.ANAME)select * from TableIn where ANAME=ANY(select BNAME from TableEx)NOT EXISTS 的作⽤与 EXISTS 正好相反。

Oracle中in与exist,not in与not exist的性能问题

上星期五与ｈaieｒ讨论in跟exists的性能问题，正好想起原来公司的一个关于noｔ in的规定,本想做个实验证明我的观点是正确的，但多次实验结果却给了我一个比较大的教训。

我又咨询了下orａcle公司工作的朋友,确实是我持有的观点太保守了。

于是写个文章总结下，希望对大家有所启发。

后面可能有大篇是关于1００53 ｔraｃe的内容，只作实验证明,可直接忽略看最终的结论即可。

我们知道,in 是把外表和内表作hash 连接,而exｉsｔｓ是对外表作loｏp循环,每次loop循环再对内表进行查询。

一直以来认为exiｓｔｓ比ｉn效率高的说法是不准确的。

如果查询的两个表大小相当,那么用in和exｉsｔs是差别不大的。

但如果两个表中一个较小,一个是大表,则子查询表大的用exｉsts,子查询表小的用ｉn,效率才是最高的。

假定表A（小表）,表B(大表），ｃc列上都有索引:•ｓｅｌｅct ＊ fｒom A ｗhere cc iｎ（select ｃｃｆrom B）； --效率低,用到了A表上cc列的索引•select ＊ froｍ A ｗhｅre exiｓts(seｌeｃt cc from B wheｒｅ cc＝Ａ.cc); --效率高，用到了B 表上cｃ列的索引。

相反的：•select * fｒom B ｗｈｅrｅ cc ｉn （sｅleｃt ｃｃ from A); －-效率高，用到了B表上cc列的索引•ｓelｅct ＊ from B whｅre eｘists(select cｃｆroｍＡ wｈerｅ cc=)； --效率低，用到了A表上cc列的索引通过使用ｅxiｓtｓ,Ｏracle会首先检查主查询，然后运行子查询直到它找到第一个匹配项,这就节省了时间。

Oｒaclｅ在执行IＮ子查询时，首先执行子查询，并将获得的结果列表存放在一个加了索引的临时表中。

在执行子查询之前，系统先将主查询挂起,待子查询执行完毕,存放在临时表中以后再执行主查询。

MySQL中in与exists的使用及区别介绍

MySQL中in与exists的使⽤及区别介绍先放⼀段代码for(int i=0;i<1000;i++){for(int j=0;j<5;j++){System.out.println("hello");}}for(int i=0;i<5;i++){for(int j=0;j<1000;j++){System.out.println("hello");}}分析以上代码可以看到两⾏代码除了循环的次序不⼀致意外，其他并⽆区别，在实际执⾏时两者所消耗的时间和空间应该也是⼀致的。

但是这仅仅是在Java中，现在我们转化⼀下情景，最外层循环是数据库中的连接操作，内层循环为查找操作，那么现在两次的结果将相差巨⼤。

之所以出现这样的原因是数据库的特点决定的，数据库中相⽐较于查询操作⽽⾔，建⽴连接是更消耗资源的。

第⼀段代码建⽴了1000次连接，每⼀次连接却只做了5次查询，显然是很浪费的。

因此在我们对数据库进⾏操作时需要遵循的操作应当是⼩表驱动⼤表(⼩的数据集驱动⼤的数据集)。

in与exists表结构tbl_emp为员⼯表，deptld为部门id。

tbl_dept为部门表。

员⼯表中含有客⼈，其deptld字段为-1mysql> desc tbl_emp;+--------+-------------+------+-----+---------+----------------+| Field | Type | Null | Key | Default | Extra |+--------+-------------+------+-----+---------+----------------+| id | int(11) | NO | PRI | NULL | auto_increment || name | varchar(20) | YES | | NULL | || deptld | int(11) | YES | MUL | NULL | |+--------+-------------+------+-----+---------+----------------+3 rows in set (0.00 sec)mysql> desc tbl_dept;+----------+-------------+------+-----+---------+----------------+| Field | Type | Null | Key | Default | Extra |+----------+-------------+------+-----+---------+----------------+| id | int(11) | NO | PRI | NULL | auto_increment || deptName | varchar(30) | YES | MUL | NULL | || locAdd | varchar(40) | YES | | NULL | |+----------+-------------+------+-----+---------+----------------+3 rows in set (0.01 sec)我们知道对于⼀个公司⽽⾔相对于部门来说员⼯数要多得多。

SQL 里的 EXISTS与in、not exists与not in

SQL 里的EXISTS与in、not exists与not in2011-01-07 10:01:25| 分类：sql | 标签：|字号大中小订阅系统要求进行SQL优化，对效率比较低的SQL进行优化，使其运行效率更高，其中要求对SQL中的部分in/not in修改为exists/not exists修改方法如下：in的SQL语句SELECT id, category_id, htmlfile, title, convert(varchar(20),begintime,112) as pubtimeFROM tab_oa_pub WHERE is_check=1 andcategory_id in (select id from tab_oa_pub_cate where no='1')order by begintime desc修改为exists的SQL语句SELECT id, category_id, htmlfile, title, convert(varchar(20),begintime,112) as pubtimeFROM tab_oa_pub WHERE is_check=1 andexists (select id from tab_oa_pub_cate where tab_oa_pub.category_id=convert(int,no) and no='1') order by begintime desc分析一下exists真的就比in的效率高吗？我们先讨论IN和EXISTS。

select * from t1 where x in ( select y from t2 )事实上可以理解为：select *from t1, ( select distinct y from t2 ) t2where t1.x = t2.y;——如果你有一定的SQL优化经验，从这句很自然的可以想到t2绝对不能是个大表，因为需要对t2进行全表的“唯一排序”，如果t2很大这个排序的性能是不可忍受的。

in和extexs

in和exists的区别与SQL执行效率in和exists的区别与SQL执行效率最近很多论坛又开始讨论in和exists的区别与SQL执行效率的问题，本文特整理一些in和exists的区别与SQL执行效率分析SQL中in可以分为三类：1、形如select * from t1 where f1 in ('a','b')，应该和以下两种比较效率select * from t1 where f1='a' or f1='b'或者select * from t1 where f1 ='a' union all select * from t1 f1='b'你可能指的不是这一类，这里不做讨论。

2、形如select * from t1 where f1 in (select f1 from t2 where t2.fx='x')，其中子查询的where里的条件不受外层查询的影响，这类查询一般情况下，自动优化会转成exist语句，也就是效率和exist一样。

3、形如select * from t1 where f1 in (select f1 from t2 where t2.fx=t1.fx)，其中子查询的where里的条件受外层查询的影响，这类查询的效率要看相关条件涉及的字段的索引情况和数据量多少，一般认为效率不如exists。

除了第一类in语句都是可以转化成exists 语句的SQL，一般编程习惯应该是用exi sts而不用in，而很少去考虑in和exists的执行效率.in和exists的SQL执行效率分析A，B两个表，(1)当只显示一个表的数据如A，关系条件只一个如ID时，使用IN更快：select * from A where id in (select id from B)(2)当只显示一个表的数据如A，关系条件不只一个如ID，col1时，使用IN就不方便了，可以使用EXISTS：select * from Awhere exists (select 1 from B where id = A.id and col1 = A.col1)(3)当只显示两个表的数据时，使用IN，EXISTS都不合适，要使用连接：select * from A left join B on id = A.id所以使用何种方式，要根据要求来定。

Oracle中in与exist,notin与notexist性能问题

上星期五与haier讨论in跟exists的性能问题，正好想起原来公司的一个关于not in的规定，本想做个实验证明我的观点是正确的，但多次实验结果却给了我一个比较大的教训。

我又咨询了下oracle公司工作的朋友，确实是我持有的观点太保守了。

于是写个文章总结下，希望对大家有所启发。

后面可能有大篇是关于10053 trace的内容，只作实验证明，可直接忽略看最终的结论即可。

我们知道，in 是把外表和内表作hash 连接，而exists是对外表作loop循环，每次loop循环再对内表进行查询。

一直以来认为exists比in效率高的说法是不准确的。

如果查询的两个表大小相当，那么用in和exists是差别不大的。

但如果两个表中一个较小，一个是大表，则子查询表大的用exists，子查询表小的用in，效率才是最高的。

假定表A（小表），表B（大表），cc列上都有索引：•select * from A where cc in (select cc from B)。

--效率低，用到了A表上cc列的索引•select * from A where exists(select cc from B where cc=)。

--效率高，用到了B表上cc 列的索引。

相反的：•select * from B where cc in (select cc from A)。

--效率高，用到了B表上cc列的索引•select * from B where exists(select cc from A where cc=)。

--效率低，用到了A表上cc 列的索引通过使用exists，Oracle会首先检查主查询，然后运行子查询直到它找到第一个匹配项，这就节省了时间。

Oracle在执行IN子查询时，首先执行子查询，并将获得的结果列表存放在一个加了索引的临时表中。

在执行子查询之前，系统先将主查询挂起，待子查询执行完毕，存放在临时表中以后再执行主查询。

数据库in和exists的用法

数据库in和exists的用法数据库in和exists的用法的用法如下：SELECT DISTINCT MD001 FROM BOMMD WHERE MD001 NOT IN (SELECT MC001 FROM BOMMC)NOT EXISTS,exists的用法跟in不一样，一般都需要和子表进行关联，而且关联时，需要用索引，这样就可以加快速度select DISTINCT MD001 from BOMMD WHERE NOT EXISTS (SELECT MC001 FROM BOMMC where BOMMC.MC001 = BOMMD.MD001)exists是用来判断是否存在的，当exists(查询)中的查询存在结果时则返回真，否则返回假。

not exists则相反。

exists做为where 条件时，是先对where 前的主查询询进行查询，然后用主查询的结果一个一个的代入exists的查询进行判断，如果为真则输出当前这一条主查询的结果，否则不输出。

in和existsin 是把外表和内表作hash 连接，而exists是对外表作loop循环，每次loop循环再对内表进行查询。

一直以来认为exists比in效率高的说法是不准确的。

如果查询的两个表大小相当，那么用in和exists差别不大。

如果两个表中一个较小，一个是大表，则子查询表大的用exists，子查询表小的用in：例如：表A（小表），表B（大表）1：select * from A where cc in (select cc from B)效率低，用到了A表上cc列的索引；select * from A where exists(select cc from B where cc=)效率高，用到了B 表上cc列的索引。

相反的2：select * from B where cc in (select cc from A)效率高，用到了B表上cc列的索引；select * from B where exists(select cc from A where cc=)效率低，用到了A表上cc列的索引。

数据库in和exists的用法

数据库in和exists的用法数据库in和exists的用法的用法如下：SELECTDISTINCTMD001FROMBOMMDWHEREMD001NOTIN(SELECTMC001F ROMBOMMC)NOTEXISTS,exists的用法跟in不一样，一般都需要和子表进行关联，而且关联时，需要用索引，这样就可以加快速度selectDISTINCTMD001fromBOMMDWHERENOTEXISTS(SELECTMC001FR OMBOMMCwhereBOMMC.MC001=BOMMD.MD001)exists是用来判断是否存在的，当exists(查询)中的查询存在结果时则返回真，否则返回假。

notexists则相反。

exists做为where条件时，是先对where前的主查询询进行查询，然后用主查询的结果一个一个的代入exists的查询进行判断，如果为真则输出当前这一条主查询的结果，否则不输出。

in和existsin是把外表和内表作hash连接，而exists是对外表作loop循环，每次loop循环再对内表进行查询。

一直以来认为exists比in 效率高的说法是不准确的。

如果查询的两个表大小相当，那么用in和exists差别不大。

如果两个表中一个较小，一个是大表，则子查询表大的用exists，子查询表小的用in：例如：表A（小表），表B（大表）1：select*fromAwhereccin(selectccfromB)效率低，用到了A表上cc列的索引；select*fromAwhereexists(selectccfromBwherecc=)效率高，用到了B表上cc列的索引。

相反的2：select*fromBwhereccin(selectccfromA)效率高，用到了B表上cc列的索引；select*fromBwhereexists(selectccfromAwherecc=)效率低，用到了A表上cc列的索引。

exists和in的用法

"exists"和"in"在英语中常常用于不同的语境中，表达不同的含义。

以下是关于这两个词的一些基本用法和注意事项：**exists**1. **存在性**：这个词主要用于表达某个实体或概念在某个集合或范围内是存在的。

例如：“Does anyone exist in this class?”（这个班级里有人存在吗？）这里的“exist”是动词，表示“存在”。

2. **存在状态**：当我们谈论某个物体或情况的存在状态时，我们可能会使用“exists”。

例如：“My car exists in my garage.”（我的车在车库里。

）在这个句子中，“exists”表示的是一种存在状态。

**in**1. **在……里面**：这个用法主要用于表示位置或范围。

例如：“The cat is in the kitchen.”（猫在厨房里。

）在这个句子中，“in”表示的是空间位置。

2. **用某种语言或方式**：当我们在描述某种行为或情况时，我们可能会使用“in”。

例如：“She speaks French very well, in a clear and confident way.”（她法语说得非常好，用清晰而自信的方式。

）在这个句子中，“in”表示方式。

3. **在某个时间或时期**：当我们谈论某个事件或活动发生的时间或时期时，我们可能会使用“in”。

例如：“The party started in the early evening.”（晚会开始于傍晚早些时候。

）**用法建议**在使用这两个词时，建议根据语境选择合适的词。

一般来说，“exists”更常用于描述事物的存在状态，而“in”则更常用于描述空间位置、方式或时间。

同时，注意不要混淆这两个词的用法，以免产生误解。

另外，在某些情况下，你可能需要查阅相关词典或语法书籍以获取更准确和详细的解释。

这些资源通常会提供更多关于这两个词的用法、含义和例句的信息，帮助你更好地理解和使用它们。

exists的用法

两个集合的交集包含同时属于两个原集合的所有元素。
差集包含只属于两个集合中的第一个集合的元素。
EXISTS:指定一个子查询，检测行的存在。
本示例所示查询查找由位于以字母B开头的城市中的任一出版商出版的书名：
SELECTDISTINCTpub_nameFROMpublishersWHEREEXISTS(SELECT*FROMtitlesWHEREpub_id=publishers.pub_idANDtype=
WHEREpub_idIN
(SELECTpub_id
FROMpublishers
WHEREcityLIKE\'B%\')
GO
E.使用NOTEXISTS
NOTEXISTS的作用与EXISTS正相反。如果子查询没有返回行，则满足NOTEXISTS中的WHERE子句。本示例查找不出版商业书籍的出版商的名称：
NOTEXISTS:
例如，要查找不出版商业书籍的出版商的名称：
SELECTpub_nameFROMpublishersWHERENOTEXISTS(SELECT*FROMtitlesWHEREpub_id=publishers.pub_idANDtype=
'business')
下面的查询查找已经不销售的书的名称:
USEpubs
GO
SELECTtitle
FROMtitles
WHEREEXISTS
(SELECT*
FROMpublΒιβλιοθήκη shersWHEREpub_id=titles.pub_id
ANDcityLIKE\'B%\')
GO
-- Or, using IN:
USEpubs

in和not in的用法

in和not in的用法一、引言在数据库操作和编程中，`in` 和 `not in` 是常用的运算符，它们用于测试一个值是否存在于指定的集合中。

本文将详细介绍这两个运算符的用法，并通过示例来展示其应用。

二、`in` 的用法`in` 运算符用于测试一个值是否存在于指定的集合中。

如果值存在于集合中，则结果为真（即 `True`），否则为假（即 `False`）。

1. 数据库操作在数据库操作中，`in` 通常用于筛选符合特定条件的记录。

例如，在查询学生表中成绩在 A 到 C 之间的学生时，可以使用 `in` 运算符：```sqlSELECT * FROM students WHERE grade IN (A, B, C);```这将返回所有成绩在 A 到 C 之间的学生记录。

2. 编程语言在大多数编程语言中，`in` 运算符的使用方式类似。

以 Python 为例，假设我们有一个数字列表，并想检查一个数字是否在该列表中，可以使用 `in` 运算符：```pythonnumbers = [1, 2, 3, 4, 5]if 3 in numbers:print("数字 3 在列表中")else:print("数字 3 不在列表中")```这将输出 "数字 3 在列表中"，因为 3 确实存在于列表中。

`not in` 运算符则用于测试一个值是否不存在于指定的集合中。

如果值不在集合中，则结果为真（即 `True`），否则为假（即 `False`）。

1. 数据库操作在数据库操作中，`not in` 常用于筛选不符合特定条件的记录。

例如，如果我们想查询所有成绩低于 A 的学生，可以使用 `not in`：```sqlSELECT * FROM students WHERE grade NOT IN (A, B, C);```这将返回所有成绩低于 A 的学生记录。

in与existnotin与notexist的区别

in与existnotin与notexist的区别-- 1. EXISTS谓词 exists/not exists/in/not in存在量词带有EXISTS谓词的子查询不返回任何数据，只产生逻辑真值“true”或逻辑假值“false”。

若内层查询结果非空，则外层的WHERE子句返回真值若内层查询结果为空，则外层的WHERE子句返回假值由EXISTS引出的子查询，其目标列表达式通常都用* ，因为带EXISTS的子查询只返回真值或假值，给出列名无实际意义-- 2. NOT EXISTS谓词若内层查询结果非空，则外层的WHERE子句返回假值若内层查询结果为空，则外层的WHERE子句返回真值注不同形式的查询间的替换一些带EXISTS或NOT EXISTS谓词的子查询不能被其他形式的子查询等价替换所有带IN谓词、比较运算符、ANY和ALL谓词的子查询都能用带EXISTS谓词的子查询等价替换列：（1）查询与“刘晨”在同一个系学习的学生。

可以用带EXISTS谓词的子查询替换：SELECT Sno，Sname，SdeptFROM Student S1WHERE EXISTS(SELECT *FROM Student S2WHERE S2.Sdept = S1.Sdept ANDS2.Sname = ‘刘晨’)；（2）查询选修了全部课程的学生姓名。

SELECT SnameFROM StudentWHERE NOT EXISTS（SELECT *FROM CourseWHERE NOT EXISTS(SELECT *FROM SCWHERE Sno= Student.SnoAND Cno= /doc/0316377881.html,o））；-- sql语句中in与exist not in与not exist 的区别in和existsin 是把外表和内表作hash 连接，而exists是对外表作loop循环，每次loop循环再对内表进行查询。

对比分析MySQL语句中的IN和Exists

对⽐分析MySQL语句中的IN和Exists背景介绍最近在写SQL语句时，对选择IN 还是Exists 犹豫不决，于是把两种⽅法的SQL都写出来对⽐⼀下执⾏效率，发现IN的查询效率⽐Exists⾼了很多，于是想当然的认为IN的效率⽐Exists好，但本着寻根究底的原则，我想知道这个结论是否适⽤所有场景，以及为什么会出现这个结果。

⽹上查了⼀下相关资料，⼤体可以归纳为：外部表⼩，内部表⼤时，适⽤Exists；外部表⼤，内部表⼩时，适⽤IN。

那我就困惑了，因为我的SQL语句⾥⾯，外表只有1W级别的数据，内表有30W级别的数据，按⽹上的说法应该是Exists的效率会⽐IN⾼的，但我的结果刚好相反！！“没有调查就没有发⾔权”！于是我开始研究IN 和Exists的实际执⾏过程，从实践的⾓度出发，在根本上去寻找原因，于是有了这篇博⽂分享。

实验数据我的实验数据包括两张表：t_author表和 t_poetry表。

对应表的数据量：t_author表，13355条记录；t_poetry表，289917条记录。

对应的表结构如下：CREATE TABLE t_poetry (id bigint(20) NOT NULL AUTO_INCREMENT,poetry_id bigint(20) NOT NULL COMMENT '诗词id',poetry_name varchar(200) NOT NULL COMMENT '诗词名称',<font color=red> author_id bigint(20) NOT NULL COMMENT '作者id'</font>PRIMARY KEY (id),UNIQUE KEY pid_idx (poetry_id) USING BTREE,KEY aid_idx (author_id) USING BTREE) ENGINE=InnoDB AUTO_INCREMENT=291270 DEFAULT CHARSET=utf8mb4CREATE TABLE t_author (id int(15) NOT NULL AUTO_INCREMENT,author_id bigint(20) NOT NULL,</font>author_name varchar(32) NOT NULL,dynasty varchar(16) NOT NULL,poetry_num int(8) NOT NULL DEFAULT '0'PRIMARY KEY (id),<font color=red>UNIQUE KEY authorid_idx (author_id) USING BTREE) ENGINE=InnoDB AUTO_INCREMENT=13339 DEFAULT CHARSET=utf8mb4执⾏计划分析 IN 执⾏过程sql⽰例：select * from tabA where tabA.x in (select x from tabB where y>0 );其执⾏计划：（1）执⾏tabB表的⼦查询，得到结果集B，可以使⽤到tabB表的索引y；（2）执⾏tabA表的查询，查询条件是tabA.x在结果集B⾥⾯，可以使⽤到tabA表的索引x。

In和NotIn的使用注意事项和区别

In和NotIn的使⽤注意事项和区别总结：NULL值不能⽤⽤来+-*/, 不能⽤来<>, not in否则返回空或NULL即不可以 1. not in （select null），返回空2. not exists 如果条件中有null值，外层查询的null值会被返回。

3. in 和 exists 均会过滤掉条件中null值not In 相当于 <> all,如果 Not In 后⾯跟的是⼦查询的话，⼦查询中只要包含⼀个 null 的返回值，则会造成整个 Not in 字句返回空值，结果就是查询不会返回任何结果。

⽽ in 相当于 =any 的意思,可以有效处理⼦查询中返回空值的情况,返回正确的结果。

------------------------------------------------------------------------------------------------------not in ⽰例：--该例⼦想要返回没有下属的职员的姓名，如果⼦查询中有空值返回的话，则整个查询将没有结果返回SELECT st_nameFROM employees empWHERE emp.employee_id NOT IN (SELECT mgr.manager_id FROM employees mgr)说明：Null Values in a SubqueryThe SQL statement in the slide attempts to display all the employees who do not have anysubordinates. Logically, this SQL statement should have returned 12 rows. However, the SQLstatement does not return any rows. One of the values returned by the inner query is a null value and, therefore, the entire query returns no rowsThe reason is that all conditions that compare a null value result in a null. So whenever null valuesare likely to be part of the resultsset of a subquery, do not use the NOT INoperator. The NOT INoperator is equivalent to <> ALL.---------------------------------------------------------------------------------------------------------in 的⽰例：Notice that the null value as part of the results set of a subquery is not a problem if you use the INoperator. The IN operator is equivalent to =ANY. For example, to display the employees who have subordinates(下属), use the following SQL statement:SELECT st_nameFROM employees empWHERE emp.employee_id IN (SELECT mgr.manager_id FROM employees mgr);---------------------------------------------------------------------------------------------------------Alternatively, a WHERE clause can be included in the subquery to display all employees who do nothave any subordinates:--使⽤ Not In 的话，要注意除掉⼦查询中将要返回的空值SELECT last_nameFROM employeesWHERE employee_id NOT IN(SELECT manager_id FROM employees WHERE manager_id IS NOT NULL);。

数据库EXISTS与NOTEXISTS

数据库EXISTS与NOTEXISTSEXISTS与NOT EXISTSEXISTS：表⽰存在xxx。

在查询的外层添加⼀个EXISTS，当内层查询有结果，则该EXISTS返回true,反之返回falseNOT EXISTS:表⽰不存在xxx。

在查询的外层添加⼀个NOT EXISTS,当内层查询有结果，则该NOT EXISTS返回false,反之返回true##表⽣成的过程 ``` SELECT Sname FROM Student WHERE NOT EXISTS（1） (SELECT * FROM Course WHERE NOT EXISTS（2） (SELECT * FROM SC WHERE Sno= Student.Sno AND Cno= o)); ``` ###学⽣表 ![](/blog/1017814/201704/1017814-20170422154233899-361931250.png) ###课程表 ![](/blog/1017814/201704/1017814-20170422154308962-74150998.png) ###学⽣选课表 ![](/blog/1017814/201704/1017814-20170422154327915-791639455.png)以上⾯的为例：⾸先改例⼦中有两个EXISTS，我们先从最⾥⾯的内容开始，当⼀个元组和课程表中的第⼀个元组在最⾥层循环中与SC.sno和o进⾏匹配的时候。

（情况1）若配上最内层的WHERE将该数据插⼊到临时表中，第⼀个NOT EXISTS(指内层的NOT EXISTS,代码中的（2）)判断该临时表不为空则返回false。

（情况2）若没有匹配上最内层的WHERE返回false,则不将数据插⼊到临时的表中，第⼀个NOT EXISTS(是内层的NOT EXISTS,代码中的（2）)判断结果表为空返回true####当Course循环结束之后 ####第⼆个NOT EXISTS（最外层的NOT EXISTS，代码上的（1））判断该内层返回集是否为空。

数学notin和in 符号

数学notin和in 符号数学中的notin和in符号数学是一门以逻辑推理和符号计算为基础的学科，符号在数学中起着重要的作用。

在数学中，人们常常使用特定的符号来表示某些关系和操作。

其中，notin符号和in符号是表示集合中元素的关系的两个重要符号。

一、notin符号notin符号常表示“不属于”或“不在”的概念。

它通常在数学中用于集合论和逻辑推理中。

表示该元素不属于某个给定的集合。

在符号上，notin符号通常用一个斜线（/）加上一个ε（ε）符号来表示，形如："∉"。

例如，如果一个集合A = {1, 2, 3}，那么如果一个元素x不属于集合A，可以用符号表达为x∉A。

在数学推理中，notin符号常常用于否定某个条件或命题。

例如，如果命题P是“x = 2”，那么可以在逻辑推理中表示为：P∉{x}。

值得注意的是，notin符号的反义符号是in符号。

二、in符号in符号常表示“属于”的概念。

它同样常用于集合论和逻辑推理中，表示某个元素属于某个集合。

在符号上，in符号通常用一个小圆圈（∈）来表示。

例如，如果一个集合A = {1, 2, 3}，那么如果一个元素x属于集合A，可以用符号表达为x∈A。

同时，在逻辑推理中，in符号也可以表示命题成立的情况。

例如，如果命题P是“x = 2”，那么可以在逻辑推理中表示为：P∈{x}。

在使用in符号时，需要注意它的反义符号是notin符号。

三、notin和in符号的应用举例1. 集合的元素判断假设有两个集合A = {1, 2, 3}和B = {4, 5, 6}，我们可以使用notin 和in符号来判断元素的归属关系：若元素x在集合A中，则可以表示为x∈A；若元素x不在集合B中，则可以表示为x∉B。

2. 数字的属性判断对于某个数字x，可以使用notin和in符号来表示其属性：若x是偶数，则可以表示为x∈{2, 4, 6, ...}；若x不是奇数，则可以表示为x∉{1, 3, 5, ...}。