exists

mysql吧？这是一个创建表的sql，CREATE TABLE IF NOT EXISTS `tb_gonggao`如果表tb_gonggao不存在，就创建 `id` int(4) NOT NULL auto_increment,创建id字段，4位整数，不允许为空，且为自增字段`title` varchar(200) default NULL,创建title字段，200位字符串，默认值为nullPRIMARY KEY (`id`)设置主键为id字段 ENGINE=MyISAM 这表示使用MyISAM存储引擎DEFAULT CHARSET=latin1存储在数据库里的默认字符集 AUTO_INCREMENT=23 ;这个参考：http://blog.sina.com.cn/s/blog_5da3d5c50100bjh0.html

为了上rule34ifitexists需要在电脑上操作。1、首先，我们打开电脑，我们双击电脑桌面的开运行程序。2、接着，我们在打开-栏中输入regedit，并点击下方的确定按钮，进入注册列表界面。3、其次，我们找到或新建rule34项目。4、然后，我们双击打开该项目右边的默认数值。5、最后，我们将默认数值修改为0034，并点击确定按钮，此时，我们就能使用rule34项目。

美国IN102钴基沉淀硬化合金 美国IN102高温合金 美国IN102化学成分编号：N06102化学成分：Cr：15.0 Ni67.0 Mo：2.9 W3.0 NB:2.9 Ti：0.5 Al：0.5 Fe：7.0 C：0.06 B:0.005 Mg0.02 Zr0.03

SYS0003 : User already exists.什么意思

Morality and conscience exists because we realize it in the end.可以这样理解：之所以存在道德与良心，是因为我们最终意识到了。

怎么在where子句中用case when + existsSELECT (CASE WHEN MASTERJOB = "" THEN JOBNO ELSE MASTERJOB END)WO,JOBNO,CHILDJOB,CODE,BDESC,P_CODE,(SELECT TOP 1 BDESC FROM PRO WHERE CODE=RESVT.P_CODE)CBDESC,QTY,UNIT,LOC,(CASE WHEN exists(SELECT top 1 TAXUPFROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)WHERE B.CODE=RESVT.CODE AND A.WO like @gd AND B.TAXUP > 0 )THEN(SELECT top 1 TAXUPFROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)

SELECT (CASE WHEN MASTERJOB = "" THEN JOBNO ELSE MASTERJOB END)WO,JOBNO,CHILDJOB,CODE,BDESC,P_CODE,(SELECT TOP 1 BDESC FROM PRO WHERE CODE=RESVT.P_CODE)CBDESC,QTY,UNIT,LOC,(CASE WHEN exists(SELECT top 1 TAXUP FROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO) WHERE B.CODE=RESVT.CODE AND A.WO like @gd AND B.TAXUP > 0 ) THEN (SELECT top 1 TAXUP FROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO) WHERE B.CODE=RESVT.CODE AND B.TAXUP > 0 ) --AND charindex(@gd,WO)>0 WHEN exists( SELECT TOP 1 B.TAXUP FROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO) WHERE B.CODE=RESVT.CODE AND B.TAXUP > 0 order by B.[DATETIME] desc ) THEN (SELECT TOP 1 B.TAXUP FROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO) WHERE B.CODE=RESVT.CODE AND B.TAXUP > 0 order by B.[DATETIME] DESC) ELSE (select TOP 1 TAXUP from VQUT WHERE VQUT.CODE=RESVT.CODE order by [DATETIME] DESC) END)DJ,(CASE WHEN CHILDJOB="" THEN JOBNO ELSE CHILDJOB END)W,(SELECT TOP 1 SUM(QTY) FROM MRT WHERE JOBNO=RESVT.JOBNO AND CODE=RESVT.CODE AND P_CODE=RESVT.P_CODE)T,(SELECT TOP 1 SUM(QTY) FROM MRT WHERE JOBNO=RESVT.JOBNO AND CODE=RESVT.CODE AND P_CODE=RESVT.P_CODE AND MRNO LIKE "%HCBL%" )BL,(select TOP 1 SUM(BADQTY+PBADQTY+RETUQTY) from PRT Left JOIN PRTUDF ON PRT.PRNO=PRTUDF.PRNO AND PRT.ITEMNO=PRTUDF.ITEMNO WHERE JOBNO=RESVT.JOBNO AND CODE=RESVT.CODE AND P_CODE=RESVT.P_CODE)TL,(SELECT TOP 1 VEN FROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)WHERE B.CODE=RESVT.CODE AND A.WO like @gd )VEN,(SELECT TOP 1 qty_nee from #tree where #tree.code=RESVT.CODE AND #tree.p_code=RESVT.P_CODE)QTY_NEE,(SELECT TOP 1 sh from #tree where #tree.code=RESVT.CODE AND #tree.p_code=RESVT.P_CODE)SHFROM RESVT WHERE 1=1 and (CASE WHEN MASTERJOB = "" THEN JOBNO ELSE MASTERJOB END

　　简单的用法比如：selelct user_id, user_namefrom tb_users where user_id in (select user_id from tb_course)这个查询是查询在tb_course表中存在的user记录。使用exists，写成select user_id, user_namefrom tb_userswhere exists (select 1 from tb_course where tb_course.user_id = tb_users.user_id)exists用法是把主查询中的字段传入到子查询中去。如果有符合的条件，会停止全表检索，返回TRUE。所以效率才要高于IN，IN是要进行完全表检索得到集合才会结束执行。而EXISTS遇到符合的 条件，就会停止执行子查询。　　SELECT (CASE WHEN MASTERJOB = "" THEN JOBNO ELSE MASTERJOB END)WO,JOBNO,CHILDJOB,CODE,BDESC,P_CODE,(SELECT TOP 1 BDESC FROM PRO WHERE CODE=RESVT.P_CODE)CBDESC,QTY,UNIT,LOC,(CASE WHEN exists(SELECT top 1 TAXUPFROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)WHERE B.CODE=RESVT.CODE AND A.WO like @gd AND B.TAXUP > 0 )THEN(SELECT top 1 TAXUP FROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)WHERE B.CODE=RESVT.CODE AND B.TAXUP > 0 ) --AND charindex(@gd,WO)>0WHEN exists(SELECT TOP 1 B.TAXUPFROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)WHERE B.CODE=RESVT.CODE AND B.TAXUP > 0 order by B.[DATETIME] desc )THEN(SELECT TOP 1 B.TAXUPFROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)WHERE B.CODE=RESVT.CODE AND B.TAXUP > 0 order by B.[DATETIME] DESC)ELSE(select TOP 1 TAXUP from VQUT WHERE VQUT.CODE=RESVT.CODE order by [DATETIME] DESC)END)DJ,(CASE WHEN CHILDJOB="" THEN JOBNO ELSE CHILDJOB END)W,(SELECT TOP 1 SUM(QTY) FROM MRT WHERE JOBNO=RESVT.JOBNO AND CODE=RESVT.CODE AND P_CODE=RESVT.P_CODE)T,(SELECT TOP 1 SUM(QTY) FROM MRT WHERE JOBNO=RESVT.JOBNO AND CODE=RESVT.CODE AND P_CODE=RESVT.P_CODE AND MRNO LIKE "%HCBL%" )BL,(select TOP 1 SUM(BADQTY+PBADQTY+RETUQTY) from PRT Left JOIN PRTUDF ON PRT.PRNO=PRTUDF.PRNO AND PRT.ITEMNO=PRTUDF.ITEMNO WHERE JOBNO=RESVT.JOBNO AND CODE=RESVT.CODE AND P_CODE=RESVT.P_CODE)TL,(SELECT TOP 1 VEN FROM ANT B LEFT JOIN ANTUDF A ON (B.PANNO=A.PANNO and B.ITEMNO=A.ITEMNO)WHERE B.CODE=RESVT.CODE AND A.WO like @gd )VEN,(SELECT TOP 1 qty_nee from #tree where #tree.code=RESVT.CODE AND #tree.p_code=RESVT.P_CODE)QTY_NEE,(SELECT TOP 1 sh from #tree where #tree.code=RESVT.CODE AND #tree.p_code=RESVT.P_CODE)SHFROM RESVT WHERE 1=1 and (CASE WHEN MASTERJOB = "" THEN JOBNO ELSE MASTERJOB END

UPDATE stuMarks1 SET writtenExam=case when exists(select stuno from stuMarks1 where writtenExam>80) then writtenExam-2 else writtenExam-5end;相当于如下两句 UPDATE stuMarks1 SET writtenExam=writtenExam+2where exists (select stuno from stuMarks1 where writtenExam>80);UPDATE stuMarks1 SET writtenExam=writtenExam+5where not exists (select stuno from stuMarks1 where writtenExam>80);

COPY [/D] [/V] [/N] [/Y | /-Y] [/Z] [/A | /B ] source [/A | /B] [+ source [/A | /B] [+ ...]] [destination [/A | /B]]

arranged 是过去分词作形容词 ，arranged marriages 包办婚姻 这个整体是of 后面的内容。

名字已经被注册了

S.TID是 STUDENT 表内的，EXISTS是用来判断是不是存在 EXISTS(SELECT T.ID FROM TEACHER T);这样一句话只是查询一句话当然不行

1、关于在 Oracle8i 时代中in和exists的区别这里有条SQL语句：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次,遍历次数大大减少,效率大大提升.结论1:in()适合B表比A表数据小的情况这里还有一条SQL语句： select a.* from A a where exists(select 1 from B b where a.id=b.id)以上查询使用了exists语句,exists()会执行A.length次,它并不缓存exists()结果集,因为exists()结果集的内容并不重要,重要的是结果集中是否有记录,如果有则返回true,没有则返回false.它的查询过程类似于以下过程List resultSet=[];Array A=(select * from A)for(int i=0;i<A.length;i++) {if(exists(A[i].id) { //执行select 1 from B b where b.id=a.id是否有记录返回resultSet.add(A[i]);}}return resultSet;结论2:exists()适合B表比A表数据大的情况当B表比A表数据大时适合使用exists(),因为它没有那么遍历操作,只需要再执行一次查询就行.如:A表有10000条记录,B表有1000000条记录,那么exists()会执行10000次去判断A表中的id是否与B表中的id相等.如:A表有10000条记录,B表有100000000条记录,那么exists()还是执行10000次,因为它只执行A.length次,可见B表数据越多,越适合exists()发挥效果.再如:A表有10000条记录,B表有100条记录,那么exists()还是执行10000次,还不如使用in()遍历10000*100次,因为in()是在内存里遍历比较,而exists()需要查询数据库,我们都知道查询数据库所消耗的性能更高,而内存比较很快.当A表数据与B表数据一样大时,in与exists效率差不多,可任选一个使用.In适合内外表都很大的情况，exists适合外表结果集很小的情况。In和exists对比：若子查询结果集比较小，优先使用in，若外层查询比子查询小，优先使用exists。因为若用in，则Oracle会优先查询子查询，然后匹配外层查询，若使用exists，则oracle会优先查询外层表，然后再与内层表匹配。最优化匹配原则，拿最小记录匹配大记录2、关于在 Oracle8i 之后 时代中in和exists的区别in 是把外表和内表作hash join，而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=A.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=B.cc) 效率低，用到了A表上cc列的索引。带in的关联子查询是多余的，因为in子句和子查询中相关的操作的功能是一样的。如：select staff_name from staff_member where staff_id in(select staff_id from staff_func where staff_member.staff_id=staff_func.staff_id);为非关联子查询指定exists子句是不适当的，因为这样会产生笛卡乘积。如： select staff_name from staff_member where staff_idexists (select staff_id from staff_func);not in 和not exists如果查询语句使用了not in 那么内外表都进行全表扫描，没有用到索引；而not extsts 的子查询依然能用到表上的索引。所以无论哪个表大，用not exists都比not in要快。尽量不要使用not in子句。使用minus 子句都比not in 子句快，虽然使用minus子句要进行两次查询： select staff_name from staff_member where staff_id in (select staff_id from staff_member minus select staff_id from staff_func where func_id like "81%");in 与 "=" 的区别select name from student where name in ("zhang","wang","li","zhao");与select name from student where name="zhang" or name="li" or name="wang" or name="zhao"的结果是相同的。3、关于在 Oracle8i 之后 时代中in和exists的区别在ORACLE 11G大行其道的今天，还有很多人受早期版本的影响，记住一些既定的规则，1.子查询结果集小，用IN2.外表小，子查询表大，用EXISTS这是完全错误的观点。在8i时代，这经常是正确的，但是现在已经11G了，马上12C就要面世了。其实在ORACLE 9i CBO就已经优化了IN,EXISTS的区别，ORACLE优化器有个查询转换器，很多SQL虽然写法不同，但是ORACLE优化器会根据既定规则进行查询重写，重写为优化器觉得效率最高的SQL，所以可能SQL写法不同，但是执行计划却是完全一样的。IN与EXISTS有一点要记住：IN一般是用于非相关子查询，而EXISTS一般用于相关子查询。当然IN也可以用于相关子查询，EXISTS也可以用于非相关子查询。但是这区别很重要，虽然优化器很强大，但是查询转换是有一定的限制的，在EXISTS性能低下，无法进行相关查询转换，比如不能UNNEST SUBQUERY,那么可能我们需要改写SQL，通常可以用IN/JOIN等改写相关子查询，或对于含有OR的SEMI JOIN改为UNION ALL/UNION的形式。下面就用例子说明一下：DROP TABLE a;DROP TABLE b;CREATE TABLE a AS SELECT * FROM hr.employees;CREATE TABLE b AS SELECT * FROM hr.employees;--反复插入，构造20万行+INSERT INTO a SELECT * FROM a;INSERT INTO b SELECT * FROM a;COMMIT；BEGINdbms_stats.gather_table_stats(ownname => USER,tabname => "a",estimate_percent => 100,cascade => TRUE);dbms_stats.gather_table_stats(ownname => USER,tabname => "b",estimate_percent => 100,cascade => TRUE);END;/ 1.测试IN,EXISTS在简单查询中，是等价的SQL> set autotrace traceonly expSQL> SELECT * FROM a2 WHERE EXISTS(3 SELECT 1 FROM b WHERE a.employee_id=b.employee_id);执行计划----------------------------------------------------------Plan hash value: 2317816356---------------------------------------------------------------------------------| Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time |---------------------------------------------------------------------------------| 0 | SELECT STATEMENT | | 217K| 15M| 1375 (2)| 00:00:17 ||* 1 | HASH JOIN | | 217K| 15M| 1375 (2)| 00:00:17 || 2 | SORT UNIQUE | | 217K| 848K| 126 (1)| 00:00:02 || 3 | INDEX FAST FULL SCAN | IDX2_B | 217K| 848K| 126 (1)| 00:00:02 || 4 | TABLE ACCESS FULL | A | 217K| 14M| 620 (1)| 00:00:08 |---------------------------------------------------------------------------------Predicate Information (identified by operation id):---------------------------------------------------1 - access("A"."EMPLOYEE_ID"="B"."EMPLOYEE_ID")SQL> SELECT * FROM a2 WHERE a.employee_id IN (SELECT b.employee_id FROM b);执行计划----------------------------------------------------------Plan hash value: 2317816356---------------------------------------------------------------------------------| Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time |---------------------------------------------------------------------------------| 0 | SELECT STATEMENT | | 217K | 15M| 1375 (2) | 00:00:17 ||* 1 | HASH JOIN | | 217K | 15M| 1375 (2) | 00:00:17 || 2 | SORT UNIQUE | | 217K | 848K| 126 (1) | 00:00:02 || 3 | INDEX FAST FULL SCAN | IDX2_B | 217K | 848K| 126 (1) | 00:00:02 || 4 | TABLE ACCESS FULL | A | 217K | 14M| 620 (1) | 00:00:08 |---------------------------------------------------------------------------------Predicate Information (identified by operation id):---------------------------------------------------1 - access("A"."EMPLOYEE_ID"="B"."EMPLOYEE_ID") 可以看出，两个计划完全没有区别。类似于ORACLE查询重写为：SELECT a.* FROM a,(SELECT DISTINCT b.employee_id FROM b) b1 WHERE a.employee_id=b1.employee_id;结语：讨论SQL语句：select * from A where id in (1,2,3,4,5,6,7,8,9) 中 在Oracle8i 版本之后的Oracle数据库中性能是一样的。

没道理的改法，为什么非要用exists来实现呢，这个语句用exists来实现并不好

在查询中 select * from table where id exists()exists中的条件只要是真这个查询就是成立的

不要被别人误导了 要想知道真正结果 用plsql查看一下执行记录，你会有很多收获。用本人的亲身体会给你建议。

WOW是完美

exists 换成 in 尝试下

exists 是Oracle sql中的一个函数。表示是否存在符合某种条件的记录。如select * from A,Bwhere A.id=B.idand exists （SELECT * FROM A WHERE A.type LIKE "S%")exists 还有个功能就是 每次用到这个函数的时候就相当于测试了这条数据

没有

不是复数，是第三人称单数这个是动词，没有复数

in是介词，不能单独使用，或作谓语。例句：It"s in that drawer.它放在那个抽屉里。exist是动词，可以单独作谓语。(不用于进行时)存在；实际上有。例句：Does life exist on other planets?其他行星上有生命吗？

应该是select DISTINCT a.* 把?正确,去掉重复时显示。应该这样理解select * from 学生 a where 学生号 in(select 学生号 from 选课)举例子应该这样举比较好 如: T1: ID Name 1 a 2 c 3 a 选取对应ID=1的Name的数据 select * from t1 a where exists(select 1 from t1 where Name=a.Name and ID=1)

isdir 是判断是否是目录(文件夹) 关注的是文件的类型，而exists只是判断文件是否存在。

不对的 select * from tbl_a,tbl_b where tbl_a.uuid=tbl_b.uuid 这个不要用* 要指定某一列。其实exists就是和in 差不多。

一个用于检测子查询 一个在子查询中用于检测它的子查询

检查文件是否存在希望能帮到你！ 如果你对我的答案还满意请采纳非常感谢你的认同。谢谢。。。

n 是把外表和内表作hash 连接；exists 是对外表作loop循环，每次loop循环再对内表进行查询。一直以来认为exists比in效率高的说法是不准确的。如果查询的两个表大小相当，那么用in和exists差别不大。如果两个表中一个较小，一个是大表，则子查询表大的用exists，子查询表小的用in。希望对你有帮助。

IN 确定给定的值是否与子查询或列表中的值相匹配。 EXISTS 指定一个子查询，检测行的存在。 比较使用 EXISTS 和 IN 的查询 exists()后面的子查询被称做相关子查询 他是不返回列表的值的.只是返回一个ture或false的结果,其运行方式是先运行主查询一次 再去子查询里查询与其对应的结果 如果是ture则输出,反之则不输出.再根据主查询中的每一行去子查询里去查询. in()后面的子查询 是返回结果集的,换句话说执行次序和exists()不一样.子查询先产生结果集,然后主查询再去结果集里去找符合要求的字段列表去.符合要求的输出,反之则不输出.

你的数据明显就是可以使用 in 的，又不能使用 in ，只好 把这一组数据写到一个表里，这样就可以不用 in 而用 exists 了。几千条数据，你做一个临时表B，把数据写入临时表B里，然后用 select * from A where exists (select 1 from B where A.id = b.id)

in是集合查询，查询当前记录的属性值是否在一个集合中（集合或子查询）exist是存在查询，查询与当前记录关联的集合（子查询）是否存在记录

删除表Exists 方法 描述如果在 Dictionary 对象中指定的关键字存在，则返回 True，若不存在，则返回 False。（这句不是词语解释，这是数据库方法的名称！）一般drop table if exists是数据库里面的，后面接表名，如：drop table if exists xxx_book其意思是：如果数据库中存在xxx_book表，就把它从数据库中drop掉。备份sql中一般都有这样的语句，如果是数据库中有这个表，先drop掉，然后create表，然后再进行数据插入。拓展：数据库(Database)是按照数据结构来组织、存储和管理数据的仓库，它产生于距今六十多年前，随着信息技术和市场的发展，特别是二十世纪九十年代以后，数据管理不再仅仅是存储和管理数据，而转变成用户所需要的各种数据管理的方式。数据库有很多种类型，从最简单的存储有各种数据的表格到能够进行海量数据存储的大型数据库系统都在各个方面得到了广泛的应用。

不相关子查询：子查询的查询条件不依赖于父查询的称为不相关子查询。相关子查询：子查询的查询条件依赖于外层父查询的某个属性值的称为相关子查询，带EXISTS 的子查询就是相关子查询EXISTS表示存在量词：带有EXISTS的子查询不返回任何记录的数据，只返回逻辑值“True”或“False”

例学生表(t_student)和班级表(t_class)班级表：create table t_class ( id SERIAL not null, name VARCHAR(20) null, constraint PK_T_CLASS primary key (id));学生表：create table t_student ( id SERIAL not null, name VARCHAR(20) null, class_id INT8 null, constraint PK_T_STUDENT primary key (id));alter table t_student add constraint FK_T_STUDEN_REFERENCE_T_CLASS foreign key (class_id) references t_class (id) on delete restrict on update restrict;select * from t_student t1 where exists (select * from t_class t2 where t2.id = t1.class_id and t2.name = "一年级一班" );

用 perldoc 如perldoc dbi

in 和 exists区别in 是把外表和内表作hash join，而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=A.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=B.cc) 效率低，用到了A表上cc列的索引。带in的关联子查询是多余的，因为in子句和子查询中相关的操作的功能是一样的。如：select staff_name from staff_member where staff_id in(select staff_id from staff_func where staff_member.staff_id=staff_func.staff_id); 为非关联子查询指定exists子句是不适当的，因为这样会产生笛卡乘积。如： select staff_name from staff_member where staff_id exists (select staff_id from staff_func);not in 和not exists如果查询语句使用了not in 那么内外表都进行全表扫描，没有用到索引；而not extsts 的子查询依然能用到表上的索引。所以无论哪个表大，用not exists都比not in要快。尽量不要使用not in子句。使用minus 子句都比not in 子句快，虽然使用minus子句要进行两次查询： select staff_name from staff_member where staff_id in (select staff_id from staff_member minus select staff_id from staff_func where func_id like "81%"); in 与 "=" 的区别select name from student where name in ("zhang","wang","li","zhao");与select name from student where name="zhang" or name="li" or name="wang" or name="zhao"的结果是相同的。

in是遍历内存操作，esists是查询操作，当主表数据大于字表数据时，用in，当情况相反时用esists

in后面跟子查询的情况才能改写为exists

先是子条件。。。因为没有子条件外面条件没法执行，还有 写嵌套子查询的时候注意效率

1、exists 是判断的意思，通常后面有一个被判断的条件使用格式为：exists(被判断的条件)如果被判断的条件为真则返回值为真（ture），如果被判断的条件为假则返回值为假(false)2、与not exists相对，其意思恰恰和上面相反，调用格式是相同的。

存在，就是说，如果存在什么什么东西，就怎么怎么样

B

用exists和not exists代替in not in

hexists只用来判断是否存在参数所指定的hash字段，只可以带一个参数，返回值只有1（存在）和0（不存在）两种情况。redis> HSET myhash field1 "foo"(integer) 1redis> HEXISTS myhash field1(integer) 1redis> HEXISTS myhash field2(integer) 0redis> exists用来判断key是否存在，只有1组参数时用法和hexists一样，时间复杂度也一样，所以效率没区别。Redis3.0.3之后支持多组参数，返回存在的key的数量。redis> SET key1 "Hello"OKredis> EXISTS key1(integer) 1redis> EXISTS nosuchkey(integer) 0redis> SET key2 "World"OKredis> EXISTS key1 key2 nosuchkey(integer) 2redis>

这个貌似file类不行，你可以用net包下面的url跟httpurlconnection这两个类看看

java.io.File类的方法public boolean exists()用来判断一个文件是否存在，如:import java.io.*;public class Demo{public static void main(String[] args) throws Exception{//将p指定为文件的路径String p="test.txt";File f=new File(p);if(f.isFile()){if(f.exists()){System.out.println("文件"+p+"存在。");}else{System.out.println("文件"+p+"不存在。");}}else{System.out.println(p+"不是文件。");}}}

如果查询的两个表大小相当，那么用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=A.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=B.cc) 效率低，用到了A表上cc列的索引。not in 和not exists如果查询语句使用了not in 那么内外表都进行全表扫描，没有用到索引；而not extsts 的子查询依然能用到表上的索引。所以无论那个表大，用not exists都比not in要快。 in 与 =的区别 select name from student where name in ("zhang","wang","li","zhao"); 与 select name from student where name="zhang" or name="li" or name="wang" or name="zhao" 的结果是相同的。

存在

是的

exists 后面括号中，并不关心 SELECT 后的字段列表，只关心 FROM 后面返回的结果。有结果就是 true，反之为false 如果不加上 e.deptno=d.deptno，exists（）括号中的结果就跟emp 无关了。 加上 e.deptno=d.deptno：表示 如果 dept 表中存在 emp表中的empno要在dept中 资料行，并且这些emp 属于 sales 或者 research，则exists 为true。不加上 e.deptno=d.deptno：表示 只要dept中 的dname 包含 sales 或者 research，exists结果就是true，跟emp表没关系。类似于表关联，把 dname in () 括号中内容改成dept中不存在的值，查询结果就是空的了。dname in ("xxx","yyy")

exists 是Oracle sql中的一个函数.表示是否存在符合某种条件的记录.如select * from A,Bwhere A.id=B.idand exists （SELECT * FROM AWHERE A.type LIKE "S%")

exists 是Oracle sql中的一个函数。表示是否存在符合某种条件的记录。如select * from A,Bwhere A.id=B.idand exists （SELECT * FROM A WHERE A.type LIKE "S%")它和Oracle的另外一个函数IN很相似，你可以比较一下他们的用法，见下：http://www.blogjava.net/terry-zj/archive/2006/04/18/41662.html

IF EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N"[dbo].[表名]") AND type in (N"U"))DROP TABLE [dbo].[表名]如果存在就drop掉tablenot exists 类似如果不存在就。。。

EXISTS是判断是否存在,和in类似,但效率要比in高SELECT*FROMEMP(基础表)WHEREEMPNO>0ANDEXISTS(SELECT‘X"FROMDEPTWHEREDEPT.DEPTNO=EMP.DEPTNOANDLOC=‘MELB")SELECT*FROMEMP(基础表)WHEREEMPNO>0ANDDEPTNOIN(SELECTDEPTNOFROMDEPTWHERELOC=‘MELB")这两句效果一样

1、不带exists时，则将所有的t2.c3更新成t1.id; 注：t1需满足 t1.c1 = t2.c1 and t1.c2 = t2.c22、带exists时，则判断t1.id是否为空，如果为空则在1的基础上将t2.c3更新为空; 注：exists(select t1.id from t1 where t1.c1 = t2.c1 and t1.c2 = t2.c2);此句exists是判断t1.id 是否为空

简单点说 if EXISTS(select* from tb where name="abc") 就是这样用上面这句话的意思是 查询表tb 找name="abc"的列 如果有找到 exists返回真 否则 返回假 加上if语句 还可以取反操作 if not exists

存在

s in P表示当s与P中的某个值相等时 为真： not in 和not exists的区别如果查询语句使用了not in 那么内外表都进行全表扫描，子查询表小的用in，每次loop循环再对内表进行查询。如果查询的两个表大小相当in和exists区别in 是把外表和内表作hash 连接。 exists 相当于存在量词；而not extsts 的子查询依然能用到表上的索引。NOT EXISTS,也就是集合不为空只作用一个集合，而exists是对外表作loop循环。一直以来认为exists比in效率高的说法是不准确的; not exist P表示p为空时为真，那么用in和exists差别不大。所以无论那个表大，这样就可以加快速度。 in表示一个标量和一元关系的关系，而且关联时，需要用索引，没有用到索引，则子查询表大的用exists，一个是大表。如果两个表中一个较小：表示集合存在，一般都需要和子表进行关联,exists的用法跟in不一样。例如 exist P 表示P不空时为真。例如; s not in P 表示s与P中的每一个值都不相等时为真

if exists （select * from table whre a=1）--------（如果这个select 语句能查询出资料就执 begin end 中的语句）beginend

sql结构化查询语言（Structured Query Language）exists出现

简明英汉词典exist D.J.[iɡ"zist] K.K.[u026aɡ"zu026ast] vi. 1 存在, 有2 生存, 活下来, 幸存

类似问题以前也给其他朋友回答过，“exists的效率比in的高”的说法不完全正确，要视情况而定。“exists”和“in”是Oracle中，都是查询某集合的值是否存在在另一个集合，但对不同的数据有不同的用法，主要是在效率问题上存在很大的差别，以下有两个简单例子，以说明 “exists”和“in”的效率问题。1、 select * from Table1 where exists(select 1 from Table2 where Table1.a=Table2.a) ;Table1数据量小而Table2数据量非常大时，Table1<<Table2 时，exists的查询效率高。2、 select * from Table1 where Table1.a in (select Table2.a from Table2) ;Table1数据量非常大而Table2数据量小时，Table1>>Table2 时，in的查询效率高。通过使用EXISTS，Oracle会首先检查主查询，然后运行子查询直到它找到第一个匹配项，这就节省了时间。Oracle在执行IN子查询时，首先执行子查询，并将获得的结果列表存放在一个加了索引的临时表中。在执行子查询之前，系统先将主查询挂起，待子查询执行完毕，存放在临时表中以后再执行主查询。