¾�ΥС�������ʸ�� �� 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

34.4. �䤤��碌�����SQL�˴ؿ�

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

¾�ˤ⡢SQL�ؿ��ϡ�SETOF sometype�����֤��褦�˻��ꤹ�뤳�Ȥˤ�ꡢ������֤��褦��������뤳�Ȥ�Ǥ��ޤ��� ���ξ�硢�Ǹ���䤤��碌�η�̤����ƤιԤ��֤���ޤ��� �ܺ٤ϸ���������ޤ���

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

SQL����Ǻ������줿��Ǥ�դΥ��ޥ�ɷ��ϤޤȤ�ơ��ؿ��Ȥ���������뤳�Ȥ��Ǥ��ޤ��� SELECT�䤤��碌�ʳ��ˡ��ǡ����ѹ��Ѥ��䤤��碌�ʤĤޤꡢINSERT��UPDATE��DELETE�ˤ䤽��¾��SQL���ޥ�ɤ�ޤ�뤳�Ȥ��Ǥ��ޤ��� ���㳰��1�Ĥ���ޤ��������BEGIN��COMMIT��ROLLBACK��SAVEPOINT��SQL�ؿ��˴ޤ�뤳�ȤϤǤ��ʤ����Ǥ����� ���������Ǹ�Υ��ޥ�ɤϡ��ؿ�������ͷ������������Τ��֤�SELECT�Ǥʤ���Фʤ�ޤ��� ����¾�ˤ⡢����ư��򤵤��뤬��ͭ�Ѥ��ͤ��֤��ʤ�SQL�ؿ�������������ΤǤ���С�void���֤���Τ�������뤳�ȤǼ¸���ǽ�Ǥ��� ���ξ�硢�ؿ����Τ�SELECT�ǽ���äƤϤʤ�ޤ��� ���Ȥ��С��ʲ��δؿ���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.2�ˤ��Ǥ������Ǥ��� ʸ���������ñ�������dz���̾�ι�ʸ�Ǥϡ��ؿ�������ǻ��Ѥ����ñ��������'�ˤȥХå�����å����\�ˡʥ���������ʸ����ʸ����ˤ��̾�Ϥ���ʸ������Ťˤ��ʤ���Фʤ�ޤ����項4.1.2.1�򻲾ȡˡ�

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

INSERT INTO mytable VALUES ($1);

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

INSERT INTO $1 VALUES (42);

34.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;

����ϻĹ��Ĵ������������λĹ���֤��ޤ���

34.4.2. ʣ�緿����Ѥ���SQL�ؿ�

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

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

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���ܤ���ˡ�ˤĤ��Ƥϡ�項34.4.4�Ǥ��ܤ����������ޤ���

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

SELECT (new_emp()).name;

 name
------
 None

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

SELECT new_emp().name;
ERROR:  syntax error at or near "." at character 17
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)

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

34.4.3. ���ϥѥ�᡼������Ĵؿ�

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

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)

項34.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�Ȥ���������Ϳ�Ǥ��ޤ��� INOUT�ѥ�᡼���ϡ����ϥѥ�᡼���ʸƤӽФ������ꥹ�Ȥΰ����ˤȽ��ϥѥ�᡼���ʷ�̤Υ쥳���ɷ��ΰ���ʬ�ˤ�ξ�����󶡤��ޤ���

34.4.4. �ơ��֥륽�����Ȥ��Ƥ�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����ꤷ�ʤ��ä�����Ǥ��� ����ˤĤ��Ƥϼ�����������ޤ���

34.4.5. ������֤�SQL�ؿ�

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

���ε�ǽ���̾�ؿ���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 FUNCTION sum_n_product_with_tab (x int, OUT sum int, OUT product int) RETURNS SETOF record AS $$
    SELECT x + tab.y, x * tab.y FROM tab;
$$ LANGUAGE SQL;

�����ǽ��פ����ϡ��ؿ���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���������Ϥ��Ф��ƶ��ν�����֤�������ϹԤ���������ʤ�����Ǥ���

34.4.6. ¿��SQL�ؿ�

SQL�ؿ��ϡ�¿�ͷ�anyelement��anyarray��anynonarray�����anyenum������դ����֤��褦��������뤳�Ȥ��Ǥ��ޤ��� ¿�ʹؿ��ξܺ������ˤĤ��Ƥ�項34.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)