4.2. ֵ���ʽ

ֵ���ʽ���ڸ����﷨�����У������� SELECT �����Ŀ���б��У��� INSERT �� UPDATE �������µ���ֵ����������������е�����������ʹ�á� ������ʱ���ֵ���ʽ�Ľ������������ �Ա���һ������ʽ�Ľ����������һ���������ֵ���ʽҲ�����������ʽ �����߸��򵥵����ʽ�������ʽ�﷨��������Ի������ֵ���ֵ�����������߼������ϣ����������������㡣

ֵ���ʽ����������֮һ��

��������б����⣬������๹����Թ���Ϊ���ʽ�����Dz���ѭ�κ�ͨ�õ��﷨���� ����ͨ���к���������������壬������ Chapter 9 ����ʵ�λ�������� һ�������� IS NULL �Ӿ䡣

�����Ѿ��� Section 4.1.2 �������۹��������ˡ�����Ľ�����ʣ�µ�ѡ�

4.2.1. �ֶ�����

һ���ֶο�����������ʽ�����ã�

correlation.columnname

correlation ��һ��������֣�������ģʽ���Σ��� ��������FROM�Ӿ������ķ�������ı�ı����������ǹؼ��� NEW �� OLD�� ��NEW�� OLDֻ�ܳ�����һ����д�����У� ��������ص����ֿ����������� SQL ����С��� ����ڵ�ǰ��ѯ����ʹ�õ����б��У����ֶ�������Ψһ�ģ� ��ô���������ֺͷָ��õĵ�Ϳ���ʡ�ԡ� ���ּ� Chapter 7����

4.2.2. λ�ò���

λ�ò����������ڱ�ʶ���ⲿ��һ�� SQL ����һ�������� �������� SQL ������������׼���õIJ�ѯ�� ��Щ�ͻ��˿⻹֧���� SQL �����ִ������������ֵ����������²����������� SQL �ִ���������ݡ� һ����������ʽ���£�

$number

���磬����һ������ dept �Ķ��壬 ����

CREATE FUNCTION dept(text) RETURNS dept
  AS $$ SELECT * FROM dept WHERE name = $1 $$
  LANGUAGE SQL;

�ں��������õ�ʱ������� $1 ������һ�������IJ������档

4.2.3. �±�

���һ�����ʽ����һ���������͵���ֵ����ô���ǿ���ͨ��д���������ı��ʽ����������ֵ��Ԫ��

expression[subscript]

����Ƕ�����ڵ�Ԫ�أ�һ��"����Ƭ��"������������ķ�����ȡ

expression[lower_subscript:upper_subscript]

������������� [ ] ����˼�ǰ��������ı��ķ�ʽ���֡��� ÿ��subscript�Լ�����һ�����ʽ������������һ������ֵ��

ͨ�������� expression ������Բ������Χ�� �����Ҫ���нű����ı��ʽֻ��һ���ֶ����û���һ��λ�ò�������ôԲ��������ʡ�ԡ� ͬ�������Դ�����Ƕ�ά�ģ���ô����ű����������һ�𡣱��磬

mytable.arraycolumn[4]
mytable.two_d_column[17][34]
$1[10:42]
(arrayfunction(a,b))[42]

���һ���������Բ�����DZ���ġ����� Section 8.10 ��ȡ�й�����ĸ�����Ϣ��

4.2.4. �ֶ�ѡ��

���һ�����ʽ����һ���������ͣ������ͣ�����ô������ķ������Գ�ȡһ��ָ�����ֶ�

expression.fieldname

ͨ������ expression ������Բ������Χ�� �������Ҫѡȡ�ı��ʽֻ��һ�������û���λ�ò���������ʡ��Բ������ ����

mytable.mycolumn
$1.somecolumn
(rowfunction(a,b)).col3

����ˣ�һ��ȫ�Ƶ��ֶ�����ʵ����ֻ��һ���ֶ�ѡ���﷨����������

4.2.5. ����������

�����������������﷨��

expression operator expression (˫Ŀ��׺������)
operator expression (��Ŀǰ׺������)
expression operator (��Ŀ��׺������)

����� operator �Ǻ���ѭ�﷨���� Section 4.1.3�� �����ǼǺţ�AND�� OR���� NOT ֮һ�� ������һ�������εIJ�������

OPERATOR(schema.operatorname)

��������ĸ��������Լ������ǵ�Ŀ����˫Ŀȡ����ϵͳ���û�������ʲô��������Chapter 9 ���������õIJ�������

4.2.6. ��������

�������õ��﷨�ǺϷ��������֣�������ģʽ�����Σ��� ���������Բ����������IJ����б�

function ([expression [, expression ... ]] )

���磬����Ĵ������ 2 ��ƽ������

sqrt(2)

���ú������б��� Chapter 9 � ���������������û���ӡ�

4.2.7. �ۼ����ʽ

һ���ۼ����ʽ����һ���ۼ�������һ����ѯѡ�����еĴ��� һ���ۼ������Ѷ����������Ϊһ�����ֵ�� �����������ͻ�ƽ����һ���ۼ����ʽ���﷨������֮һ��

aggregate_name (expression)
aggregate_name (ALL expression)
aggregate_name (DISTINCT expression)
aggregate_name ( * )

���� aggregate_name ��ǰ�涨��ľۼ�����������ȫ�ƣ��� �� expression ��һ�����������ۼ����ʽ������ֵ���ʽ��

��һ����ʽ�ľۼ����ʽΪ���б��ʽ���ɷǿ�ֵ�������е��þۼ��� ��ʵ���ϣ��Ƿ���Կ�ֵ�ɾۼ��������� — �������б�׼�ľۼ��������������ǡ��� �ڶ�����ʽ�͵�һ��һ������Ϊ ALL ��ȱʡֵ�� ��������ʽΪ�������������ҵ����ʽ������Ψһ�ķǿ�ֵ���þۼ��� ���һ����ʽΪÿ�������У������ǿջ��Ƿǿգ�����һ�ξۼ��� ��Ϊû�������ض�������ֵ��ͨ����ֻ�Ƕ� count() �ۼ��������á�

���磬count(*) ���������е������� count(f1) ���� f1 Ϊ�ǿյ����������� count(distinct f1) ���� f1 Ψһ�ǿյ�������

Ԥ����ľۼ������� Section 9.15 �������� �����ۼ������������û����ӡ�

һ���ۼ����ʽֻ���� SELECT ����Ľ���б���� HAVING �Ӿ�����֡� ��ֹ�������Ӿ�����֣����� WHERE ���棬��Ϊ��Щ�Ӿ��߼��������ɾۼ����֮ǰ���㡣

���һ���ۼ����ʽ������һ���Ӳ�ѯ����� Section 4.2.9 �� Section 9.16���� �ۼ�ͨ�������Ӳ�ѯ�����Ͻ��м��㡣��������ۼ��IJ���ֻ��������ѯ�ı�������һ�����⣺ ����ۼ��������������������ѯ�������ڸò�ѯ�Ͻ��м��㡣 �þۼ����ʽ���������������ֵ��Ӳ�ѯ������ѯ�����ã��������൱���Ӳ�ѯ�κ�һ�μ����е�һ�������� ����ۼ����ʽ���й�ֻ�ܳ����ڽ���л��� HAVING �Ӿ�����������ھۼ������IJ�ѯ�㡣

4.2.8. ����ת��

һ������ת������һ����һ���������͵�����һ���������͵�ת���� PostgreSQL �������ֵ�Ч������ת���﷨��

CAST ( expression AS type )
expression::type

CAST �﷨��ѭ SQL��:: ���﷨�� PostgreSQL ��ͳ�÷���

�����һ����֪���͵�ֵ���ʽӦ��ת����������һ������ʱ����ת���� ֻ���ڶ����˺��ʵ�����ת������������£���ת�����ܳɹ��� ��ע����һ������ڳ�����ת������������ Section 4.1.2.5 ��ʾ�� һ��Ӧ����ij��δ���ε��ִ��ı���ת����ʾ��һ���ִ��ı���ֵ����һ����ʼ�����ͣ� ����������κ����Ͷ���ɹ�������ִ��ı������ݷ��ϸ��������͵������﷨���ܡ���

�������һ��ֵ���ʽ���ɵ���ֵ��ij���Ͷ��Բ����ڻ���������� ��ô���ǿ���ʡ����ȷ������ת�������磬�ڸ�һ�����ֶθ�ֵ��ʱ�򣩣� ������������£�ϵͳ���Զ�����һ������ת���� �������Զ�ת��ֻ��������Щϵͳ���б���� "OK to apply implicitly" ��ת�������� ����ת��������������ȷ��ת���﷨���á� ��Щ������Ϊ�˱���һЩ�����ת����Ӧ�á�

����Ҳ�����ú��������﷨����һ������ת����

typename ( expression )

�������������ֻ��������Щ����ͬʱҲ����Ч�������ֵ����͡� ���磬double precision �Ͳ�����ô�ã� ���ǵ�Ч�� float8 ���ԡ�ͬ����interval�� time���� timestamp �������˫����Ҳֻ����ô�ã� ��Ϊ�����﷨��ͻ����ˣ�������������ת���ᵼ�²�һ�£� ���Կ���Ӧ�ñ�������Ӧ������ô�á� ���������﷨ʵ���Ͼ��ƺ�һ���������á����ʹ�����ֱ�׼ת���﷨������ʱת���� ��ô�������ڲ�����һ����ע��ú���ִ��ת����ͨ���� ����ת�����������ǵ��������ͬ�����������Ҫ��ɲ�����Щ������ֲ�ij�����������Ķ�������

4.2.9. �����Ӳ�ѯ

һ�������Ӳ�ѯ��һ������Բ���������ͨ SELECT��ѯ�� ��ֻ����ֻ��һ���ֶε�һ�С������� Chapter 7 ��ȡ�й�д��ѯ����Ϣ���� �� SELECT ����ִ�У� ���䵥������ֵ������Χ��ֵ���ʽ��ʹ�á� ��һ�����س���һ�л��߳���һ�еIJ�ѯ����������ѯ�Ǵ���ġ� �����������ض���ִ���У��Ӳ�ѯ��������������󣻱��������Ϊ��NULL���� ���Ӳ�ѯ����������Χ��ѯ�ı�������Щ����Ҳ���ڼ��������Ӳ�ѯ��ʱ��������ʹ�õġ� �ּ� Section 9.16��

���磬����IJ�ѯ�ҳ�ÿ�����е�����˿������ij��У�

SELECT name, (SELECT max(pop) FROM cities WHERE cities.state = states.name)
FROM states;

4.2.10. ���鹹����

һ�����鹹������һ�����ʽ���������ij�ԱԪ���Ϲ���һ������ֵ�� һ���򵥵����鹹�����ɹؼ��� ARRAY��һ�������� [�� һ���������ʽ���ö��ŷָ�����ʾ����Բ��ֵ���Լ����һ���ҷ����� ]�� ����

SELECT ARRAY[1,2,3+4];
  array
---------
 {1,2,7}
(1 row)

����Ԫ�������dz�Ա���ʽ�Ĺ������ͣ�ʹ�ú� UNION �� CASE ����һ���Ĺ�������� ������ Section 10.5����

��ά����ֵ����ͨ��Ƕ�����鹹�����ķ����������� ���ڲ㹹������ؼ��� ARRAY ����ʡ�ԡ����磬�������������ͬ���Ľ����

SELECT ARRAY[ARRAY[1,2], ARRAY[3,4]];
     array
---------------
 {{1,2},{3,4}}
(1 row)

SELECT ARRAY[[1,2],[3,4]];
     array
---------------
 {{1,2},{3,4}}
(1 row)

��Ϊ��ά�������ʽ���Σ�ͬ����ڲ㹹������������ͬά�������顣

��ά���鹹����Ԫ�ؿ������κ����ɺ�������Ķ���������������һ���� ARRAY ���졣 ���磺

CREATE TABLE arr(f1 int[], f2 int[]);

INSERT INTO arr VALUES (ARRAY[[1,2],[3,4]], ARRAY[[5,6],[7,8]]);

SELECT ARRAY[f1, f2, '{{9,10},{11,12}}'::int[]] FROM arr;
                     array
------------------------------------------------
 {{{1,2},{3,4}},{{5,6},{7,8}},{{9,10},{11,12}}}
(1 row)

����Ҳ���Դ�һ���Ӳ�ѯ�Ľ���й���һ�����顣��������ʽ�£� ���鹹�������ùؼ��� ARRAY �������һ����Բ���������Ƿ���������Χ���Ӳ�ѯ�� ���磺

SELECT ARRAY(SELECT oid FROM pg_proc WHERE proname LIKE 'bytea%');
                          ?column?
-------------------------------------------------------------
 {2011,1954,1948,1952,1951,1244,1950,2005,1949,1953,2006,31}
(1 row)

�Ӳ�ѯ���뷵��һ���ֶΡ����ɵ�һά���齫Ϊ�Ӳ�ѯ��ÿ�н������һ��Ԫ�أ� Ԫ������ƥ���Ӳ�ѯ������ֶΡ�

�� ARRAY ����������ֵ�Ľű����Ǵ�һ��ʼ�� �й�����ĸ�����Ϣ������ Section 8.10��

4.2.11. ���

һ���й�������һ�����ṩ�����ij�Ա�ֶ���ֵ����������ֵ��Ҳ�и�������ֵ���ı��ʽ�� һ���й������ɹؼ��� ROW��һ����Բ������ ������߶���������ֶ�ֵ�ı��ʽ���ö��ŷָ������Լ����һ����Բ���������磬

SELECT ROW(1,2.5,'this is a test');

������б����ж�����ʽ����ô�ؼ��� ROW �ǿ�ѡ�ġ�

ȱʡʱ��ROW ���ʽ������ֵ��һ�������ļ�¼���͡������Ҫ������԰���ת����һ�������ĸ������� — �ȿ�����һ����������ͣ�Ҳ������һ���� CREATE TYPE AS �����ĸ������͡� ���ܻ���Ҫһ����ȷ��ת���Ա������塣���磺

CREATE TABLE mytable(f1 int, f2 float, f3 text);

CREATE FUNCTION getf1(mytable) RETURNS int AS 'SELECT $1.f1' LANGUAGE SQL;

-- ��Ϊֻ��һ�� getf1() ���ڣ����Բ���Ҫ����ת��
SELECT getf1(ROW(1,2.5,'this is a test'));
 getf1
-------
     1
(1 row)

CREATE TYPE myrowtype AS (f1 int, f2 text, f3 numeric);

CREATE FUNCTION getf1(myrowtype) RETURNS int AS 'SELECT $1.f1' LANGUAGE SQL;

-- ����������Ҫ����ת���Ա��������ĸ�������
SELECT getf1(ROW(1,2.5,'this is a test'));
ERROR:  function getf1(record) is not unique

SELECT getf1(ROW(1,2.5,'this is a test')::mytable);
 getf1
-------
     1
(1 row)

SELECT getf1(CAST(ROW(11,'this is a test',2.5) AS myrowtype));
 getf1
-------
    11
(1 row)

�й������������������洢�ڸ������ͱ��ֶ�����ĸ�������ֵ�� �����Ǵ��ݸ�һ�����ܸ������Ͳ����ĺ��������У�����Ҳ���ԱȽ���������ֵ������ IS NULL �� IS NOT NULL ����һ������ֵ������

SELECT ROW(1,2.5,'this is a test') = ROW(1, 3, 'not the same');

SELECT ROW(a, b, c) IS NOT NULL FROM table;

�����ϸ�ڣ������ Section 9.17�� �й��컹�������������Ӳ�ѯ����Щ�� Section 9.16 ��������ϸ���ۡ�

4.2.12. ���ʽ�������

�ӱ��ʽ�ļ���˳����û�ж���ġ��ر�Ҫָ�����ǣ� һ�����������ߺ��������벢��һ���ǰ��մ������ҵ�˳�������ij���ض���˳����м���ġ�

���⣬���һ�����ʽ�Ľ������ͨ��ֻ�ж�����һ���־Ϳ��Եõ��� ��ô�����ӱ��ʽ�Ϳ�����ȫ�������ˡ����磬���������ôд

SELECT true OR somefunc();

��ô somefunc() �ͣ����ܣ��������ᱻ���á� �������д����ģ�Ҳ���ܻ�������

SELECT somefunc() OR true;

��ע�������ijЩ���������Ĵ�������"��·"�Dz�һ���ġ�

��ˣ�����Щ�и����õĺ�����Ϊ���ӱ��ʽ��һ�����Dz����ǵ�ѡ�� �� WHERE �� HAVING �Ӿ��������������û����Ǽ���˳�����ر�Σ�յģ� ��Ϊ��Щ�Ӿ䶼����Ϊ����һ��ִ�й滮��һ���ֽ����˴������ٴ��� ����Щ�Ӿ���IJ������ʽ��AND/OR/NOT ����ϣ������Բ���������������������ⷽʽ����ʶ��

���ǿ�Ƽ���˳��dz���Ҫ����ô����ʹ�� CASE ���죨���� Section 9.13���� ���磬������һ����ͼ������ WHERE �Ӿ��ﱻ����IJ����ŵķ�����

SELECT ... WHERE x <> 0 AND y/x > 1.5;

���������������ǰ�ȫ�ģ�

SELECT ... WHERE CASE WHEN x <> 0 THEN y/x > 1.5 ELSE false END;

�����ַ��� CASE �������ֹ�Ż������Ӧ��ֻ�ڱ�Ҫ��ʱ��ʹ�á� �������������������������д�� y > 1.5*x ���á���