PostgreSQL 9.0.4ʸ�� | ||||
---|---|---|---|---|
前のページ | 巻戻し | 第 35章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);
�Ǥ��ñ��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;
�ؿ��ΰ�����ʣ�緿�Ҥ�����硢�ʤ���ޤǹԤäƤ���$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�Ĥν��פ���������ʲ��˼����ޤ���
�䤤��碌�ˤ���������ꥹ�Ȥν��֤ϡ�ʣ�緿�ȴ�Ϣ�����ơ��֥���Ǹ������ν��֤����Τ˰��פ���ɬ�פ�����ޤ� �ʾ�ǹԤä��褦�����̾�����դ��Ƥ⡢�����ƥ��ǧ�����ޤ���ˡ�
ʣ�緿����Ȱ��פ���褦�˼����㥹�Ȥ��ʤ���Фʤ�ޤ��� ����ʤ��С��ʲ��Τ褦�ʥ��顼�Ȥʤ�ޤ���
ERROR: function declared to return emp returns varchar instead of text at column 1
Ʊ���ؿ���ʲ��Τ褦��������뤳�Ȥ�Ǥ��ޤ���
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���������ޤ���
�ʲ�����Τ褦�ˡ��ؿ��Υѥ�����̾�����꿶�뤳�Ȥ��Ǥ��ޤ���
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���������ޤ������ؿ���¿���Υѥ�������ľ��Ϥޤ����ؿ���ƤӽФ�����̾������Ѥ��뤳�Ȥ�ͭ�ѤǤ���
�ؿ��η�̤ε�����ˡ�ˤϡ�¾�ˤ����ϥѥ�������Ѥ������������ˡ������ޤ��� �ʲ�������ޤ���
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�ѥ��������ϥѥ����Ǥ��������˵��ܤ���褦�����̤˰����ޤ���
���٤Ƥ�"���ץ�����"������Ʊ���ǡ������ξ�硢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]);
����ư��ޤ���
�����ޤ��Ϥ��٤Ƥ����ϰ����˥ǥե�����ͤ���Ĵؿ���������뤳�Ȥ��Ǥ��ޤ��� �ǥե�����ͤϡ��ؿ����ºݤΰ����ο�����ʤ����ΰ����ǸƤӽФ��줿������������ޤ��� �����ϼ°����ꥹ�Ȥν�ü�����ά���뤳�Ȥ��Ǥ��ޤ��Τǡ��ǥե�����ͤ���ĥѥ����θ�ˤ���ѥ����Ϥ��٤ơ�Ʊ�ͤ˥ǥե�����ͤ�����ʤ���Фʤ�ޤ��� ��̾���դ��ΰ�����ˡ����Ѥ��Ƥ������¤���¤����뤳�Ȥ�Ǥ��ޤ������ޤ����ְ�����ˡ������Ū��ư��Ǥ��뤳�Ȥ���������Ƥ��ޤ�����
�ʲ�������ޤ���
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������ɤ�����˻��Ѥ��뤳�Ȥ�Ǥ��ޤ���
���Ƥ�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����ꤷ�ʤ��ä�����Ǥ��� ����ˤĤ��Ƥϼ�����������ޤ���
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������������;�פʹԤϤ��٤Ʒٹ�̵���˺������ޤ��������ޥ���оݤΥơ��֥���ѹ��Ϥ���Ǥⵯ����ޤ��ʤ����ơ��ؿ�����������ˤ��٤ƴ�λ���ޤ��ˡ�
������֤���ΤȤ��ƴؿ����������ˤϡ�¾�ˤ���ˡ������ޤ��� 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�ꥹ�Ȥ˴ޤ�ʤ���Фʤ�ޤ���
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)