专题：SQL之EXISTS
专题：SQL之EXISTS
4
for(int i =0; i<EOFout;i++) { for (int j = 0 ; j<EOFin;j++) }
5
使用EXISTS，首先检查主查询，然后运行 子查询直到它找到第一个匹配项，这就节省 了时间。 而执行IN子查询时，首先执行子查询，并将 获得的结果列表存放在一个加了索引的临时 表中。在执行子查询之前，系统先将主查询 挂起，待子查询执行完毕，存放在临时表中 以后再执行主查询。 因此，使用EXISTS比使用IN通常查询速度 快。
12
思路二（EXISTS）
select Sname from student where NOT exists // (select * from course where NOT exists //不存在的提 //交给course (select * from SC where Sno = student.sno and cno = o) // 代//入 两个未知变量 )
select Sname from student where Sno IN (select Sno from SC group by Sno //根据Sno分组，统计每个 //学生选修了几门课程。如果等于course的 //总数，就是我们要找的Sno having count(*) = (select count(*) from course ) ) //统计course中共有几门课程
2
即：exists做为where 条件时，是先对 where 前的主查询进行查询，然后用主查询 的结果一个一个的代入exists的子查询进行 判断，如果为真则输出当前这一条主查询的 结果，否则不输出
3
建立程序循环的概念，这是一个动态的查询 过程。如 FOR循环 。 流程为首先取出外层中的第一个元组， 再 执行内层查询，将外层表的第一元组代入， 若内层查询为真，即有结果时，返回外层表 中的第一元 组，接着取出第二元组，执行 相同的算法。一直到扫描完外层整表 。
SQL中IN与EXISTS关键字
SQL中IN与EXISTS关键字 偶遇这样⼀个场景，使⽤IN关键字进⾏检索数据所消耗的时间是使⽤EXISTS关键字进⾏检索数据所消耗的时间的接近30倍。
⼀看差距这么⼤，查阅了⼀本SQL数据，其中也没有介绍多少，不过我们可以从其定义中可以领悟到⼀些差异。
（1）IN关键字：该操作符IN⽤于把⼀个值与⼀个指定列表进⾏⽐较，当被⽐较的值⾄少与列表中的⼀个值相匹配时，它会返回TRUE。
（2）EXISTS关键字：该操作符EXISTS⽤于搜索指定表⾥是否存在满⾜特定条件的记录。
根据这两个关键字作⽤的描述，可知：若是IN⼦句或者EXISTS⼦句都是采⽤SELECT语法检索出来的结果列表进⾏匹配的话，那么在IN⼦句中还要将被⽐较值与结果列表做进⼀步的循环⽐较，当IN中的被⽐较值能够匹配到结果列表中某个值，那么IN⼦句就会返回TRUE，否则的话就会返回FALSE；⽽在EXISTS⼦句中，若SELECT语句检索的结果值不为空，那么EXISTS⼦句直接将该结果集返回，若是检索的结果值为空的，那么EXISTS⼦句就返回空，也就是说EXISTS⼦句返回的就是SELECT语句返回的结果集，不需要再次做⽐较判断了。
-- INSELECT column1FROM table_nameWHERE some_col IN (SELECT column1 FROM table_name WHERE other_col >'xx');-- EXISTSSELECT column1FROM table_nameWHERE EXISTS (SELECT column1 FROM table_name WHERE other_col >'xx'); 上述代码⽰例只是⼀个象征性的对⽐说明，在同⼀个表中进⾏不同条件的多次检索，使⽤IN的⽅式：先根据条件检索出数据，然后some_col与结果列表进⾏循环⽐较；使⽤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 正好相反。
sql语言 exists语句的使用
用逻辑蕴函表达：查询学号为x的学生，对所有的课程y，只 要200215122学生选修了课程y，则x也选修了y。
形式化表示： 用P表示谓词 “学生200215122选修了课程y” 用q表示谓词 “学生x选修了课程y” 则上述查询为: (y) p q
带有EXISTS谓词的子查询(续）
由EXISTS引出的子查询，其目标列表达式通常都用* ，因 为带EXISTS的子查询只返回真值或假值，给出列名无实际 意义 2. NOT EXISTS谓词
若内层查询结果非空，则外层的WHERE子句返回假值 若内层查询结果为空，则外层的WHERE子句返回真值
带有EXISTS谓词的子查询(续）
带有EXISTS谓词的子查询(续）
查询选修了全部课程的学生姓名。
SELECT Sname FROM Student WHERE NOT EXISTS （SELECT * FROM Course WHERE NOT EXISTS (SELECT * FROM SC WHERE Sno= Student.Sno AND Cno= o ） ）；
带有EXISTS谓词的子查询(续）
不同形式的查询间的替换
一些带EXISTS或NOT EXISTS谓词的子查询不能被其他形式 的子查询等价替换 所有带IN谓词、比较运算符、ANY和ALL谓词的子查询都能用 带EXISTS谓词的子查询等价替换
用EXISTS/NOT EXISTS实现全称量词(难点) SQL语言中没有全称量词 （For all） 可以把带有全称量词的谓词转换为等价的带有存在量词的谓词： (x)P ≡ ( x( P))
等价变换： (y)p q ≡ (y ((p q )) ≡ (y (( p∨ q) )) ≡ y(p∧q)
sql中exists用法循环 -回复
sql中exists用法循环-回复SQL中的exists用法与循环SQL（Structured Query Language）是一种专为管理关系型数据库管理系统（RDBMS）而设计的语言。
在SQL中，可以使用exists关键字来判断查询结果是否存在，从而进行相关的操作或逻辑的判断。
本文将逐步解析exists关键字的用法以及如何使用它进行循环操作。
第一步，了解exists关键字的作用和语法exists关键字用于判断是否存在满足某个条件的行。
它的语法为：SELECT 列名FROM 表名WHERE EXISTS (子查询);在这个语法中，exists后面的子查询返回的结果集如果不为空，则exists 返回的结果为真；否则为假。
第二步，使用exists关键字进行循环操作的实例现假设有两个表：学生表（students）和成绩表（scores）。
学生表包含学生的学号（id）和姓名（name），成绩表包含学生的学号（id）和语文成绩（chinese_score）。
我们需要根据成绩表中每个学生的语文成绩，判断该学生是否及格。
如果成绩大于等于60分，则标记为及格；否则标记为不及格。
首先，我们需要编写一个外层查询来选取学生表中的每一条记录：SELECT id, nameFROM students;然后，我们在exists子查询中编写对应的条件来判断成绩是否及格：SELECT id, nameFROM studentsWHERE EXISTS (SELECT *FROM scoresWHERE students.id = scores.idAND chinese_score >= 60);在这个子查询中，我们判断学生表的学号与成绩表的学号相等，并且判断语文成绩是否大于等于60分。
如果返回的结果集不为空，则表示该学生及格。
第三步，使用exists关键字进行循环操作的注意事项- 在SQL中，exists关键字通常用于子查询中，作为一个条件进行判断。
sql语句exists用法
sql语句exists用法SQL语句中的EXISTS用于判断子查询结果集是否存在，如果子查询有结果集，则返回True，否则返回False。
EXISTS可以用在Where、Having、Select子句中，一般与IN操作符、ANY/SOME操作符和ALL操作符配合使用，在某些情况下，EXISTS可以优化查询性能。
EXISTS用法详解EXISTS语法：sqlSELECT column_name(s)FROM table_name 1WHERE EXISTS(SELECT column_name FROM table_name 2 WHERE condition);上面的语法中，column_name是我们要检索的列名，table_name1是我们要搜索的表名，condition是我们要满足的任何条件，column_name和table_name2在它们的子查询中被使用。
实际上，EXISTS语句根据子查询返回的结果是否为空来确定是否返回结果集，如果子查询至少返回一行，则存在记录，即EXISTS条件成立；反之，则不存在记录，即EXISTS条件不成立。
例如，在一个包含客户信息和订单信息的数据表中，我们想筛选出购买了某些产品的客户，那么可以使用以下SQL语句：sqlSELECT * FROM customersWHERE EXISTS(SELECT * FROM orders WHEREcustomers.customer_id=orders.customer_idAND orders.product_id IN (‘9991’,’9832’,’3834’));上面这个SQL查询将检查customer_id等于客户表的orders.customer_id的订单表。
如果订单表中包含任何三种产品中的任何一种，则返回所有匹配的客户表行。
EXISTS与IN关系虽然EXISTS和IN的目的有所不同，但它们可以用相同的方式执行操作。
sql中exist 用法
sql中exist 用法
在SQL中，EXISTS是一个用于检查子查询结果是否为空的运算符。
它返回一个布尔值，如果子查询至少返回一行，则返回true，否则返回false。
EXIST的用法如下：
1. 使用EXISTS进行简单的子查询检查：
SELECT column1, column2,... FROM table1 WHERE EXISTS (SELECT column1 FROM table2 WHERE condition);
这个查询将检查table2中是否存在满足指定条件的行，如果存在，则返回table1中指定的列。
2. 使用EXISTS进行关联查询：
SELECT column1, column2,... FROM table1 WHERE EXISTS (SELECT column1 FROM table2 WHERE condition1 AND table1.column2 = table2.column2);
这个查询将根据指定条件和关联条件进行关联查询，只返回满足关联条件的行。
3. 使用EXISTS进行多级子查询：
SELECT column1, column2,... FROM table1 WHERE EXISTS (SELECT column1 FROM table2 WHERE condition1 AND EXISTS (SELECT column1 FROM table3 WHERE condition2)); 这个查询将使用多个子查询进行检查和关联，只返回满足所有
条件的行。
请注意，子查询中的SELECT语句可以是任意有效的SELECT语句，并且可以根据具体的需求来编写。
sql的存在函数
sql的存在函数存在函数（EXISTS）是结构化查询语言（SQL）中的一种条件函数，主要用于判断是否存在满足指定条件的行。
存在函数通常与子查询结合使用，它返回一个布尔值，表示子查询是否返回了一个以上的行。
如果子查询返回了至少一行结果，则存在函数返回TRUE；否则，返回FALSE。
语法：```SELECT column_name(s)FROM table_nameWHERE EXISTS (SELECT column_name(s) FROM table_name WHERE condition);```在使用存在函数时，需要注意以下几点：1. 子查询必须返回至少一行结果，否则存在函数将返回FALSE。
2. 子查询中的列可以是外部查询中的列，也可以是子查询中的一部分。
通常使用子查询的主键或外键列进行匹配。
3. 存在函数可以嵌套使用，多个嵌套的存在函数可以构建更复杂的查询条件。
存在函数在实际应用中有以下几个常见的应用场景。
1. 检查关联记录的存在性存在函数通常用于检查一个表中的记录是否存在于另一个表中。
比如，我们有一个"orders"表和一个"customers"表，我们可以使用存在函数来查找是否有与某个客户关联的订单：```SELECT customerNameFROM customersWHERE EXISTS (SELECT orderNumber FROM orders WHERE orders.customerID = customers.customerID);```上述查询将返回所有存在于"orders"表中的客户名称。
2. 检查子级数据的存在性有时候我们需要检查某个表中是否存在满足某个条件的子集。
例如，我们有一个"categories"表和一个"products"表，我们想要查找是否存在某个类别下有产品：```SELECT categoryNameFROM categoriesWHERE EXISTS (SELECT productID FROM products WHERE products.categoryID = categories.categoryID);```上述查询将返回所有有产品的类别名称。
sql中的exists用法
sql中的exists⽤法查询选修语⽂（cno=21）的学⽣名单SELECT sname FROM student WHERE EXISTS ( SELECT 1 FROM sc WHERE o = 21 AND sc.sno = student.sno )查询没有选修语⽂（cno=21）的学⽣名单SELECT sname FROM student WHERE NOT EXISTS ( SELECT 1 FROM sc WHERE o = 21 AND sc.sno = student.sno )选修全部课程的学⽣名单（⼦查询）SELECT sname FROM student WHERE sno in (SELECT sc.sno FROM sc GROUP BY sc.sno HAVING count(1) = (SELECT count(1) from course))选修全部课程的学⽣名单（exists）select * from student t where not exists( select * from course s where not exists(select * from sc where t.sno=sc.sno and o= o )) 当有课程没有选修时，下⾯的查询有返回的记录数。
当全部课程都选择时，返回空( select * from course s where not exists(select * from sc where t.sno=sc.sno and o= o ))数据库表结构--课程表CREATE TABLE `course` (`cno` int(11) NOT NULL DEFAULT '0',`cname` varchar(255) DEFAULT NULL,PRIMARY KEY (`cno`)) ENGINE=MyISAM DEFAULT CHARSET=utf8mb4;INSERT INTO `course` VALUES ('20', '数学');INSERT INTO `course` VALUES ('21', '语⽂');INSERT INTO `course` VALUES ('22', '外语');--课程学⽣表CREATE TABLE `sc` (`sno` int(11) NOT NULL DEFAULT '0',`cno` int(11) NOT NULL DEFAULT '0',PRIMARY KEY (`sno`,`cno`)) ENGINE=MyISAM DEFAULT CHARSET=utf8mb4;INSERT INTO `sc` VALUES ('10', '20');INSERT INTO `sc` VALUES ('10', '21');INSERT INTO `sc` VALUES ('11', '20');INSERT INTO `sc` VALUES ('11', '21');INSERT INTO `sc` VALUES ('11', '22');INSERT INTO `sc` VALUES ('12', '22');--学⽣表CREATE TABLE `student` (`sno` int(11) NOT NULL DEFAULT '0',`sname` varchar(255) DEFAULT NULL,PRIMARY KEY (`sno`)) ENGINE=MyISAM DEFAULT CHARSET=utf8mb4;INSERT INTO `student` VALUES ('10', 'zhangsan'); INSERT INTO `student` VALUES ('11', 'lisi'); INSERT INTO `student` VALUES ('12', 'wangwu');。
SQL之EXISTS用法示例
AND EXISTS(SELECT C.FID FROM T_SAL_OUTSTOCK C WHERE C.FID=B.FID AND CONVERT(VARCHAR(10),C.FDATE,120)>='2018-07-01'
FROM T_SAL_OUTSTOCKENTRY B WHERE A.FENTRYID=B.FENTRYID
AND EXISTS(SELECT FID FROM T_SAL_OUTSTOCKENTRY_R C WHERE C.FID=B.FID AND C.FSRCBILLNO LIKE 'CA%' AND EXISTS(SELECT FID FROM T_SAL_OUTSTOCK D WHERE D.FID=C.FID AND CONVERT(VARCHAR(10),D.FDATE,120)>='2018-07-01' ) )
更新表信息嵌套exists最内层大范围筛选修改日期的fid信息次内层进一步筛选符合调拨单的fid信息嵌套外层筛选符合fid条件的分录内码fentryid信息updateasetafamountlc0afprice0fromtsaloutstockentrycawhereexistsselectfentryidfromtsaloutstockentrybwhereafentryidbfentryidandexistsselectfidfromtsaloutstockentryrcwherecfidbfidandcfsrcbillnolikecaandexistsselectfidfromtsaloutstockdwheredfidcfidandconvertvarchar10dfdate12020180701
exists用法sql
exists用法sql
在SQL中，`EXISTS`是用于检查子查询返回的结果集是否为空的关键字。
`EXISTS`通常与`WHERE`子句一起使用，用于过滤查询结果。
它的语法如下：
```sql
SELECT column1, column2, ...
FROM table
WHERE EXISTS (subquery)
```
在`EXISTS`后面的括号中，可以使用子查询来指定一个条件。
如果子查询返回的结果集非空，那么`EXISTS`的条件为真，否则为假。
下面是一个示例，使用`EXISTS`查找具有某种特定特征的记录： ```sql
SELECT emp_name
FROM employees
WHERE EXISTS (
SELECT emp_id
FROM departments
WHERE employees.emp_id = departments.emp_id
AND department_name = "Finance"
)
```
在这个例子中，`EXISTS`用于检查是否存在一个具有部门名称为"Finance"的记录。
如果存在，那么该员工的姓名将被返回。
请注意，`EXISTS`只关心子查询返回的结果集是否为空，而不关心实际返回的数据是什么。
因此，子查询可以包含任何有效的SQL语句，只要它返回一个结果集即可。
sql中exists的用法
sql中exists的用法SQL中的EXISTS语句是一种非常重要的查询方式，它用于判断一个子查询是否返回任何结果，如果存在，则返回TRUE，否则，返回FALSE。
这个方法为我们提供了一种在查询中过滤数据的有效手段，让我们能够更加精确地获取需要的结果。
在本文中，我们将深入探讨EXISTS语句，包括语法，用法和示例。
我们将覆盖以下主题：1. EXISTS语句的语法2. EXISTS语句的使用方法3. EXISTS语句的实际应用1. EXISTS语句的语法EXISTS语句的语法如下：```sqlSELECT column1, column2, ... column_nFROM table_nameWHERE EXISTS (subquery);```在上面的语法中，我们需要使用SELECT语句选择从表中获取的列，FROM子句指定要查询的表，WHERE子句中的EXISTS子句是包含条件的子查询。
我们可以与EXISTS一起使用NOT运算符来判断查询的子查询返回的结果是否为空，这里的语法为：```sqlSELECT column1, column2, ... column_nFROM table_nameWHERE NOT EXISTS (subquery);```在下面的示例中，我们将使用上述语法来讲解EXISTS语句更具体的细节。
2. EXISTS语句的使用方法现在，我们将介绍如何使用EXISTS语句进行数据查询。
为了更好的说明，我们将使用下面的两个表作为示例：1. employee表| emp_id | emp_name | emp_salary ||--------|----------|------------|| 101 | John | 5000 || 102 | Smith | 6000 || 103 | Jane | 7000 || 104 | James | 8000 || 105 | Michael | 9000 |2. department表| dept_id | dept_name ||---------|-----------|| 001 | IT || 002 | HR || 003 | Sales || 004 | Marketing |要使用EXISTS语句，我们需要构建一个子查询，并将其放在WHERE子句中。
sql中的exists
sql中的exists刚开始⼯作的开发，很容易过度的使⽤in、not in。
其实，在有些时候可以⽤exists、not exists来代替in和not in，实现查询性能的提升。
exists操作符时候会和in操作符产⽣混淆。
因为他们都是⽤于检查某个属性是否包含在某个集合中。
但是相同点也仅限于此。
exists的真正⽬的是检查⼦查询是否⾄少包含⼀条记录。
例如，下⾯的查询会返回⾏1和2：WITH numbers (nr) AS (SELECT 1 AS nr UNION ALLSELECT 2 AS nr UNION ALLSELECT 3 AS nr), letters (letter, nr) AS (SELECT 'A' AS letter, 1 AS nr UNION ALLSELECT 'B' AS letter, 2 AS nr)SELECT * FROM numbers n WHERE EXISTS (SELECT nr FROM letters WHERE nr= n.nr);当然，你也可以改写成in：WITH numbers (nr) AS (SELECT 1 AS nr UNION ALLSELECT 2 AS nr UNION ALLSELECT 3 AS nr), letters (letter, nr) AS (SELECT 'A' AS letter, 1 AS nr UNION ALLSELECT 'B' AS letter, 2 AS nr)SELECT * FROM numbers n WHERE n.nr IN (SELECT nr FROM letters);这两种写法，都可以返回相同的记录。
区别是exists会更快，因为在得到第⼀条满⾜条件的记录之后就会停⽌，⽽in会查询所有的记录(如果in返回很多⾏的话)。
SQL中EXISTS用法
SQL中EXISTS用法EXISTS 是判断是否存在,和in类似,但效率要比in高SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND EXISTS (SELECT ‘X'FROM DEPT WHERE DEPT.DEPTNO = EMP.DEPTNO AND LOC = ‘MELB')SELECT * FROM EMP (基础表) WHERE EMPNO > 0 AND DEPTNO IN(SELECT DEPTNO FROM DEPT WHERE LOC = ‘MELB')这两句效果一样EXISTS或者NOT EXISTS是把主查询的字段传到后边的查询中作为条件，返回值是TRUE或者FALSE。
EXISTS TRUE，那么就是查询条件成立，结果会显示出来。
NOT EXISTS TRUE，则为FALSE，查询连接条件不成立。
select * from course where not exists(select * from grade where grade.课程代号=course.课程代号)这个语句，是查询course表中课程代号在grade中没有出现的数据。
看看grade表，课程编号有K01到K06，而COURSE表，有K01到K07，那么K07在GRADE表是不存在的，那么，是符合条件的。
同样select * from course where exists(select * from grade where grade.课程代号=course.课程代号)则是查询COURSE的记录条件为编号在GRADE中存在。
那么很明显，结果是K01到K06的数据。
另外，EXISTS和NOT EXISTS的作用可以用IN或NOT IN实现，但是，效率要高。
因为EXISTS和NOT EXISTS返回的结果是TRUE或者FALSE，那么则在子查询中，遇到第一个符合条件的结果，就会退出查询，而不会进行全表的检索。
sql exists用法
sql exists用法
EXISTS 是SQL语言中的一种运算符，其作用是判断子查询是否返回任何行，如果返
回则结果为“True”，反之为”False”。
EXISTS 常用于子查询中，它返回子查询是否返
回任何的记录值，如果子查询返回任何行，则EXISTS 会返回true，否则，返回false。
EXISTS 常用于SELECT 或者 UPDATE 语句中, WHERE 条件也可以选择。
EXISTS 用在SELECT 中的语句如下：
SELECT *
FROM 表A
WHERE EXISTS（SELECT 1 FROM 表 B WHERE 表A.字段A = 表B.字段A）
上面的例子表示：从表A查询出符合条件的行，条件是子查询从表B中返回的行的字
段A的值和表A的字段A的值相同。
即从表A中获取：字段A的值在表B 中存在的行。
还有许多用法，但必须记住，EXISTS操作符仅供返回布尔值（True 或False），它
不会返回实际的行。
通过使用 EXISTS，可以在 WHERE 子句中组合出更复杂的 SQL 语句。
sql中exist的用法
sql中exist的用法
exist是一种用于判断子查询是否返回结果的函数。
其语法为：EXISTS(subquery)。
如果subquery返回至少一行结果，则exist返
回true，否则返回false。
在sql中，exist常常与关键词IN或NOT IN搭配使用，例如： SELECT *
FROM Table1
WHERE EXISTS (
SELECT *
FROM Table2
WHERE Table1.key = Table2.key
);
这个查询将返回Table1表中的所有行，其中key列的值存在于Table2表中的key列中。
在实际应用中，exist可以用于优化sql语句的性能。
由于exist 只判断子查询是否返回结果，而不会返回实际结果集，因此对于大型数据集和复杂查询，使用exist可以减少查询的开销和提高查询效率。
总之，exist是sql中一个非常实用的函数，可以用于判断子查询是否返回结果并优化查询的性能。
- 1 -。
SQL进阶系列之8EXISTS谓词的用法
SQL进阶系列之8EXISTS谓词的⽤法写在前⾯⽀撑SQL和关系数据库的基础理论：数学领域的集合论和逻辑学标准体系的谓词逻辑理论篇什么是谓词？谓词是返回值为真值(true false unknown)的函数关系数据库⾥，每⼀个⾏数据可以看作是⼀个命题实体的阶层0阶实体(单⾏) -- 1阶谓词( = between and)1阶实体(⾏集合/表) -- 2阶谓词 (exists)2阶实体(表的集合) -- 3阶谓词 1970被毙掉，⽬前数据库均以⼆阶谓词为基准全称量化与存在量化全称量词：所有的x都满⾜条件P存在量词：存在(⾄少有⼀个)满⾜条件P的xEXISTS谓词实现了存在量词(因此，可以根据德摩根律实现全称量化)实践篇查询表中不存在的数据/* 查询表中“不”存在的数据 */CREATE TABLE Meetings(meeting CHAR(32) NOT NULL,person CHAR(32) NOT NULL,PRIMARY KEY (meeting, person));INSERT INTO Meetings VALUES('第1次', '伊藤');INSERT INTO Meetings VALUES('第1次', '⽔岛');INSERT INTO Meetings VALUES('第1次', '坂东');INSERT INTO Meetings VALUES('第2次', '伊藤');INSERT INTO Meetings VALUES('第2次', '宫⽥');INSERT INTO Meetings VALUES('第3次', '坂东');INSERT INTO Meetings VALUES('第3次', '⽔岛');INSERT INTO Meetings VALUES('第3次', '宫⽥');-- 求所有⼈参加所有会的笛卡尔积SELECT DISTINCT m1.meeting,m2.person FROM Meetings AS m1 CROSS JOIN Meetings AS m2;-- 求出缺席者的SQL语句(1):存在量化的应⽤SELECT DISTINCT m1.meeting,m2.personFROM Meetings AS m1 CROSS JOIN Meetings AS m2WHERE NOT EXISTS (SELECT * FROM Meetings AS m3 WHERE m1.meeting = m3.meeting AND m2.person = m3.person);-- 求出缺席者的SQL语句(2):使⽤差集运算SELECT m1.meeting,m2.personFROM Meetings AS m1,Meetings AS m2EXCEPTSELECT meeting,personFROM Meetings;全称量词(1)：习惯"肯定\Leftrightarrow双重否定"之间的转换/* 全称量化（1）：习惯“肯定<＝>双重否定”之间的转换 */CREATE TABLE TestScores(student_id INTEGER,subject VARCHAR(32) ,score INTEGER,PRIMARY KEY(student_id, subject));INSERT INTO TestScores VALUES(100, '数学',100);INSERT INTO TestScores VALUES(100, '语⽂',80);INSERT INTO TestScores VALUES(100, '理化',80);INSERT INTO TestScores VALUES(200, '数学',80);INSERT INTO TestScores VALUES(200, '语⽂',95);INSERT INTO TestScores VALUES(300, '数学',40);INSERT INTO TestScores VALUES(300, '语⽂',90);INSERT INTO TestScores VALUES(300, '社会',55);INSERT INTO TestScores VALUES(400, '数学',80);-- 查出所有科⽬分数都在50分以上的学⽣SELECT DISTINCT student_id FROM TestScores AS TS1WHERE NOT EXISTS (SELECT * FROM TestScores AS TS2 WHERE TS2.student_id= TS1.student_id AND TS2.score < 50) -- 仅就本题⽽⾔，还可以使⽤min(score)>=50-- 查找出数学分数>=80,语⽂分数>=50的学⽣SELECT DISTINCT student_id FROM TestScores AS TS1WHERE subject IN ('数学','语⽂') AND NOT EXISTS (SELECT * FROM TestScores AS TS2 WHERE TS2.student_id= TS1.student_id AND 1 = CASE WHEN subject = '数学' AND score < 80 THEN 1WHEN subject = '语⽂' AND score < 50 THEN 1 ELSE 0 END)GROUP BY student_idHAVING COUNT(*) = 2; -- group by having ⼦句要求两门课程都要有成绩全称量化(2)：集合和谓词，哪个更强⼤？/* 全称量化（2）：集合VS谓词——哪个更强⼤？ */CREATE TABLE Projects(project_id VARCHAR(32),step_nbr INTEGER ,status VARCHAR(32),PRIMARY KEY(project_id, step_nbr));INSERT INTO Projects VALUES('AA100', 0, '完成');INSERT INTO Projects VALUES('AA100', 1, '等待');INSERT INTO Projects VALUES('AA100', 2, '等待');INSERT INTO Projects VALUES('B200', 0, '等待');INSERT INTO Projects VALUES('B200', 1, '等待');INSERT INTO Projects VALUES('CS300', 0, '完成');INSERT INTO Projects VALUES('CS300', 1, '完成');INSERT INTO Projects VALUES('CS300', 2, '等待');INSERT INTO Projects VALUES('CS300', 3, '等待');INSERT INTO Projects VALUES('DY400', 0, '完成');INSERT INTO Projects VALUES('DY400', 1, '完成');INSERT INTO Projects VALUES('DY400', 2, '完成');-- 查询完成到了⼯程1的项⽬ having⼦句解法SELECT product_id FROM Projects GROUP BY project_id HAVING COUNT(*) = SUM(CASE WHEN step_nbr <= AND status = '完成' THEN 1 WHEN step_nbr > 1 AND status = '等待' THEN 1 ELSE 0 END); -- 查询完成到了⼯程1的项⽬ having⼦句解法谓词解法SELECT * FROM Projects P1 WHERE NOT EXISTS (SELECT status from Projects P2 WHERE P1.project_id = P2.project_id AND status <> CASE WHEN step_nbr <= 1 THEN '完成' ELSE '等待' END);-- 劣势：双重否定，不易理解；优势：性能好，只要有⼀个⾏满⾜条件，查询就会终⽌；包含的信息更全对列进⾏量化：查询全是1的⾏/* 对列进⾏量化：查询全是1的⾏ */CREATE TABLE ArrayTbl(keycol CHAR(1) PRIMARY KEY,col1 INTEGER,col2 INTEGER,col3 INTEGER,col4 INTEGER,col5 INTEGER,col6 INTEGER,col7 INTEGER,col8 INTEGER,col9 INTEGER,col10 INTEGER);--全为NULLINSERT INTO ArrayTbl VALUES('A', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);INSERT INTO ArrayTbl VALUES('B', 3, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);--全为1INSERT INTO ArrayTbl VALUES('C', 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);--⾄少有⼀个9INSERT INTO ArrayTbl VALUES('D', NULL, NULL, 9, NULL, NULL, NULL, NULL, NULL, NULL, NULL);INSERT INTO ArrayTbl VALUES('E', NULL, 3, NULL, 1, 9, NULL, NULL, 9, NULL, NULL);-- "列⽅向"的全称量化：查找全是1的⾏不优雅的解答SELECT * FROM ArrayTbl WHERE col1 = 1 AND col2 = 1 AND col3 = 1 AND col4 = 1 AND col5 = 1AND col6 = 1 AND col7 = 1 AND col8 = 1 AND col9 = 1 AND col10 = 1;-- "列⽅向"的全称量化：查找全是1的⾏优雅的解答SELECT * FROM ArrayTbl WHERE 1 = ALL (values(col1),(col2),(col3),(col4),(col5),(col6),(col7),(col8),(col9),(col10));-- "列⽅向"的全称量化：查找某⼀列是9的⾏SELECT * FROM ArrayTbl WHERE 9 = ANY (values(col1),(col2),(col3),(col4),(col5),(col6),(col7),(col8),(col9),(col10));-- "列⽅向"的全称量化：查找某⼀列是9的⾏SELECT * FROM ArrayTbl WHERE 9 IN (col1,col2,col3,col4,col5,col6,col7,col8,col9,col10);-- 查找全是NULL的⾏SELECT * FROM ArrayTbl WHERE COALESCE(col1,col2,col3,col4,col5,col6,col7,col8,col9,col10) IS NULL;⼩结SQL中的谓词指的是返回真值的函数EXISTS与其他谓词不同，接受的参数是集合因此EXISTS可以看成⼀种⾼阶函数SQL没有与全称量词相当的谓词，可以使⽤NOT EXISTS代替练习题/* 练习题1-8-1:数组表——⾏结构表的情况 */CREATE TABLE ArrayTbl2(key CHAR(1) NOT NULL,i INTEGER NOT NULL,val INTEGER,PRIMARY KEY (key, i));/* A全为NULL、B仅有⼀个为⾮NULL、C全为⾮NULL */INSERT INTO ArrayTbl2 VALUES('A', 1, NULL);INSERT INTO ArrayTbl2 VALUES('A', 2, NULL);INSERT INTO ArrayTbl2 VALUES('A', 3, NULL);INSERT INTO ArrayTbl2 VALUES('A', 4, NULL);INSERT INTO ArrayTbl2 VALUES('A', 5, NULL);INSERT INTO ArrayTbl2 VALUES('A', 6, NULL);INSERT INTO ArrayTbl2 VALUES('A', 7, NULL);INSERT INTO ArrayTbl2 VALUES('A', 8, NULL);INSERT INTO ArrayTbl2 VALUES('A', 9, NULL);INSERT INTO ArrayTbl2 VALUES('A',10, NULL);INSERT INTO ArrayTbl2 VALUES('B', 1, 3);INSERT INTO ArrayTbl2 VALUES('B', 2, NULL);INSERT INTO ArrayTbl2 VALUES('B', 3, NULL);INSERT INTO ArrayTbl2 VALUES('B', 4, NULL);INSERT INTO ArrayTbl2 VALUES('B', 5, NULL);INSERT INTO ArrayTbl2 VALUES('B', 6, NULL);INSERT INTO ArrayTbl2 VALUES('B', 7, NULL);INSERT INTO ArrayTbl2 VALUES('B', 8, NULL);INSERT INTO ArrayTbl2 VALUES('B', 9, NULL);INSERT INTO ArrayTbl2 VALUES('B',10, NULL);INSERT INTO ArrayTbl2 VALUES('C', 1, 1);INSERT INTO ArrayTbl2 VALUES('C', 2, 1);INSERT INTO ArrayTbl2 VALUES('C', 3, 1);INSERT INTO ArrayTbl2 VALUES('C', 4, 1);INSERT INTO ArrayTbl2 VALUES('C', 5, 1);INSERT INTO ArrayTbl2 VALUES('C', 6, 1);INSERT INTO ArrayTbl2 VALUES('C', 7, 1);INSERT INTO ArrayTbl2 VALUES('C', 8, 1);INSERT INTO ArrayTbl2 VALUES('C', 9, 1);INSERT INTO ArrayTbl2 VALUES('C',10, 1);/* 正确解法 */SELECT DISTINCT keyFROM ArrayTbl2 A1WHERE NOT EXISTS(SELECT *FROM ArrayTbl2 A2WHERE A1.key = A2.keyAND (A2.val <> 1 OR A2.val IS NULL));/* 其他解法1：使⽤ALL谓词 */SELECT DISTINCT keyFROM ArrayTbl2 A1WHERE 1 = ALL(SELECT valFROM ArrayTbl2 A2WHERE A1.key = A2.key);/* 其他解法2：使⽤HAVING⼦句 */SELECT keyFROM ArrayTbl2GROUP BY keyHAVING SUM(CASE WHEN val = 1 THEN 1 ELSE 0 END) = 10;/* 其他解法3：在HAVING⼦句中使⽤极值函数 */SELECT keyFROM ArrayTbl2GROUP BY keyHAVING MAX(val) = 1AND MIN(val) = 1;/* 练习题1-8-2：使⽤ALL谓词进⾏全称量化查找已经完成到⼯程1的项⽬：使⽤ALL谓词解答 */SELECT *FROM Projects P1WHERE '○' = ALL(SELECT CASE WHEN step_nbr <= 1 AND status = '完成' THEN '○'WHEN step_nbr > 1 AND status = '等待' THEN '○'ELSE '×' ENDFROM Projects P2WHERE P1.project_id = P2. project_id);/* 练习题1-8-3：求（1-100）中的质数 */SELECT num AS primeFROM Numbers DividendWHERE num > 1AND NOT EXISTS(SELECT *FROM Numbers DivisorWHERE Divisor.num <= Dividend.num / 2 /* 除了⾃⾝之外的约数必定⼩于等于⾃⾝值的⼀半 */ AND Divisor.num <> 1 /* 约数中不包含1 */AND MOD(Dividend.num, Divisor.num) = 0) /*“除不尽”的否定条件是“除尽” */ORDER BY prime;Processing math: 0%。
sql中exists,notexists的用法
sql中exists,notexists的⽤法exists : 强调的是是否返回结果集，不要求知道返回什么, ⽐如：select name from student where sex = 'm' and mark exists(select 1 from grade where ...) ,只要exists引导的⼦句有结果集返回，那么exists这个条件就算成⽴了,⼤家注意返回的字段始终为1，如果改成“select 2 from grade where ...”，那么返回的字段就是2，这个数字没有意义。
所以exists⼦句不在乎返回什么，⽽是在乎是不是有结果集返回。
⽽ exists 与 in 最⼤的区别在于 in引导的⼦句只能返回⼀个字段，⽐如：select name from student where sex = 'm' and mark in (select 1,2,3 from grade where ...)，in⼦句返回了三个字段，这是不正确的，exists⼦句是允许的，但in只允许有⼀个字段返回，在1，2，3中随便去了两个字段即可。
⽽not exists 和not in 分别是exists 和 in 的对⽴⾯。
exists （sql 返回结果集为真） not exists (sql 不返回结果集为真）下⾯详细描述not exists的过程：如下：表AID NAME 1 A12 A23 A3表BID AID NAME1 1 B12 2 B2 3 2 B3表A和表B是１对多的关系 A.ID => B.AIDSELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHEREA.ID=B.AID)执⾏结果为1 A12 A2原因可以按照如下分析SELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHERE B.AID=１)--->SELECT * FROM B WHERE B.AID=１有值返回真所以有数据SELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHERE B.AID=2)--->SELECT * FROM B WHERE B.AID=２有值返回真所以有数据SELECT ID,NAME FROM A WHERE EXISTS (SELECT * FROM B WHERE B.AID=3)--->SELECT * FROM B WHERE B.AID=３⽆值返回真所以没有数据NOT EXISTS 就是反过来SELECT ID,NAME FROM A WHERE NOT EXIST (SELECT * FROM B WHERE A.ID=B.AID)执⾏结果为3A3===========================================================================EXISTS = IN,意思相同不过语法上有点点区别，好像使⽤IN效率要差点，应该是不会执⾏索引的原因SELECTID,NAME FROM A WHERE ID IN (SELECT AID FROM B)NOT EXISTS = NOT IN ,意思相同不过语法上有点点区别SELECT ID,NAME FROM A WHERE ID NOT IN (SELECT AID FROM B)有时候我们会遇到要选出某⼀列不重复,某⼀列作为选择条件,其他列正常输出的情况.如下⾯的表table:Id Name Class Count Date1 苹果⽔果 10 2011-7-11 桔⼦⽔果 20 2011-7-21 ⾹蕉⽔果 15 2011-7-32 ⽩菜蔬菜 12 2011-7-12 青菜蔬菜 19 2011-7-2如果想要得到下⾯的结果:(Id唯⼀,Date选最近的⼀次)1 ⾹蕉⽔果 15 2011-7-32 青菜蔬菜 19 2011-7-2正确的SQL语句是:SELECT Id, Name, Class, Count, DateFROM table tWHERE (NOT EXISTS(SELECT Id, Name, Class, Count, Date FROM tableWHERE Id = t.Id AND Date > t.Date))如果⽤distinct,得不到这个结果, 因为distinct是作⽤与所有列的SELECT DISTINCT Id, Name, Class, Count, Date FROM table结果是表table的所有不同列都显⽰出来,如下所⽰:1 苹果⽔果 10 2011-7-11 桔⼦⽔果 20 2011-7-21 ⾹蕉⽔果 15 2011-7-32 ⽩菜蔬菜 12 2011-7-12 青菜蔬菜 19 2011-7-2如果⽤Group by也得不到需要的结果,因为Group by 要和聚合函数共同使⽤,所以对于Name,Class和Count列要么使⽤Group by,要么使⽤聚合函数. 如果写成SELECT Id, Name, Class, Count, MAX(Date)FROM tableGROUP BY Id, Name, Class, Count得到的结果是1 苹果⽔果 10 2011-7-11 桔⼦⽔果 20 2011-7-21 ⾹蕉⽔果 15 2011-7-32 ⽩菜蔬菜 12 2011-7-12 青菜蔬菜 19 2011-7-2如果写成SELECT Id, MAX(Name), MAX(Class), MAX(Count), MAX(Date)FROM tableGROUP BY Id得到的结果是:1 ⾹蕉⽔果 20 2011-7-32 青菜蔬菜 19 2011-7-2如果⽤in有时候也得不到结果,（有的时候可以得到，如果Date都不相同（没有重复数据），或者是下⾯得到的Max（Date）只有⼀个值）SELECT DISTINCT Id, Name, Class, Count, Date FROM tableWHERE (Date IN(SELECT MAX(Date)FROM tableGROUP BY Id))得到的结果是：（因为MAX(Date)有两个值2011-7-2，2011-7-3）1 桔⼦⽔果 20 2011-7-21 ⾹蕉⽔果 15 2011-7-32 青菜蔬菜 19 2011-7-2注意in只允许有⼀个字段返回有⼀种⽅法可以实现：SELECT Id, Name, Class, COUNT, DateFROM table1 tWHERE (Date = (SELECT MAX(Date) FROM table1 WHERE Id = t .Id))⽐如在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 指定⼀个⼦查询，检测⾏的存在。
sql 中exists用法
sql 中exists用法SQL中exists用法在SQL中，exists是一个非常有用的关键字，用于检查一个子查询是否至少返回一行结果。
exists通常与主查询的where子句一起使用，以确定特定条件是否成立。
exists的语法如下：```SELECT column1, column2, ...FROM table1WHERE EXISTS (subquery);```在子查询中，我们可以根据需求使用各种条件和语句。
exists语句将返回true或false，取决于子查询是否返回任何行。
exists语句非常适合以下场景：1. 存在性检查：用于检查特定条件下是否存在符合要求的数据行。
例如，我们需要查询存在未支付订单的客户。
```SELECT customer_nameFROM customersWHERE EXISTS (SELECT * FROM orders WHEREcustomers.customer_id = orders.customer_id AND orders.status = 'unpaid');```在这个例子中，子查询用于检查是否存在未支付的订单。
如果存在任何未支付的订单，exists将返回true，并包含具有未支付订单的客户的名称。
2. 子查询过滤：可以使用exists关键字作为过滤条件来限制主查询返回的结果集。
例如，我们需要查询所有至少拥有一辆汽车的客户。
```SELECT customer_id, customer_nameFROM customersWHERE EXISTS (SELECT * FROM cars WHEREcustomers.customer_id = cars.customer_id);```在这个例子中，子查询用于过滤掉没有拥有任何汽车的客户。
只有存在相关汽车的客户才会被包含在结果集中。
3. 避免重复行：在某些情况下，我们可能需要避免返回重复的数据行。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
exists是用来判断是否存在的，当exists(查 是用来判断是否存在的， 是用来判断是否存在的 查 中的查询存在结果时则返回真， 询)中的查询存在结果时则返回真，否则返 中的查询存在结果时则返回真 回假。 回假。not exists则相反 则相反 它所在的查询属于相关子查询， 它所在的查询属于相关子查询，即子查询的 查询条件依赖于外层父查询的某个属性值， 查询条件依赖于外层父查询的某个属性值， 处理过程一般为： 处理过程一般为：
8
思路一（ ） 思路一（in）
select Sname from student where Sno IN (select Sno from SC group by Sno //根据 根据Sno分组，统计每个 分组， 根据 分组 //学生选修了几门课程。如果等于 学生选修了几门课程。 学生选修了几门课程 如果等于course的 的 //总数，就是我们要找的 总数， 总数 就是我们要找的Sno having count(*) = (select count(*) from course ) ) //统计 统计course中共有几门课程 统计 中共有几门课程
6
1、查询选修了全部课程的学生姓名 、
7
思路一（ ） 思路一（in）
首先学生的选课信息存在于SC表中， 首先学生的选课信息存在于 表中， 要想 表中 知道某个学生是否选修了全部课程， 知道某个学生是否选修了全部课程，至少我 们需要知道一共有几门课程。 们需要知道一共有几门课程。 其次，学生选修了与否，我们又要扫描SC 其次，学生选修了与否，我们又要扫描 全表， 全表，统计出选修了所有课程的学生号 最后在STUDENT表中根据学生号打出姓名 最后在 表中根据学路二（EXISTS） ）
select Sname from student where NOT exists // (select * from course where NOT exists //不存在的提 不存在的提 //交给 交给course 交给 (select * from SC where Sno = student.sno and cno = o) // 代//入 入 两个未知变量 )
16
取外层查询的第一个元组， 取外层查询的第一个元组，根据它与内层查询 相关的属性值处理内层查询， 相关的属性值处理内层查询，若where子句返回 子句返回 true，则将此元组放入结果表，然后取下一个元 ，则将此元组放入结果表， 组，重复这个过程直到全部检查完为止
2
做为where 条件时，是先对 条件时， 即：exists做为 做为 where 前的主查询进行查询，然后用主查询 前的主查询进行查询， 的结果一个一个的代入exists的子查询进行 的结果一个一个的代入 的子查询进行 判断， 判断，如果为真则输出当前这一条主查询的 结果， 结果，否则不输出
10
select Cname from course where not exists//找不到的组合，提交 找不到的组合， 找不到的组合 提交course (select * from SC where o = cno and sno = ''00002'') //在SC中匹配 在 中匹配
4
for(int i =0; i<EOFout;i++) { for (int j = 0 ; j<EOFin;j++) }
5
使用EXISTS，首先检查主查询，然后运行 ，首先检查主查询， 使用 子查询直到它找到第一个匹配项， 子查询直到它找到第一个匹配项，这就节省 了时间。 了时间。 而执行IN子查询时 首先执行子查询， 子查询时， 而执行 子查询时，首先执行子查询，并将 获得的结果列表存放在一个加了索引的临时 表中。在执行子查询之前， 表中。在执行子查询之前，系统先将主查询 挂起，待子查询执行完毕， 挂起，待子查询执行完毕，存放在临时表中 以后再执行主查询。 以后再执行主查询。 因此，使用EXISTS比使用 通常查询速度 比使用IN通常查询速度 因此，使用 比使用 快。
13
回头看，就是我们第一个引出的题目 回头看，就是我们第一个引出的题目:
选修了全部课程的学生姓名
“选了全部课程的学生” 变成“找这样的 选了全部课程的学生” 变成“ 不存在一门课他没选的， 学生 ：不存在一门课他没选的，也就是没 有课程他没有选 举一反三,请写出 举一反三 请写出
被全部学生都选的课程 被全部学生都不选的课程
11
思路二（ 思路二（EXISTS） ）
换个题目： 换个题目： 查找没有 没有选修科目的学生姓名 思路： 科目未知， 思路：学号未知 ， 科目未知，说明有两个未知变 应该有两个EXISTS。 量。应该有两个 。 可以扫描student 和 course共有 s * c 中组合， 中组合， 可以扫描 共有 将这些组合与SC的每一项进行匹配 注意s*c组合 的每一项进行匹配， 将这些组合与 的每一项进行匹配，注意 组合 已经包含所有可能。 已经包含所有可能。如果全部找到 ，就说明已经 选修了全部课程。 选修了全部课程。找不到就说明有课程没选修 。 再将没选修的的提交给上一exists 循环 。若上一 再将没选修的的提交给上一 exists 不存在的再提交给外循环。 不存在的再提交给外循环。
9
思路二（ 思路二（EXISTS） ）
引入： 引入：将题目换为 查找学号为 00003 没有 选修的科目 思路： 思路：
将已知学号00003代入 代入 将已知学号 把每一个科目代入（循环） 把每一个科目代入（循环） 将上述两个条件组合，一一与SC表中的学号 表中的学号（ 将上述两个条件组合，一一与 表中的学号（ 00003 ）和科目进行比对，找不到匹配的就是 和科目进行比对， 00003 没有选修的科目
3
建立程序循环的概念， 建立程序循环的概念，这是一个动态的查询 过程。 过程。如 FOR循环 。 循环 流程为首先取出外层中的第一个元组， 流程为首先取出外层中的第一个元组， 再 执行内层查询，将外层表的第一元组代入， 执行内层查询，将外层表的第一元组代入， 若内层查询为真，即有结果时， 若内层查询为真，即有结果时，返回外层表 接着取出第二元组， 中的第一元 组，接着取出第二元组，执行 相同的算法。 相同的算法。一直到扫描完外层整表 。
14
2、 查询至少选修了学生 、 查询至少选修了学生00002选修的全部课 选修的全部课 程的学生号码 它表示的语义为：不存在这样的课程 ， 它表示的语义为：不存在这样的课程y，学 选了， 生95002选了，而学生 没有选 选了 而学生x没有选
15
select distinct sno from sc scx where not exists( select * from sc scy where sno='95002' and not exist( select * from sc scz where scz.sno = scx.sno and o=o))