SQL select 语法-数据库专栏,SQL Server-数据库其他-idc中文资讯站-客观公证的IDC产业权威媒体,关注域名、虚拟主机、服务器、网络、开源技术资讯，整合运营商资源，客观评价各地机房带宽线路质量、IDC企业名录等信息

SQL select 语法-数据库专栏,SQL Server

来源：作者：发布时间:2007-12-25 13:39:02

sql 里面最常用的命令是 select 语句，用于检索数据。语法是：

select [ all | distinct [ on ( expression [, ...] ) ] ] * | expression [ as output_name ] [, ...] [ into [ temporary | temp ] [ table ] new_table ] [ from from_item [, ...] ] [ where condition ] [ group by expression [, ...] ] [ having condition [, ...] ] [ { union | intersect | except [ all ] } select ] [ order by expression [ asc | desc | using operator ] [, ...] ] [ for update [ of class_name [, ...] ] ] [ limit { count | all } [ { offset | , } start ]]

现在我们将通过不同的例子演示 select 语句复杂的语法。用于这些例子的表在供给商和部件数据库里定义。
1.4.1.1. 简单的 select
这里是一些使用 select 语句的简单例子：

example 1-4. 带有条件的简单查询

要从表 part 里面把字段 price 大于 10 的任何记录找出来，我们写出下面查询：

select * from part where price > 10;
然后得到表：
pno | pname | price-----+---------+-------- 3 | bolt | 15 4 | cam | 25

在 select语句里使用 "*" 将检索出表中的任何属性。假如我们只希望从表 part 中检索出属性 pname 和 price，我们使用下面的语句：

select pname, price from part where price > 10;
这回我们的结果是：
pname | price --------+-------- bolt | 15 cam | 25
请注意 sql 的 select 语句对应关系演算里面的 "projection" （映射），而不是 "selection"（选择）（参阅关系演算获取周详信息）。

where 子句里的条件也能够用关键字 or，and，和 not 逻辑地连接起来：

select pname, price from part where pname = bolt and (price = 0 or price <= 15);
这样将生成下面的结果：
pname | price--------+-------- bolt | 15

目标列表和 where 子句里能够使用算术操作。例如，假如我们想知道假如我们买两个部件的话要多少钱，我们能够用下面的查询：

select pname, price * 2 as double from part where price * 2 < 50;
这样我们得到：
pname | double--------+--------- screw | 20 nut | 16 bolt | 30
请注意在关键字 as 后面的 double 是第二个列的新名字。这个技巧能够用于目标列表里的每个元素，给他们赋予一个在结果列中显示的新的标题。这个新的标题通常称为别名。这个别名不能在该查询的其他地方使用。

1.4.1.2. joins（连接）
下面的例子显示了 sql 里是怎样实现连接的。

要在一起的属性上连接三个表 supplier，part 和 sells，我们通常使用下面的语句：

select s.sname, p.pname from supplier s, part p, sells se where s.sno = se.sno and p.pno = se.pno;
而我们得到的结果是：
sname | pname-------+------- smith | screw smith | nut jones | cam adams | screw adams | bolt blake | nut blake | bolt blake | cam

在 from 子句里，我们为每个关系使用了一个别名，因为在这些关系间有着公共的命名属性（sno 和 pno）。现在我们能够区分不同表的公共命名属性，只需要简单的用每个关系的别名加上个点做前缀就行了。联合是用和一个内部联接里显示的同样的方法计算的。首先算出笛卡儿积 supplier × part × sells 。然后选出那些满足 where 子句里给出的条件的记录（也就是说，公共命名属性的值必须相等）。最后我们映射出除 s.sname 和 p.pname 外的任何属性。

另外一个进行连接的方法是使用下面这样的 sql join 语法：

select sname, pname from supplier join sells using (sno) join part using (pno);
giving again:
sname | pname-------+------- smith | screw adams | screw smith | nut blake | nut adams | bolt blake | bolt jones | cam blake | cam(8 rows)

一个用 join 语法创建的连接表，是个出现在 from 子句里的，在任何 where，group by 或 having 子句之前的表引用列表项．其他表引用，包括表名字或其他 join 子句，假如用逗号分隔的话，能够包含在 from 子句里．连接生成的表逻辑上和任何其他在 from 子句里列出的表都相同．

sql join 有两种主要类型，cross join (无条件连接) 和条件连接．条件连接还能够根据声明的连接条件(on，using，或 natural)和他应用的方式(inner 或 outer 连接)进一步细分．

连接类型
cross join
{ t1 } cross join { t2 }

一个交叉连接（cross join）接收两个分别有 n 行和 m 行的表 t1 和 t2，然后返回一个包含交叉乘积 nxm 条记录的连接表．对于 t1 的每行 r1，t2 的每行 r2 都和 r1 连接生成连接的表行 jr，jr 包含任何 r1 和 r2 的字段． cross join 实际上就是个 inner join on true．
条件 join
{ t1 } [ natural ] [ inner | { left | right | full } [ outer ] ] join { t2 } { on search condition | using ( join column list ) }

一个条件 join 必须通过提供一个(并且只能有一个) natural，on，或 using 这样的关键字来声明他的连接条件． on 子句接受一个 search condition，他和一个 where 子句相同．using 子句接受一个用逗号分隔的字段名列表，连接表中必须都有这些字段，并且用那些字段连接这些表，生成的连接表包含每个共有字段和两个表的任何其他字段． natural 是 using 子句的缩写，他列出两个表中任何公共的字段名字．使用 using 和 natural 的副作用是每个连接的字段都只有一份拷贝出现在结果表中 (和前面定义的关系演算的 join 相比较)．

[ inner ] join

对于 t1 的每行 r1，连接成的表在 t2 里都有一行满足和 r1 一起的连接条件．

对于任何 join 而言，inner 和 outer 都是可选的．inner 是缺省． left，right，和 full 只用于 outer join．

left [ outer ] join

首先，执行一次 inner join．然后，假如 t1 里有一行对任何 t2 的行都不满足连接条件，那么返回一个连接行，该行的 t2 的字段为 null．

小技巧: 连接成的表无条件地包含 t1 里的任何行．

right [ outer ] join

首先，执行一次 inner join．然后，假如 t2 里有一行对任何 t1 的行都不满足连接条件，那么返回一个连接行，该行的 t1 的字段为 null．

小技巧: 连接成的表无条件地包含 t2 里的任何行．

full [ outer ] join

首先，执行一次 inner join．然后，假如 t1 里有一行对任何 t2 的行都不满足连接条件，那么返回一个连接行，该行的 t1 的字段为 null．同样，假如 t2 里有一行对任何 t1 的行都不满足连接条件，那么返回一个连接行，该行的 t2 的字段为 null．

小技巧: 连接成的表无条件地拥有来自 t1 的每一行和来自 t2 的每一行．

任何类型的 join 都能够链接在一起或嵌套在一起，这时 t1 和 t2 都能够是连接生成的表．我们能够使用圆括弧控制 join 的顺序，假如我们不主动控制，那么连接顺序是从左到右．
1.4.1.3. 聚集操作符
sql 提供以一些聚集操作符（如， avg，count，sum，min，max），这些聚集操作符以一个表达式为参数。只要是满足 where 子句的行，就会计算这个表达式，然后聚集操作符对这个输入数值的集合进行计算．通常，一个聚集对整个 select 语句计算的结果是生成一个结果．但假如在一个查询里面声明了分组，那么数据库将对每个组进行一次单独的计算，并且聚集结果是按照各个组出现的(见下节)．

example 1-5. 聚集

果我们想知道表 part 里面任何部件的平均价格，我们能够使用下面查询：

select avg(price) as avg_price from part;

结果是：

avg_price----------- 14.5

假如我们想知道在表 part 里面存储了多少部件，我们能够使用语句：

select count(pno) from part;
得到：
count------- 4

1.4.1.4. 分组聚集
sql 允许我们把一个表里面的记录分成组。然后上面描述的聚集操作符能够应用于这些组上（也就是说，聚集操作符的值不再是对任何声明的列的值进行操作，而是对一个组的任何值进行操作。这样聚集函数是为每个组单独地进行计算的。）

对记录的分组是通过关键字 group by 实现的，group by 后面跟着一个定义组的构成的属性列表。假如我们使用语句 group by a1, ⃛, ak 我们就把关系分成了组，这样当且仅当两条记录在任何属性 a1, ⃛, ak 上达成一致，他们才是同一组的。

example 1-6. 聚集

假如我们想知道每个供给商销售多少个部件，我们能够这样写查询：

select s.sno, s.sname, count(se.pno) from supplier s, sells se where s.sno = se.sno group by s.sno, s.sname;
得到：
sno | sname | count-----+-------+------- 1 | smith | 2 2 | jones | 1 3 | adams | 2 4 | blake | 3

然后我们看一看发生了什么事情。首先生成表 supplier 和 sells 的连接：

s.sno | s.sname | se.pno-------+---------+-------- 1 | smith | 1 1 | smith | 2 2 | jones | 4 3 | adams | 1 3 | adams | 3 4 | blake | 2 4 | blake | 3 4 | blake | 4

然后我们把那些属性 s.sno 和 s.sname 相同的记录放在组中：

s.sno | s.sname | se.pno-------+---------+-------- 1 | smith | 1 | 2-------------------------- 2 | jones | 4-------------------------- 3 | adams | 1 | 3-------------------------- 4 | blake | 2 | 3 | 4

在我们的例子里，我们有四个组并且现在我们能够对每个组应用聚集操作符 count，生成上面给出的查询的最终结果。

请注意假如要让一个使用 group by 和聚集操作符的查询的结果有意义，那么用于分组的属性也必须出现在目标列表中。任何没有在 group by 子句里面出现的属性都只能通过使用聚集函数来选择。否则就不会有唯一的数值和其他字段关联．

还要注意的是在聚集上聚集是没有意义的，比如，avg(max(sno))，因为 select 只做一个回合的分组和聚集．您能够获得这样的结果，方法是使用临时表或在 from 子句中使用一个子 select 做第一个层次的聚集．
1.4.1.5. having
having 子句运做起来很象 where 子句，只用于对那些满足 having 子句里面给出的条件的组进行计算。其实，where 在分组和聚集之前过滤掉我们无需的输入行，而 having 在 group 之后那些无需的组．因此，where 无法使用一个聚集函数的结果．而另一方面，我们也没有理由写一个不涉及聚集函数的 having．假如您的条件不包含聚集，那么您也能够把他写在 where 里面，这样就能够避免对那些您准备抛弃的行进行的聚集运算．

example 1-7. having

假如我们想知道那些销售超过一个部件的供给商，使用下面查询：

select s.sno, s.sname, count(se.pno) from supplier s, sells se where s.sno = se.sno group by s.sno, s.sname having count(se.pno) > 1;
and get:
sno | sname | count-----+-------+------- 1 | smith | 2 3 | adams | 2 4 | blake | 3

1.4.1.6. 子查询
在 where 和 having 子句里，允许在任何要产生数值的地方使用子查询（子选择）。这种情况下，该值必须首先来自对子查询的计算。子查询的使用扩展了 sql 的表达能力。

example 1-8. 子查询

假如我们想知道任何比名为 screw 的部件贵的部件，我们能够用下面的查询：

select * from part where price > (select price from part where pname=screw);

结果是：

pno | pname | price-----+---------+-------- 3 | bolt | 15 4 | cam | 25

当我们检查上面的查询时会发现出现了两次 select 关键字。第一个在查询的开头 - 我们将称之为外层 select - 而另一个在 where 子句里面，成为一个嵌入的查询 - 我们将称之为内层 select。对外层 select 的每条记录都必须先计算内层 select。在完成任何计算之后，我们得知名为 screw 部件的记录的价格，然后我们就能够检查那些价格更贵的记录了。 (实际上，在本例中，内层查询只需要执行一次，因为他不依赖于外层查询高等状态．)

假如我们想知道那些不销售任何部件的供给商（比如说，我们想把这些供给商从数据库中删除），我们用：

select * from supplier s where not exists (select * from sells se where se.sno = s.sno);

在我们的例子里，结果列将是空的，因为每个供给商至少销售一个部件。请注意我们在 where 子句的内层 select 里使用了来自外层 select 的 s.sno。正如前面所说的，子查询为每个外层查询计算一次，也就是说， s.sno 的值总是从外层 select 的实际记录中取得的。

1.4.1.7. 在 from 里面的子查询
一种有些特别的子查询的用法是把他们放在 from 子句里．这个特性很有用，因为这样的子查询能够输出多列和多行，而在表达式里使用的子查询必须生成一个结果． from 里的子查询还能够让我们获得多于一个回合的分组/聚集特性，而无需求助于临时表．

example 1-9. from 里面的子查询

假如我们想知道在任何我们的供给商中的最高平均部件价格的那家，我们不能用 max(avg(price))，但我们能够这么写：

select max(subtable.avgprice) from (select avg(p.price) as avgprice from supplier s, part p, sells se where s.sno = se.sno and p.pno = se.pno group by s.sno) subtable;
这个子查询为每个供给商返回一行（因为他的 group by）然后我们在外层查询对任何行进行聚集．

1.4.1.8. union, intersect, except（联合，相交，相异）
这些操作符分别计算两个子查询产生的元组的联合，相交和集合理论里的相异。

example 1-10. union, intersect, except

下面的例子是 union 的例子：

select s.sno, s.sname, s.city from supplier s where s.sname = jonesunion select s.sno, s.sname, s.city from supplier s where s.sname = adams;
产生结果：
sno | sname | city-----+-------+-------- 2 | jones | paris 3 | adams | vienna

下面是相交（ intersect）的例子：

select s.sno, s.sname, s.city from supplier s where s.sno > 1intersect select s.sno, s.sname, s.city from supplier s where s.sno < 3;
产生结果：
sno | sname | city-----+-------+-------- 2 | jones | paris
两个查询都会返回的元组是那条 sno=2 的

最后是个 except 的例子：

select s.sno, s.sname, s.city from supplier s where s.sno > 1except select s.sno, s.sname, s.city from supplier s where s.sno > 3;
结果是：
sno | sname | city-----+-------+-------- 2 | jones | paris 3 | adams | vienna

喜欢本文，那就收藏到：