转:http://hi.baidu.com/delphi_relive/blog/item/d7c0034a49c4932208f7ef21.html

in 和 exists也是很好区别的.

in 是一个集合运算符.

a in {a,c,d,s,d....}

这个运算中,前面是一个元素,后面是一个集合,集合中的元素类型是和前面的元素一样的.

而exists是一个存在判断,如果后面的查询中有结果,则exists为真,否则为假.

in

运算用在语句中,它后面带的select 一定是选一个字段,而不是select *.

比如说你要判断某班是否存在一个名为"小明"的学生,你可以用in 运算:

"小明" in (select sname from student)

这样(select sname from student)

返回的是一个全班姓名的集合,in用于判断"小明"是否为此集合中的一个数据;

同时,你也可以用exists语句:

exists (select * from student where

sname="小明")

这两个涵数是差不多的, 但是由于优化方案的不同, 通常NOT EXISTS要比NOT IN 要快, 因为NOT EXISTS可以使用结合算法而NOT

IN　就不行了，而EXISTS则不如IN快, 因为这时候IN可能更多的使用结合算法.

select * from 表A where exists(select * from 表B

where 表B.id=表A.id)

这句相当于

select * from 表A where id in (select id from

表B)

对于表A的每一条数据,都执行select * from 表B where

表B.id=表A.id的存在性判断,如果表B中存在表A当前行相同的id,则exists为真,该行显示,否则不显示

exits适合内小外大的查询，in适合内大外小的查询

IN

确定给定的值是否与子查询或列表中的值相匹配。

EXISTS

指定一个子查询，检测行的存在。

比较使用 EXISTS 和 IN 的查询

这个例子比较了两个语义类似的查询。第一个查询使用 EXISTS 而第二个查询使用

IN。注意两个查询返回相同的信息。

USE pubs

GO

SELECT DISTINCT pub_name

FROM publishers

WHERE EXISTS

(SELECT *

FROM titles

WHERE pub_id = publishers.pub_id

AND type = 'business')

GO

-- Or, using the IN clause:

USE pubs

GO

SELECT distinct pub_name

FROM publishers

WHERE pub_id IN

(SELECT pub_id

FROM titles

WHERE type = 'business')

GO

下面是任一查询的结果集：

pub_name

----------------------------------------

Algodata Infosystems

New Moon Books

(2 row(s) affected)

exits 相当于存在量词：表示集合存在,也就是 集合不为空只作用一个集合.例如 exist P 表示P不空时为真; not

exist P表示p为空时 为真 in表示一个标量和一元关系的关系。例如：s in P表示当s与P中的某个值相等时 为真; s not

in P 表示s与P中的每一个值都不相等时 为真

二 、连接查询

SELECT

Persons.LastName, Persons.FirstName, Orders.OrderNoFROM Persons

INNER JOIN

Orders ON Persons.Id_P =

Orders.Id_P ORDER BY Persons.LastName

不同的 SQL

JOIN 返回的结果集不一样

除了我们在上面的例子中使用的 INNER

JOIN(内连接)，我们还可以使用其他几种连接。

下面列出了您可以使用的 JOIN 类型，以及它们之间的差异。

JOIN: 如果表中有至少一个匹配，则返回行

LEFT JOIN: 即使右表中没有匹配，也从左表返回所有的行

RIGHT JOIN: 即使左表中没有匹配，也从右表返回所有的行

FULL JOIN: 只要其中一个表中存在匹配，就返回行

注释：INNER JOIN 与 JOIN 是相同的。

简而言之 ，就是你希望看到的结果集是怎样的，如两个表 person 和

order 连接 ：

如果你只想看到person 中 和order 有联系的记录 即 满足 order.id_p =

person.id的记录其他不匹配的全不显示 就用 inner join

left join 就是在返回inner join 的结果集的基础上返回左表 person 表中

其余的记录(这些显示的记录行所有与order表相关的栏为空，因为它们不满足匹配关系)

同理 ，right

join 和 full

join

3)嵌套子查询

select t.deptno,count(*) from emp t,(select avg(e.sal) avgsal from emp e) a

where t.sal>a.avgsal

group by t.deptno

where 运算符 (=，,>=,<=,<>) where 运算符 (in,not

in,exists,not exists, all,any)

相关子查询是指引用了父查询中某些表或某些列的子查询(但父查询不能引用子查询中的表或列)父查询可以是select,update,delete

子句。

4)sql 中的聚合

函数的嵌套 使用

聚集函数

和大多数其它关系数据库产品一样，PostgreSQL

支持聚集函数。一个聚集函数从多个输入行中计算出一个结果。比如，我们有在一个行集合上计算 count(数目), sum(总和),

avg(均值), max(最大值), min(最小值)的函数。

比如，我们可以用下面的语句找出所有低温中的最高温度：

SELECT max(temp_lo) FROM weather; max

-----

46

(1 row)如果我们想知道该读数发生在哪个城市，可能会用：

SELECT city FROM weather WHERE temp_lo =

max(temp_lo); -- 错！不过这个方法不能运转，因为聚集函数 max 不能用于 WHERE 子句中。存在这个限制是因为 WHERE

子句决定哪些行可以进入聚集阶段；因此它必需在聚集函数之前计算。不过，我们可以用其它方法实现这个目的；这里我们使用子查询：

SELECT city FROM weather

WHERE

temp_lo = (SELECT max(temp_lo) FROM

weather); city

---------------

San Francisco

(1 row)这样做是可以的，因为子查询是一次独立的计算，它独立于外层查询计算自己的聚集。

聚集同样也常用于 GROUP BY 子句。比如，我们可以获取每个城市低温的最高值：

SELECT city, max(temp_lo)

FROM

weather

GROUP BY

city; city | max

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

Hayward | 37

San Francisco | 46

(2 rows)这样每个城市一个输出。每个聚集结果都是在匹配该城市的行上面计算的。我们可以用 HAVING 过滤这些分组：group by 可以没有 having 过滤 having必须跟在group by的后面 SELECT city, max(temp_lo)

FROM

weather

GROUP BY

city

HAVING

max(temp_lo) < 40; city | max

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

Hayward | 37

(1 row)这样就只给出那些 temp_lo 值曾经有低于 40

度的城市。最后，如果我们只关心那些名字以"S"开头的城市，我们可以用：

SELECT city, max(temp_lo)

FROM

weather

WHERE city

LIKE 'S%'

GROUP BY

city

HAVING

max(temp_lo) < 40;语句中的 LIKE 执行模式匹配，在节9.7里有解释。

理解聚集和 SQL 的 WHERE 和 HAVING 子句之间的关系非常重要。WHERE 和 HAVING 的基本区别如下：WHERE

在分组和聚集计算之前选取输入行(它控制哪些行进入聚集计算)，而 HAVING 在分组和聚集之后选取输出行。因此，WHERE

子句不能包含聚集函数；因为试图用聚集函数判断那些行将要输入给聚集运算是没有意义的。相反，HAVING

子句总是包含聚集函数。当然，你可以写不使用聚集的 HAVING 子句，但这样做没什么好处，因为同样的条件可以更有效地用于 WHERE

阶段。

在前面的例子里，我们可以在 WHERE 里应用城市名称限制，因为它不需要聚集。这样比在 HAVING

里增加限制更加高效，因为我们避免了为那些未通过 WHERE 检查的行进行分组和聚集计算。