7.2. ����ʽ

����ʽ����һ���� �ñ���ʽ����һ��FROM�Ӿ䣬���Ӿ���Ը�����Ҫѡ��WHERE��GROUP BY�� ��HAVING �Ӿ䡣�󲿷ֵı���ʽֻ��ָ������ϵ�һ����һ����ν�Ļ������������ǿ����ø����ӵı���ʽ�Ը��ַ����޸Ļ���ϻ�����

����ʽ���WHERE��GROUP BY���� HAVING �Ӿ�����һϵ�ж�Դ�� FROM �Ӿ�ı��ת��������������Щת���������һ��������ṩ���ݸ�ѡ���б�����ѯ����е������С�

7.2.1. FROM �Ӿ�

FROM �Ӿ� ��һ���ö��ŷָ��ı������б��е�һ��������������������һ����

FROM table_reference [, table_reference [, ...]]

�����ÿ�����һ�������֣�������ģʽ���Σ�������һ�����ɵı� �����Ӳ�ѯ��һ�������ӣ�������Щ�����ĸ�����ϡ������FROM�Ӿ����г��˶���һ���� ��ô���DZ� cross join �������ģ��γ�һ���������ñ���Խ��� WHERE��GROUP BY �� HAVING �Ӿ��ת������������������б���ʽ�Ľ����

���һ����������һ���򵥵ı����ֲ������DZ�̳м����еij����� ��ô�ñ���а����������ĺ���ӱ���У��������ڸñ�����ǰ���ONLY�ؼ��֡� �����Ļ���������þ�ֻ���ɳ������������е��� — �κ����ӱ���׷�ӵ��ж��ᱻ���ԡ�

7.2.1.1. ���ӱ�

һ�����ӱ��Ǹ����ض����������͵Ĺ����������������ʵ������ɱ��������ı� ����֧�������ӣ������Ӻͽ����������͡�

��������

��������
T1 CROSS JOIN T2

��ÿ���� T1 �� T2 �����е���ϣ� ���ɵı���������һ�У����������� T1 ������ֶκ���������� T2 ������ֶΡ� �������ֱ��� N �� M �У����ӳɵı��� N * M �С�

FROM T1 CROSS JOIN T2 ��Ч�� FROM T1, T2�� ������Ч�� FROM T1 INNER JOIN T2 ON TRUE�������ģ���

��������(join)
T1 { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2 ON boolean_expression
T1 { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2 USING ( join column list )
T1 NATURAL { [INNER] | { LEFT | RIGHT | FULL } [OUTER] } JOIN T2

INNER �� OUTER ���������ӣ�join�� ���Ͷ��ǿ�ѡ�ġ� INNER ��ȱʡ��LEFT��RIGHT���� FULL ���������ӡ�

����������ON��USING�Ӿ��������� �����ùؼ���NATURAL���������������������ж���������Դ���е���Щ����"ƥ��"�ģ���Щ���ǽ���������ϸ���͡�

ON�Ӿ���������������������ͣ�������һ����WHERE�Ӿ����õ�һ���IJ���ֵ���ʽ�� ��������ֱ�����T1��T2������ON���ʽ������Ľ��Ϊ�棬��ô���Ǿ�����ƥ����С�

USING�Ǹ���д�ĸ��������һ���ö��ŷָ����ֶ������б� ��Щ�ֶα��������ӱ��еģ������γ�һ��������������ʾ��Щ�ֶζԱ�����ͬ�� ���JOIN USING �������Ϊÿһ����ȵ������ֶ����һ���ֶΣ�����������Ը���������������ֶΡ� ��ˣ�USING (a, b, c) ��Ч�� ON (t1.a = t2.a AND t1.b = t2.b AND t1.c = t2.c) ֻ���������ʹ����ON����ô�ڽ���� a��b���� c�ֶ�ÿ�������������� ����USING��ʱ��ÿ���ֶξ�ֻ����һ����

���NATURAL �� USING ����д��ʽ�����γ�һ�� USING �б� ���б�����Щ���������ﶼ�����˵��ֶ�������ɡ���USINGһ������Щ�ֶ�ֻ������������һ�Ρ�

�������ӿ��ܵ������ǣ�

INNER JOIN

���� T1 ��ÿһ�� R1�����ɵ����ӱ���һ�ж�Ӧ T2 �е�ÿһ������� R1 �������������С�

LEFT OUTER JOIN

���ȣ�ִ��һ�������ӡ�Ȼ��Ϊ T1 ����Щ�� T2 ���κ�һ�ж������������������з���һ�������У� ͬʱ�����������Ӧ T2 �����ÿ�ֵ���롣��ˣ� ���ɵ����ӱ����������ذ������� T1 ���ÿһ������һ��������

RIGHT OUTER JOIN

���ȣ�ִ��һ�������ӡ�Ȼ��Ϊ T2 ����Щ�� T1 ���κ�һ�ж������������������з���һ�������У� ͬʱ�����������Ӧ T1 �����ÿ�ֵ���롣��ˣ� ���ɵ����ӱ����������ذ������� T2 ���ÿһ�С�

FULL OUTER JOIN

���ȣ�ִ��һ�������ӡ�Ȼ��Ϊ T1 ����Щ�� T2 ���κ�һ�ж������������������з���һ�������У� ͬʱ�����������Ӧ T2 �����ÿ�ֵ���롣 ͬ����Ϊ T2 ����Щ�� T1 ����κ��ж������������������з���һ�������У��������Ӧ T1 �����ÿ�ֵ���롣

��� T1 �� T2 ��һ�����߶��ǿ������ӵı� ��ô�������͵����Ӷ����Դ���һ���Ƕ����һ�� �������JOIN�Ӿ���Χʹ��Բ��������������˳�� ���û��Բ��������ôJOIN�Ӿ��Ǵ�������Ƕ�׵ġ�

Ϊ�˽�����Щ���⣬����������һ���� t1

 num | name
-----+------
   1 | a
   2 | b
   3 | c

�� t2

 num | value
-----+-------
   1 | xxx
   3 | yyy
   5 | zzz

Ȼ�������ò�ͬ�����ӷ�ʽ���Ի�ø��ֽ����

=> SELECT * FROM t1 CROSS JOIN t2;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   1 | a    |   3 | yyy
   1 | a    |   5 | zzz
   2 | b    |   1 | xxx
   2 | b    |   3 | yyy
   2 | b    |   5 | zzz
   3 | c    |   1 | xxx
   3 | c    |   3 | yyy
   3 | c    |   5 | zzz
(9 rows)

=> SELECT * FROM t1 INNER JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   3 | c    |   3 | yyy
(2 rows)

=> SELECT * FROM t1 INNER JOIN t2 USING (num);
 num | name | value
-----+------+-------
   1 | a    | xxx
   3 | c    | yyy
(2 rows)

=> SELECT * FROM t1 NATURAL INNER JOIN t2;
 num | name | value
-----+------+-------
   1 | a    | xxx
   3 | c    | yyy
(2 rows)

=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   2 | b    |     |
   3 | c    |   3 | yyy
(3 rows)

=> SELECT * FROM t1 LEFT JOIN t2 USING (num);
 num | name | value
-----+------+-------
   1 | a    | xxx
   2 | b    |
   3 | c    | yyy
(3 rows)

=> SELECT * FROM t1 RIGHT JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   3 | c    |   3 | yyy
     |      |   5 | zzz
(3 rows)

=> SELECT * FROM t1 FULL JOIN t2 ON t1.num = t2.num;
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   2 | b    |     |
   3 | c    |   3 | yyy
     |      |   5 | zzz
(4 rows)

�� ON ��������������Ҳ���԰��������Ӳ�ֱ����ص����������ֹ��ܿ��ܶ�ijЩ��ѯ�����ã�������Ҫ������ϸ������� ���磺

=> SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num AND t2.value = 'xxx';
 num | name | num | value
-----+------+-----+-------
   1 | a    |   1 | xxx
   2 | b    |     |
   3 | c    |     |
(3 rows)

7.2.1.2. ������

����Ը�һ������ӱ�����һ����ʱ�����֣�����ʣ�µIJ�ѯ��������Щ�����ı� �����������������

Ҫ����һ������������ǿ���д��

FROM table_reference AS alias

����

FROM table_reference alias

AS �ؼ���Ŀǰûɶ�ر�ĺ��塣 alias �����������ʶ����

������ĵ���Ӧ���Ǹ�����������Ƚ϶̵ı�ʶ���� ���������Ӿ���ö�һЩ�����磺

SELECT * FROM some_very_long_table_name s JOIN another_fairly_long_name a ON s.id = a.num;

������Ϊ��ǰ��ѯ�ı����õ������� — ���Dz����ܹ��øñ�����������������ˡ����

SELECT * FROM my_table AS m WHERE my_table.a > 5;

�Dz��Ϸ��� SQL �﷨�����ォ���������飨���� PostgreSQL�Ա�׼����չ������ FROM �Ӿ�����������������һ�������ã���������ѯ������������������

SELECT * FROM my_table AS m, my_table AS my_table WHERE my_table.a > 5;

����������һ���������ӣ�ͨ���ɲ�������Ҫ�ġ�

Բ�������ڽ�����壮�������佫�ѱ��� b �������ӵĽ�������Ǻ�ǰ������Ӳ�ͬ�ģ�

SELECT * FROM (my_table AS a CROSS JOIN my_table) AS b ...

����һ����ʽ�ij��˸�����������ñ���ֶθ�������ʱ���֣�

FROM table_reference [AS] alias ( column1 [, column2 [, ...]] )

����������ֶα����ȱ���ʵ�ʵ��ֶ��٣���ô������ֶξ�û���������� ����﷨���������ӻ��Ӳ�ѯ�ر����ã�

�������Щ��ʽ�е��κ�һ�ָ�һ��JOIN�Ӿ�����������һ�������� ��ô�ñ�������JOIN����������ԭʼ�����֡�����

SELECT a.* FROM my_table AS a JOIN your_table AS b ON ...

�ǺϷ� SQL������

SELECT a.* FROM (my_table AS a JOIN your_table AS b ON ...) AS c

�Dz��Ϸ��ģ������ a �ڱ���c�����ǿ������ġ�

7.2.1.3. �Ӳ�ѯ

����һ����������Ӳ�ѯ�����Χ��Բ�����ﲢ����������һ�������� ������ Section 7.2.1.2�������磺

FROM (SELECT * FROM table1) AS alias_name

������ӵ�Ч�� FROM table1 AS alias_name�� ����Ȥ�����������Ӳ�ѯ�����з����ۼ���ʱ�� ���ʱ���Ӳ�ѯ���ܹ��ɳ�һ���򵥵����ӡ�

7.2.1.4. ����

��������Щ����һ���м��ϵĺ�����������Ͽ������ɻ����������ͣ��������ͣ���ɣ� Ҳ�������ɷ����������ͣ�����У���ɡ����ǵ��÷�����һ������ͼ�������ڲ�ѯ��FROM�Ӿ�����Ӳ�ѯ�� �������ص��ֶο�����һ������ͼ�������Ӳ�ѯ�ֶ����������� SELECT��JOIN������ WHERE �Ӿ��

���һ����������һ�������������ͣ���ô���еĽ���������Ժ��������������ġ� �����������һ���������ͣ���ô����ֶε����ֺ͸����͵�ÿ���������Ե�������ͬ��

���������� FROM �Ӿ���ȡһ������������Ҳ���Բ����������� ���һ�������� FROM �Ӿ���û�б�������ô��ʹ�ú�������Ϊ���������֡�

���ӣ�

CREATE TABLE foo (fooid int, foosubid int, fooname text);

CREATE FUNCTION getfoo(int) RETURNS SETOF foo AS $$
    SELECT * FROM foo WHERE fooid = $1;
$$ LANGUAGE SQL;

SELECT * FROM getfoo(1) AS t1;

SELECT * FROM foo
    WHERE foosubid IN (select foosubid from getfoo(foo.fooid) z
                           where z.fooid = foo.fooid);

CREATE VIEW vw_getfoo AS SELECT * FROM getfoo(1);

SELECT * FROM vw_getfoo;

��ʱ���һ����������ɸ��ݲ�ͬ�ĵ��÷������Է��ز�ͬ���ֶ��Ǻ����õġ� Ϊ��֧����Щ��������������Ϊ����α���� record�� ����ڲ�ѯ��ʹ�������ĺ�������ô���DZ����ڲ�ѯ������Ԥ�ڵ��нṹ�� ����ϵͳ��֪����η����͹滮�ò�ѯ�������ǿ�����������ӣ�

SELECT *
    FROM dblink('dbname=mydb', 'select proname, prosrc from pg_proc')
      AS t1(proname name, prosrc text)
    WHERE proname LIKE 'bytea%';

dblink ����ִ��һ��Զ�̵IJ�ѯ������ contrib/dblink���� ������Ϊ���� record����Ϊ�����ܻᱻ�����κ����͵IJ�ѯ�� ʵ�ʵ��ֶμ������ڵ������IJ�ѯ��������������������֪������ * �����Ķ���Ӧ����չ��ʲô���ӡ�

7.2.2. WHERE �Ӿ�

WHERE �Ӿ� ���﷨��

WHERE search_condition

����� search_condition �����ⷵ��һ������Ϊboolean��ֵ���ʽ ������ Section 4.2����

����ɶ�FROM�Ӿ�Ĵ���֮�����ɵ�ÿһ�ж���������������м�顣 ����������Ľ�����棬��ô���������������У�����Ҳ����˵�� �������Ǽٻ�գ��Ͱ�����������������ͨ������Ҫ����һЩ��FROM�Ӿ������ɵ��У� �ⲻ�DZ���ģ���������������Ļ�����ôWHERE�Ӿ��ûʲô���ˡ�

ע��: �����ӵ����������ȿ���д�� WHERE �Ӿ�Ҳ����д�� JOIN �Ӿ�� ���磬��Щ����ʽ�ǵ�Ч�ģ�

FROM a, b WHERE a.id = b.id AND b.val > 5

��

FROM a INNER JOIN b ON (a.id = b.id) WHERE b.val > 5

���߿��ܻ���

FROM a NATURAL JOIN b WHERE b.val > 5

�������ĸ�ֻ��һ��������⡣FROM�Ӿ����JOIN�﷨���ܲ���ô������ֲ��������Ʒ�С� �����ⲿ���ӣ�outer join�����ԣ��������κ�����¶�û��ѡ�����DZ�����FROM�Ӿ�����ɡ� �ⲿ���ӵ� ON/USING �Ӿ�������WHERE������ ��Ϊ���ж����ս�����е�������Щ��ƥ��������У���ɾ��

������һЩ WHERE �Ӿ�����ӣ�

SELECT ... FROM fdt WHERE c1 > 5

SELECT ... FROM fdt WHERE c1 IN (1, 2, 3)

SELECT ... FROM fdt WHERE c1 IN (SELECT c1 FROM t2)

SELECT ... FROM fdt WHERE c1 IN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10)

SELECT ... FROM fdt WHERE c1 BETWEEN (SELECT c3 FROM t2 WHERE c2 = fdt.c1 + 10) AND 100

SELECT ... FROM fdt WHERE EXISTS (SELECT c1 FROM t2 WHERE c2 > fdt.c1)

������������fdt�Ǵ�FROM�Ӿ��������ı� ��Щ������WHERE�Ӿ�������������д�fdt��ɾ���� ��ע�����ǰѱ����Ӳ�ѯ����һ��ֵ���ʽ���á� �ͺ����κ�������ѯһ�����Ӳ�ѯ�����ʹ�ø��ӵı���ʽ�� ͬʱ����ע��fdt����������Ӳ�ѯ�ġ� ��c1���γ�fdt.c1ֻ����c1�Ǹ��Ӳ�ѯ���ɵ��е�����ʱ���DZ���ġ� �����������ֿ�����������׼ȷ�ԣ���ʹ��ʱ���DZ���ġ� ������Ӿ���ʾ���ֶ����ַ�Χ��δ�����ѯ��չ�������ڲ��ѯ��

7.2.3. GROUP BY �� HAVING �Ӿ�

��ͨ����WHERE������֮�����ɵ��������Լ�����GROUP BY �Ӿ���з��飬Ȼ����HAVING�Ӿ�ɾ��һЩ�����С�

SELECT select_list
	FROM ...
	[WHERE ...]
	GROUP BY grouping_column_reference [, grouping_column_reference]...

GROUP BY �Ӿ� ���ڰ���Щ�ڱ������г������Ϲ�����ֵͬ���оۼ���һ�� ��Щ�е��г�˳��û��ʲô��ϵ�� Ч���ǰ�ÿ�鹲����ֵͬ��������Ϊһ�����У������������������С� �����Ϳ���ɾ���������ظ���/�����Ӧ������Щ��ľۼ��� ���磺

=> SELECT * FROM test1;
 x | y
---+---
 a | 3
 c | 2
 b | 5
 a | 1
(4 rows)

=> SELECT x FROM test1 GROUP BY x;
 x
---
 a
 b
 c
(3 rows)

�ڵڶ�����ѯ����Dz���д�� SELECT * FROM test1 GROUP BY x�� ��Ϊ�ֶ� y ��û���ĸ�ֵ���Ժ�ÿ��������������� ��������ֶο�����ѡ���б�����������Ϊ����ÿ���鶼�е�һ����ֵ��

ͨ�������һ���������飬��ôû���ڷ��������õ��ֶζ��������ã������ھۼ����ʽ�����⡣ һ�����ۼ����ʽ�������ǣ�

=> SELECT x, sum(y) FROM test1 GROUP BY x;
 x | sum
---+-----
 a |   4
 b |   5
 c |   2
(3 rows)

����� sum ��һ���ۼ������������������ϼ���һ����ֵ�� �йؿ��õľۼ������ĸ�����Ϣ������ Section 9.15 ���ҵ���

��ʾ: û�оۼ����ʽ�ķ���ʵ���ϼ�����һ���ֶ��ж�����ֵ�ļ��ϡ� ����Ҳ������ DISTINCT �Ӿ�ʵ�֣�����Section 7.3.3����

����������һ�����ӣ�������ÿ�ֲ�Ʒ�������۶�����������в�Ʒ�������۶��

SELECT pid, p.name, (sum(s.units) * p.price) AS sales
  FROM products p LEFT JOIN sales s USING ( pid )
  GROUP BY pid, p.name, p.price;

�����������ֶ�pid�� p.name����p.price������GROUP BY�Ӿ�� ��Ϊ���Ƕ��ڲ�ѯѡ���б��ﱻ���õ��� �����ݲ�Ʒ���������õIJ�ͬ�����ֺͼ۸���ܺͲ�Ʒ ID ��ȫ�޹أ���������϶���ķ�������Dz��صģ� ������Щ��δʵ�֡��� �ֶ�s.units������GROUP BY�б����Ϊ��ֻ����һ���ۼ����ʽ��sum(...)�� ��ʹ�ã�������һ���Ʒ�����۶����ÿ�ֲ�Ʒ�������ѯ������һ���ò�Ʒ���������۶���ܺ͡�

���ϸ�� SQL �GROUP BYֻ�ܶ�Դ����н��з��飬�� PostgreSQL �������չΪҲ����GROUP BY��Щ��ѡ���б��е��ֶΡ�Ҳ�����ֵ���ʽ���з��飬�������Ǽ򵥵��ֶΣ�

���һ�����Ѿ���GROUP BY�Ӿ�����飬Ȼ������ֻ�����е�ijЩ�����Ȥ�� ��ô�Ϳ�����HAVING�Ӿ䣬������WHERE�Ӿ䣬����ɾ��һ��������ı��е�һЩ�顣 �﷨�ǣ�

SELECT select_list FROM ... [WHERE ...] GROUP BY ... HAVING boolean_expression

�� HAVING �Ӿ��еı��ʽ�������÷���ı��ʽ��δ����ı��ʽ�����߱����漰һ���ۼ���������

���ӣ�

=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING sum(y) > 3;
 x | sum
---+-----
 a |   4
 b |   5
(2 rows)

=> SELECT x, sum(y) FROM test1 GROUP BY x HAVING x < 'c';
 x | sum
---+-----
 a |   4
 b |   5
(2 rows)

Ȼ����һ������ʵ�����ӣ�

SELECT product_id, p.name, (sum(s.units) * (p.price - p.cost)) AS profit
    FROM products p LEFT JOIN sales s USING (product_id)
    WHERE s.date > CURRENT_DATE - INTERVAL '4 weeks'
    GROUP BY product_id, p.name, p.price, p.cost
    HAVING sum(p.price * s.units) > 5000;

������������WHERE�Ӿ�������Щ�Ƿ�����ֶ�ѡ�������С� �����ʽֻ�Ƕ���Щ������ܷ���������Ϊ�棩�� ��HAVING�Ӿ�ѡ����Щ���۳��� 5000 ������С� ��ע��ۼ���������Ҫ�ڲ�ѯ�е����еط���һ����