¾�ΥС�������ʸ�� �� 17 | 16 | 15 | 14 | 13 | 12 | 11 | 10 | 9.6 | 9.5 | 9.4 | 9.3 | 9.2 | 9.1 | 9.0 | 8.4 | 8.3 | 8.2 | 8.1 | 8.0 | 7.4 | 7.3 | 7.2

35.4. �䤤��碌�����SQL�˴ؿ�

SQL�ؿ��ϡ�Ǥ�դ�SQLʸ�Υꥹ�Ȥ�¹Ԥ������Υꥹ�ȤκǸ���䤤��碌�η�̤��֤��ޤ��� ñ��ʡʽ���ǤϤʤ��˾�硢�Ǹ���䤤��碌�η�̤κǽ�ιԤ��֤���ޤ��� ��ʣ���Ԥη�̤Τ�����"�ǽ�ι�"�ϡ�ORDER BY����Ѥ��ʤ��¤�����դ��뤳�Ȥ��Ǥ��ʤ����Ȥ�Ф��Ƥ����Ƥ����������� �Ǹ���䤤��碌������Ԥ��֤��ʤ�����NULL�ͤ��֤���ޤ���

¾�ˤ⡢SQL�ؿ��ϡ�SETOF sometype�����֤��褦�˻��ꤹ�뤳�ȡ��ޤ���Ʊ�դ�RETURNS TABLE(columns)��������뤳�Ȥˤ�ꡢ������֤��褦��������뤳�Ȥ�Ǥ��ޤ��� ���ξ�硢�Ǹ���䤤��碌�η�̤����ƤιԤ��֤���ޤ��� �ܺ٤ϸ���������ޤ���

SQL�ؿ������Τϡ����ߥ�����Ƕ��ڤä�SQLʸ�Υꥹ�ȤǤʤ���Фʤ�ޤ��� �Ǹ��ʸ�θ�Υ��ߥ�����Ͼ�ά��ǽ�Ǥ��� �ؿ���void���֤���Τ��������Ƥ��ʤ��¤ꡢ�Ǹ��ʸ��SELECT���ޤ���RETURNING������INSERT��UPDATE���ޤ���DELETE�Ǥʤ���Фʤ�ޤ���

SQL����Ǻ������줿��Ǥ�դΥ��ޥ�ɷ��ϤޤȤ�ơ��ؿ��Ȥ���������뤳�Ȥ��Ǥ��ޤ��� SELECT�䤤��碌�ʳ��ˡ��ǡ����ѹ��Ѥ��䤤��碌�ʤĤޤꡢINSERT��UPDATE��DELETE�ˤ䤽��¾��SQL���ޥ�ɤ�ޤ�뤳�Ȥ��Ǥ��ޤ��� ���㳰��1�Ĥ���ޤ��������BEGIN��COMMIT��ROLLBACK��SAVEPOINT��SQL�ؿ��˴ޤ�뤳�ȤϤǤ��ʤ����Ǥ����� ���������Ǹ�Υ��ޥ�ɤϡ��ؿ�������ͷ��Ȥ������������Τ��֤�SELECT���ޤ���RETURNING�礬�����ΤǤʤ���Фʤ�ޤ��� ����¾�ˤ⡢����ư��򤵤��뤬��ͭ�Ѥ��ͤ��֤��ʤ�SQL�ؿ�������������ΤǤ���С�void���֤���Τ�������뤳�ȤǼ¸���ǽ�Ǥ��� ���Ȥ��С��ʲ��δؿ���emp�ơ��֥뤫����ε����ȤʤäƤ���Ԥ������ޤ���

CREATE FUNCTION clean_emp() RETURNS void AS '
    DELETE FROM emp
        WHERE salary < 0;
' LANGUAGE SQL;

SELECT clean_emp();

 clean_emp
-----------

(1 row)

CREATE FUNCTION���ޥ�ɤι�ʸ�Ǥϡ��ؿ����Τ�ʸ��������Ȥ��ƺ��������ɬ�פ�����ޤ��� ����ʸ��������ε��Ҥˤϡ��̾�ɥ�������դ���項4.1.2.4�ˤ��Ǥ������Ǥ��� ʸ���������ñ�������dz���̾�ι�ʸ�Ǥϡ��ؿ�������ǻ��Ѥ����ñ��������'�ˤȥХå�����å����\�ˡʥ���������ʸ����ʸ����ˤ���Ťˤ��ʤ���Фʤ�ޤ����項4.1.2.1�򻲾ȡˡ�

SQL�ؿ��ΰ����ϴؿ��������$n�Ȥ�����ʸ���Ѥ���ɽ�����Ȥ��Ǥ��ޤ��� �Ĥޤꡢ$1����1�����򼨤���$2����2�����Τ褦�ˤʤ�ޤ��� ������ʣ�緿�ξ�硢$1.name�Τ褦�ʥɥå�ɽ�����Ѥ��ư�����°���˥����������뤳�Ȥ��Ǥ��ޤ��� ���ΰ����ϡ����̻ҤȤ��ƤǤϤʤ����ǡ����ͤȤ��ƤΤ߻��Ѥ��뤳�Ȥ��Ǥ��ޤ��� �������äơ��㤨��

INSERT INTO mytable VALUES ($1);

����������ΤǤ������ʲ���ư��ޤ���

INSERT INTO $1 VALUES (42);

35.4.1. ���ܷ�����Ѥ���SQL�ؿ�

�Ǥ��ñ��SQL�ؿ��ϡ��������餺��ñ��integer�Τ褦�ʴ��ܷ����֤���ΤǤ���

CREATE FUNCTION one() RETURNS integer AS $$
    SELECT 1 AS result;
$$ LANGUAGE SQL;

-- ʸ�����ƥ����̤ι�ʸ�Ǥ�
CREATE FUNCTION one() RETURNS integer AS '
    SELECT 1 AS result;
' LANGUAGE SQL;

SELECT one();

 one
-----
   1

�ؿ�������Ǵؿ��η���Ѥ������̾���result�Ȥ���̾���ǡ�����������Ȥ����ܤ��Ƥ��������� ���������������̾�Ϥ��δؿ��γ�������ϲĻ�ǤϤ���ޤ��� �������äơ����η�̤�result�ǤϤʤ���one�Ȥ�����٥��ɽ������Ƥ��ޤ���

���ܷ�������Ȥ��Ƽ�롢SQL�ؿ���������뤳�ȤϤۤȤ�ɤξ���ñ�Ǥ��� �ʲ�����ˤ����ơ��ؿ������Ǥ��ΰ�����$1��$2�Ȥ��ƥ����������Ƥ��뤳�Ȥ����դ��Ƥ���������

CREATE FUNCTION add_em(integer, integer) RETURNS integer AS $$
    SELECT $1 + $2;
$$ LANGUAGE SQL;

SELECT add_em(1, 2) AS answer;

 answer
--------
      3

�ʲ��ˤ⤦�������Ω�Ĵؿ��򼨤��ޤ��� ����϶�Ը��¤���ΰ�����Ȥ��˻��ѤǤ��ޤ���

CREATE FUNCTION tf1 (integer, numeric) RETURNS integer AS $$
    UPDATE bank
        SET balance = balance - $2
        WHERE accountno = $1;
    SELECT 1;
$$ LANGUAGE SQL;

�ʲ��Τ褦�ˡ��桼���Ϥ��δؿ�����Ѥ��ơ������ֹ�17����100�ɥ������Ф����Ȥ���ǽ�Ǥ���

SELECT tf1(17, 100.0);

�ºݤˤϡ��ؿ��η�̤����1����狼��䤹�����ˤ��뤿��ˡ��ʲ��Τ褦���������Ȥ褤�Ǥ��礦��

CREATE FUNCTION tf1 (integer, numeric) RETURNS numeric AS $$
    UPDATE bank
        SET balance = balance - $2
        WHERE accountno = $1;
    SELECT balance FROM bank WHERE accountno = $1;
$$ LANGUAGE SQL;

����ϻĹ��Ĵ������������λĹ���֤��ޤ��� Ʊ�����Ȥ�RETURNING����Ѥ��ƣ��ĤΥ��ޥ�ɤǹԤ��ޤ���

CREATE FUNCTION tf1 (integer, numeric) RETURNS numeric AS $$
    UPDATE bank
        SET balance = balance - $2
        WHERE accountno = $1
    RETURNING balance;
$$ LANGUAGE SQL;

35.4.2. ʣ�緿����Ѥ���SQL�ؿ�

�ؿ��ΰ�����ʣ�緿�򵭽Ҥ�����硢�ʤ���ޤǹԤäƤ���$1��$2�Τ褦�ˡ�ɬ�פʰ�����������ꤹ������ǤϤʤ���ɬ�פȤ��������°���ʥե�����ɡˤ���ꤹ��ɬ�פ�����ޤ��� �㤨�С�emp�����Ȱ��ǡ�������ĥơ��֥�Ȥ���ȡ�����̾���Ϥ��Υơ��֥���γƹԤ�ɽ��ʣ�緿��̾���Ǥ⤢��ޤ��� �ʲ��˼���double_salary�ؿ��ϡ��������뽾�Ȱ��ε���������������ɤ��ʤ뤫��׻����ޤ���

CREATE TABLE emp (
    name        text,
    salary      numeric,
    age         integer,
    cubicle     point
);

INSERT INTO emp VALUES ('Bill', 4200, 45, '(2,1)');

CREATE FUNCTION double_salary(emp) RETURNS numeric AS $$
    SELECT $1.salary * 2 AS salary;
$$ LANGUAGE SQL;

SELECT name, double_salary(emp.*) AS dream
    FROM emp
    WHERE emp.cubicle ~= point '(2,1)';

 name | dream
------+-------
 Bill |  8400

$1.salary�Ȥ�����ʸ����Ѥ��ơ������ι��ͤ�1�ե�����ɤ����򤷤Ƥ��뤳�Ȥ����ܤ��Ƥ��������� �ޤ���*����Ѥ���SELECT���ޥ�ɤθƤӽФ��Ǥϡ�ʣ�緿���ͤȤ��ơ����ߤΥơ��֥�����Τ�ɽ���ơ��֥�̾����Ѥ��Ƥ��뤳�Ȥˤ����ܤ��Ƥ��������� �̤���ˡ�Ȥ��ơ��ơ��֥�Ԥϰʲ��Τ褦�˥ơ��֥�̾��������Ѥ��ƻ��Ȥ��뤳�Ȥ��Ǥ��ޤ���

SELECT name, double_salary(emp) AS dream
    FROM emp
    WHERE emp.cubicle ~= point '(2,1)';

�����������λ�����ˡ�Ϻ��𤷤䤹�����ᤪ���ᤷ�ޤ���

���ξ��ʣ�緿�ΰ����ͤ�������뤳�Ȥ������ʾ�礬����ޤ��� �����ROW���ǹԤ����Ȥ��Ǥ��ޤ��� �㤨�С��ʲ��Τ褦�ˤ��ƴؿ����Ϥ��ǡ�����Ĵ�����뤳�Ȥ��Ǥ��ޤ���

SELECT name, double_salary(ROW(name, salary*1.1, age, cubicle)) AS dream
    FROM emp;

ʣ�緿���֤��ؿ���������뤳�Ȥ�Ǥ��ޤ��� �ʲ���ñ���emp�Ԥ��֤��ؿ�����򼨤��ޤ���

CREATE FUNCTION new_emp() RETURNS emp AS $$
    SELECT text 'None' AS name,
        1000.0 AS salary,
        25 AS age,
        point '(2,2)' AS cubicle;
$$ LANGUAGE SQL;

�����Ǥϡ���°��������ǻ��ꤷ�Ƥ��ޤ�������������򲿤餫�α黻���֤������뤳�Ȥ�Ǥ��ޤ���

�ؿ�����������ǡ�2�Ĥν��פ���������ʲ��˼����ޤ���

Ʊ���ؿ���ʲ��Τ褦��������뤳�Ȥ�Ǥ��ޤ���

CREATE FUNCTION new_emp() RETURNS emp AS $$
    SELECT ROW('None', 1000.0, 25, '(2,2)')::emp;
$$ LANGUAGE SQL;

�����ǡ�������ʣ�緿��ñ������ñ���֤�SELECT�򵭽Ҥ��ޤ����� �������ǤϤ���Ϥ��ͥ�줿��ΤȤϤ����ޤ��󤬡��㤨�С�ɬ�פ�ʣ���ͤ��֤�¾�δؿ���ƤӽФ��Ʒ�̤�׻����ʤ���Фʤ�ʤ����ʤɡ������ʲ�ˡ�ˤʤ뤳�Ȥ�����ޤ���

�ʲ���2�Ĥ���ˡ�Ǥ��δؿ���ľ�ܸƤӽФ����Ȥ��Ǥ��ޤ���

SELECT new_emp();

         new_emp
--------------------------
 (None,1000.0,25,"(2,2)")

SELECT * FROM new_emp();

 name | salary | age | cubicle
------+--------+-----+---------
 None | 1000.0 |  25 | (2,2)

2���ܤ���ˡ�ˤĤ��Ƥϡ�項35.4.7�Ǥ��ܤ����������ޤ���

ʣ�緿���֤��ؿ�����Ѥ�����ˡ����η�̤���1�ĤΥե�����ɡ�°���ˤΤߤ���Ѥ������Ȥ�����礬����ޤ��� ����ϡ��ʲ��Τ褦�ʹ�ʸ�ǹԤ����Ȥ��Ǥ��ޤ���

SELECT (new_emp()).name;

 name
------
 None

�ѡ��������𤷤ʤ��褦�ˡ���̤��ɲä���ɬ�פ�����ޤ��� ��̤ʤ��ǹԤ����Ȥ���ȡ��ʲ��Τ褦�ʷ�̤ˤʤ�ޤ���

SELECT new_emp().name;
ERROR:  syntax error at or near "."
LINE 1: SELECT new_emp().name;
                        ^

�ޤ����ؿ�ɽ������Ѥ���°������Ф��뤳�Ȥ�Ǥ��ޤ��� ��ñ����������ȡ�attribute(table)��table.attribute�Ȥ���ɽ����ˡ�Τɤ���Ǥ���ѤǤ���Ȥ������ȤǤ���

SELECT name(new_emp());

 name
------
 None

-- �����
-- SELECT emp.name AS youngster FROM emp WHERE emp.age < 30;
-- ��Ʊ��Ǥ���

SELECT name(emp) AS youngster FROM emp WHERE age(emp) < 30;

 youngster
-----------
 Sam
 Andy

ティップ: �ؿ�ɽ����°��ɽ����Ʊ�����ˤ�äơ�"�׻��������줿�ե������"���ϵ����뤿���ʣ�緿���Ф���ؿ�����Ѥ��뤳�Ȥ��Ǥ��ޤ��� �㤨�С��嵭��������줿double_salary(emp)����Ѥ��ơ����Τ褦�˵��Ҥ��뤳�Ȥ��Ǥ��ޤ���

SELECT emp.name, emp.double_salary FROM emp;

��������Ѥ��륢�ץꥱ�������ϡ�double_salary���ºݤˤϥơ��֥����ǤϤʤ����Ȥ�ľ�ܵ��ˤ���ɬ�פϤ���ޤ��� �ʤޤ����ӥ塼���Ѥ��Ʒ׻��������줿�ե�����ɤ��ϵ����뤳�Ȥ��ǽ�Ǥ��ˡ�

ʣ�緿���̤Ȥ����֤��ؿ�����Ѥ���¾����ˡ�ϡ����η�̤򡢤��ιԷ������ϤȤ��Ƽ����դ���ؿ����Ϥ����ʲ��Τ褦����ˡ�Ǥ���

CREATE FUNCTION getname(emp) RETURNS text AS $$
    SELECT $1.name;
$$ LANGUAGE SQL;

SELECT getname(new_emp());
 getname
---------
 None
(1 row)

ʣ�緿�η�̤��֤��ؿ��λ�����ˡ�Ȥ���¾�ˤ⡢�ơ��֥�ؿ��Ȥ��ƸƤӽФ���ˡ������ޤ��� �����項35.4.7���������ޤ���

35.4.3. �ѥ�᡼��̾�դ���SQL�ؿ�

�ʲ�����Τ褦�ˡ��ؿ��Υѥ�᡼����̾�����꿶�뤳�Ȥ��Ǥ��ޤ���

CREATE FUNCTION tf1 (acct_no integer, debit numeric) RETURNS numeric AS $$
    UPDATE bank
        SET balance = balance - $2
        WHERE accountno = $1
    RETURNING balance;
$$ LANGUAGE SQL;

�����Ǥϡ����ѥ�᡼����acct_no�Ȥ���̾����������ѥ�᡼���ˤ�debit�Ȥ���̾����Ϳ�����Ƥ��ޤ��� SQL�ؿ����Τ�ͤ���¤ꡢ��������̾����ñ�ʤ����Ǥ��� �ޤ����ؿ�������Ǥϥѥ�᡼����$1��$2�ʤɤΤ褦�˻��Ȥ��ʤ���Фʤ�ޤ��� �ʰ����μ�³������Ǥϥѥ�᡼��̾������˻��Ѥ��ޤ����� �������ѥ�᡼����̾�����դ��뤳�Ȥϡ�ʸ�񲽤Ȥ�����Ū�Ǥ�ͭ�ѤǤ��� 項4.3���������ޤ������ؿ���¿���Υѥ�᡼������ľ��Ϥޤ����ؿ���ƤӽФ�����̾������Ѥ��뤳�Ȥ�ͭ�ѤǤ���

35.4.4. ���ϥѥ�᡼�������SQL �ؿ�

�ؿ��η�̤ε�����ˡ�ˤϡ�¾�ˤ����ϥѥ�᡼������Ѥ������������ˡ������ޤ��� �ʲ�����򼨤��ޤ���

CREATE FUNCTION add_em (IN x int, IN y int, OUT sum int)
AS 'SELECT $1 + $2'
LANGUAGE SQL;

SELECT add_em(3,7);
 add_em
--------
     10
(1 row)

項35.4.1�Ǽ�����add_em�Ǥȴ���Ū�ʰ㤤�Ϥ���ޤ��� ʣ������֤��ؿ�����������ñ����ˡ���󶡤��뤳�Ȥ����ϥѥ�᡼��������β��ͤǤ��� �ʲ�����򼨤��ޤ���

CREATE FUNCTION sum_n_product (x int, y int, OUT sum int, OUT product int)
AS 'SELECT $1 + $2, $1 * $2'
LANGUAGE SQL;

 SELECT * FROM sum_n_product(11,42);
 sum | product
-----+---------
  53 |     462
(1 row)

����ϴ���Ū�ˡ��ؿ�����Ѥ�ƿ̾��ʣ�緿�κ�����Ԥ��ޤ��� �����Ǥϡ�

CREATE TYPE sum_prod AS (sum int, product int);

CREATE FUNCTION sum_n_product (int, int) RETURNS sum_prod
AS 'SELECT $1 + $2, $1 * $2'
LANGUAGE SQL;

��Ʊ���ǽ���̤ˤʤ�ޤ��� ����������Ω����ʣ�緿�����Ǻ�ޤ���뤳�Ȥ��ʤ��ʤꡢ�����Ǥ���Ȥ⤤���ޤ��� ���ϥѥ�᡼���˳�꿶��줿̾����ñ�ʤ����ǤϤʤ���̵̾ʣ�緿����̾����ꤹ���ΤǤ��뤳�Ȥ����դ��Ƥ��������� �ʽ��ϥѥ�᡼����̾�����ά������硢�����ƥ༫�Ȥ�̾�������Ӥޤ�����

SQL���餳�������ؿ���ƤӽФ��������ϥѥ�᡼�����ƤӽФ�¦�ΰ����ꥹ�Ȥ˴ޤޤ�ʤ����Ȥ����դ��Ƥ��������� PostgreSQL�Ǥ����ϥѥ�᡼���Τߤ��ؿ��θƤӽФ������ͥ�����������Ȥߤʤ��Ƥ��뤿��Ǥ��� ����Ϥޤ����ؿ��������뤳�Ȥʤɤ���Ū�˴ؿ��򻲾Ȥ����硢���ϥѥ�᡼���Τߤ���θ����뤳�Ȥ��̣���Ƥ��ޤ��� ��δؿ��ϡ����Τ����줫����ˡ�Ǻ�����뤳�Ȥ��Ǥ��ޤ���

DROP FUNCTION sum_n_product (x int, y int, OUT sum int, OUT product int);
DROP FUNCTION sum_n_product (int, int);

�ѥ�᡼���ˤϡ�IN�ʥǥե���ȡˡ�OUT��INOUT���ޤ���VARIADIC�Ȥ���������Ϳ�Ǥ��ޤ��� INOUT�ѥ�᡼���ϡ����ϥѥ�᡼���ʸƤӽФ������ꥹ�Ȥΰ����ˤȽ��ϥѥ�᡼���ʷ�̤Υ쥳���ɷ��ΰ����ˤ�ξ�����󶡤��ޤ��� VARIADIC�ѥ�᡼�������ϥѥ�᡼���Ǥ��������˵��ܤ���褦�����̤˰����ޤ���

35.4.5. ����Ĺ��������SQL�ؿ�

���٤Ƥ�"���ץ�����"������Ʊ���ǡ������ξ�硢SQL�ؿ��ϲ���Ĺ�ΰ���������դ���褦������Ǥ��ޤ��� ���ץ����ΰ���������Ȥ��ƴؿ����Ϥ���ޤ��� ���δؿ��ϺǸ�Υѥ�᡼����VARIADIC�Ȱ����դ����������ޤ��� ���Υѥ�᡼�������󷿤Ǥ���Ȥ����������ʤ���Фʤ�ޤ��� ��򤢤��ޤ���

CREATE FUNCTION mleast(VARIADIC arr numeric[]) RETURNS numeric AS $$
    SELECT min($1[i]) FROM generate_subscripts($1, 1) g(i);
$$ LANGUAGE SQL;

SELECT mleast(10, -1, 5, 4.4);
 mleast 
--------
     -1
(1 row)

�ºݡ�VARIADIC�ΰ��ְʹߤμ°����Ϥ��٤ơ���������ʲ��Τ褦�˵��Ҥ������Τ褦�ˡ�1����������Ȥ��ƤޤȤ���ޤ���

SELECT mleast(ARRAY[10, -1, 5, 4.4]);    -- ư��ޤ���

���������ºݤˤ��Τ褦�˵��Ҥ��뤳�ȤϤǤ��ޤ��� ���ʤ��Ȥ⡢���δؿ�����˰��פ��ޤ��� VARIADIC�����դ����ѥ�᡼���ϡ����Ȥη��ǤϤʤ����������Ƿ������İʾ�¸�ߤ��뤳�Ȥ˰��פ��ޤ���

���Ȥ��ơ�variadic�ؿ��˴��˹��ۤ��줿������Ϥ��뤳�Ȥ�ͭ�ѤǤ��� ���Ĥ�variadic�ؿ��������Ȥ�����ѥ�᡼����¾�Τ�Τ��Ϥ������Ȥ��ä������Ǥ��� �ƤӽФ���VARIADIC����ꤹ�뤳�ȤǹԤ��ޤ���

SELECT mleast(VARIADIC ARRAY[10, -1, 5, 4.4]);

����ϴؿ���variadic�ѥ�᡼�����������Ƿ��˳�ĥ����Τ��ɤ��ޤ��� ���η�̡���������ͤ�ɸ��Ū�˥ޥå������褦�ˤʤ�ޤ��� VARIADIC�ϴؿ��ƤӽФ��κǸ�μ°����Ȥ��ƤΤ��ղäǤ��ޤ���

variadic�ѥ�᡼����������������������ǥѥ�᡼���ϡ����켫�ȤˤϤޤä���̾��������ʤ���ΤȤ��ư����ޤ��� ����ϡ�̾���դ�������項4.3�ˤ���Ѥ��Ʋ���Ĺ�δؿ���ƤӽФ����Ȥ��Ǥ��ʤ����Ȥ��̣���ޤ��� ��������VARIADIC����ꤹ������㳰�Ǥ��� ���Ȥ��С�

SELECT mleast(VARIADIC arr := ARRAY[10, -1, 5, 4.4]);

��ư��ޤ�����

SELECT mleast(arr := 10);
SELECT mleast(arr := ARRAY[10, -1, 5, 4.4]);

����ư��ޤ���

35.4.6. �����˥ǥե�����ͤ����SQL�ؿ�

�����ޤ��Ϥ��٤Ƥ����ϰ����˥ǥե�����ͤ���Ĵؿ���������뤳�Ȥ��Ǥ��ޤ��� �ǥե�����ͤϡ��ؿ����ºݤΰ����ο���­��ʤ����ΰ����ǸƤӽФ��줿������������ޤ��� �����ϼ°����ꥹ�Ȥν�ü�����ά���뤳�Ȥ��Ǥ��ޤ��Τǡ��ǥե�����ͤ���ĥѥ�᡼���θ�ˤ���ѥ�᡼���Ϥ��٤ơ�Ʊ�ͤ˥ǥե�����ͤ�����ʤ���Фʤ�ޤ��� ��̾���դ��ΰ�����ˡ����Ѥ��Ƥ������¤���¤����뤳�Ȥ�Ǥ��ޤ������ޤ����ְ�����ˡ������Ū��ư��Ǥ��뤳�Ȥ���������Ƥ��ޤ�����

�ʲ�����򼨤��ޤ���

CREATE FUNCTION foo(a int, b int DEFAULT 2, c int DEFAULT 3)
RETURNS int
LANGUAGE SQL
AS $$
    SELECT $1 + $2 + $3;
$$;

SELECT foo(10, 20, 30);
 foo 
-----
  60
(1 row)

SELECT foo(10, 20);
 foo 
-----
  33
(1 row)

SELECT foo(10);
 foo 
-----
  15
(1 row)

SELECT foo();  -- fails since there is no default for the first argument
ERROR:  function foo() does not exist

=�����DEFAULT������ɤ�����˻��Ѥ��뤳�Ȥ�Ǥ��ޤ���

35.4.7. �ơ��֥륽�����Ȥ��Ƥ�SQL�ؿ�

���Ƥ�SQL�ؿ����䤤��碌��FROM��ǻ��ѤǤ��ޤ�����ʣ�緿���֤��ؿ����ä������Ǥ��� �ؿ������ܷ����֤��褦�������Ƥ����硢�ơ��֥�ؿ���1�󤫤�ʤ�ơ��֥��������ޤ��� �ؿ���ʣ�緿���֤��褦�������Ƥ����硢�ơ��֥�ؿ���ʣ�緿����Τ��줾����Ф���1�Ĥ����������ޤ���

�ʲ�����򼨤��ޤ���

CREATE TABLE foo (fooid int, foosubid int, fooname text);
INSERT INTO foo VALUES (1, 1, 'Joe');
INSERT INTO foo VALUES (1, 2, 'Ed');
INSERT INTO foo VALUES (2, 1, 'Mary');

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

SELECT *, upper(fooname) FROM getfoo(1) AS t1;

 fooid | foosubid | fooname | upper
-------+----------+---------+-------
     1 |        1 | Joe     | JOE
(1 row)

�㤫��狼���̤ꡢ�ؿ��η�̤�����̾�Υơ��֥�����Ʊ���褦�˰������Ȥ��Ǥ��ޤ���

���δؿ��η������줿�Τ�1�ԤΤߤǤ��뤳�Ȥ����դ��Ƥ��������� �����SETOF����ꤷ�ʤ��ä�����Ǥ��� ����ˤĤ��Ƥϼ�����������ޤ���

35.4.8. ������֤�SQL�ؿ�

SQL�ؿ���SETOF sometype���֤��褦�������Ƥ����硢�ؿ��κǸ���䤤��碌�ϺǸ�ޤǼ¹Ԥ��졢�ƽ��ϹԤϷ�̽�������ǤȤ����֤���ޤ���

���ε�ǽ���̾�ؿ���FROM����ǸƤӽФ����˻��Ѥ���ޤ��� ���ξ�硢�ؿ��ˤ�ä��֤����ƹԤϡ��䤤��碌�ˤ�äƸ�����ơ��֥�ιԤˤʤ�ޤ��� �㤨�С��ơ��֥�foo�����Ƥ��嵭��Ʊ���Ǥ���аʲ��Τ褦�ˤʤ�ޤ���

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

SELECT * FROM getfoo(1) AS t1;

���ν��Ϥϰʲ����̤�Ǥ���

 fooid | foosubid | fooname
-------+----------+---------
     1 |        1 | Joe
     1 |        2 | Ed
(2 rows)

�ޤ����ʲ��Τ褦�˽��ϥѥ�᡼����������줿������ʣ���ιԤ��֤����Ȥ��ǽ�Ǥ���

CREATE TABLE tab (y int, z int);
INSERT INTO tab VALUES (1, 2), (3, 4), (5, 6), (7, 8);

CREATE FUNCTION sum_n_product_with_tab (x int, OUT sum int, OUT product int)
RETURNS SETOF record
AS $$
    SELECT $1 + tab.y, $1 * tab.y FROM tab;
$$ LANGUAGE SQL;

SELECT * FROM sum_n_product_with_tab(10);
 sum | product
-----+---------
  11 |      10
  13 |      30
  15 |      50
  17 |      70
(4 rows)

�����ǽ��פ����ϡ��ؿ���1�Ԥ����ǤϤʤ�ʣ���Ԥ��֤����Ȥ򼨤������RETURNS SETOF record�򵭽Ҥ��ʤ���Фʤ�ʤ����Ǥ��� ���ϥѥ�᡼�������Ĥ���¸�ߤ��ʤ����ϡ�record�ǤϤʤ������Υѥ�᡼���η��򵭽Ҥ��Ƥ���������

���ߡ�������֤��ؿ����䤤��碌������ꥹ����Ǥ�ƤӽФ����Ȥ��Ǥ��ޤ��� �䤤��碌���Ȥˤ�ä���������ƹԤ��Ф���������֤��ؿ����ƤӽФ��졢�ؿ��η�̽���γ����Ǥ��Ф��ƽ��ϹԤ���������ޤ��� �����������ε�ǽ�ϸ��ߤǤϿ侩����Ƥ��餺������Υ�꡼���ǤϺ��������ǽ��������ޤ��� �ʲ��ϡ�����ꥹ�Ȥ��齸����֤��ؿ�����Ǥ���

CREATE FUNCTION listchildren(text) RETURNS SETOF text AS $$
    SELECT name FROM nodes WHERE parent = $1
$$ LANGUAGE SQL;

SELECT * FROM nodes;
   name    | parent
-----------+--------
 Top       |
 Child1    | Top
 Child2    | Top
 Child3    | Top
 SubChild1 | Child1
 SubChild2 | Child1
(6 rows)

SELECT listchildren('Top');
 listchildren
--------------
 Child1
 Child2
 Child3
(3 rows)

SELECT name, listchildren(name) FROM nodes;
  name  | listchildren
--------+--------------
 Top    | Child1
 Top    | Child2
 Top    | Child3
 Child1 | SubChild1
 Child1 | SubChild2
(5 rows)

�Ǹ��SELECT�ˤ����ơ�Child2��Child3�ʤɤ����ϹԤ�ɽ������Ƥ��ʤ����Ȥ����դ��Ƥ��������� ����ϡ�listchildren���������Ϥ��Ф��ƶ��ν�����֤�������ϹԤ���������ʤ�����Ǥ���

注意: �⤷�ؿ��κǸ�Υ��ޥ�ɤ�RETURNING�����INSERT��UPDATE���ޤ���DELETE�Ǥ����硢�ؿ���SETOF�դ����������Ƥ��ʤ����ޤ��ϸƤӽФ��䤤��碌�����Ƥη�̹Ԥ���Ф��ʤ��Ƥ⡢���Υ��ޥ�ɤϴ�λ�ޤǼ¹Ԥ���ޤ��� RETURNING������������;�פʹԤϤ��٤Ʒٹ�̵���˺������ޤ��������ޥ���оݤΥơ��֥���ѹ��Ϥ���Ǥⵯ����ޤ��ʤ����ơ��ؿ�����������ˤ��٤ƴ�λ���ޤ��ˡ�

35.4.9. TABLE���֤�SQL�ؿ�

������֤���ΤȤ��ƴؿ����������ˤϡ�¾�ˤ���ˡ������ޤ��� RETURNS TABLE(columns)��ʸ����Ѥ��뤳�ȤǤ��� ����ϣ��İʾ��OUT�ѥ�᡼����Ȥ�������ˡ��ؿ���SETOF record�ʤޤ��ϡ�Ŭ�ڤʤ��ñ��ν��ϥѥ�᡼���η���SETOF�ˤ��֤���ΤȰ����դ��뤳�Ȥ������Ǥ��� ���ε�ˡ��ɸ��SQL�κǶ���Ǥǵ��ꤵ�줿��ΤǤ��Τǡ�SETOF����Ѥ�����ܿ��������⤤���⤷��ޤ���

�㤨�����Ҥι�פ��Ѥ���Ϥ��Τ褦�˽񤱤ޤ���

CREATE FUNCTION sum_n_product_with_tab (x int)
RETURNS TABLE(sum int, product int) AS $$
    SELECT $1 + tab.y, $1 * tab.y FROM tab;
$$ LANGUAGE SQL;

RETURNS TABLE��ˡ�Ȱ��ˡ�����ŪOUT�ޤ���INOUT�ѥ�᡼������Ѥ��뤳�ȤϤǤ��ޤ��� ���Ƥν������TABLE�ꥹ�Ȥ˴ޤ�ʤ���Фʤ�ޤ���

35.4.10. ¿��SQL�ؿ�

SQL�ؿ��ϡ�¿�ͷ�anyelement��anyarray��anynonarray�����anyenum������դ����֤��褦��������뤳�Ȥ��Ǥ��ޤ��� ¿�ʹؿ��ξܺ������ˤĤ��Ƥ�項35.2.5�򻲾Ȥ��Ƥ��������� �ʲ���make_array¿�ʹؿ��ϡ�Ǥ�դ�2�ĤΥǡ��������Ǥ��������������ޤ���

CREATE FUNCTION make_array(anyelement, anyelement) RETURNS anyarray AS $$
    SELECT ARRAY[$1, $2];
$$ LANGUAGE SQL;

SELECT make_array(1, 2) AS intarray, make_array('a'::text, 'b') AS textarray;
 intarray | textarray
----------+-----------
 {1,2}    | {a,b}
(1 row)

'a'::text�Ȥ��������㥹�Ȥ���Ѥ��ơ�������text���Ǥ��뤳�Ȥ���ꤷ�Ƥ��뤳�Ȥ����ܤ��Ƥ��������� ����ϰ�����ñ�ʤ�ʸ�����ƥ��Ǥ������ɬ�פǤ��� ����ʤ��ȡ�unknown���Ȥ��ư����Ƥ��ޤ����ᡢ̵����unknown��������֤����Ȥ��Ƥ��ޤ��ޤ��� �����㥹�Ȥ��ʤ��ȡ��ʲ��Τ褦�ʥ��顼��ȯ�����ޤ���

ERROR:  could not determine polymorphic type because input has type "unknown"

���������ͷ���¿�Ͱ�������Ĥ��Ȥϵ�����ޤ������դϵ�����ޤ��� �ʲ�����򼨤��ޤ���

CREATE FUNCTION is_greater(anyelement, anyelement) RETURNS boolean AS $$
    SELECT $1 > $2;
$$ LANGUAGE SQL;

SELECT is_greater(1, 2);
 is_greater
------------
 f
(1 row)

CREATE FUNCTION invalid_func() RETURNS anyelement AS $$
    SELECT 1;
$$ LANGUAGE SQL;
ERROR:  cannot determine result data type
DETAIL:  A function returning a polymorphic type must have at least one polymorphic argument.

���ϰ�������Ĵؿ��Ǥ�¿��������Ѥ��뤳�Ȥ��Ǥ��ޤ��� �ʲ�����򼨤��ޤ���

CREATE FUNCTION dup (f1 anyelement, OUT f2 anyelement, OUT f3 anyarray)
AS 'select $1, array[$1,$1]' LANGUAGE SQL;

SELECT * FROM dup(22);
 f2 |   f3
----+---------
 22 | {22,22}
(1 row)

¿������variadic�ؿ��ȤȤ�˻��ѤǤ��ޤ�����򤢤��ޤ���

CREATE FUNCTION anyleast (VARIADIC anyarray) RETURNS anyelement AS $$
    SELECT min($1[i]) FROM generate_subscripts($1, 1) g(i);
$$ LANGUAGE SQL;

SELECT anyleast(10, -1, 5, 4);
 anyleast 
----------
       -1
(1 row)

SELECT anyleast('abc'::text, 'def');
 anyleast 
----------
 abc
(1 row)

CREATE FUNCTION concat(text, VARIADIC anyarray) RETURNS text AS $$
    SELECT array_to_string($2, $1);
$$ LANGUAGE SQL;

SELECT concat('|', 1, 4, 2);
 concat 
--------
 1|4|2
(1 row)