PostgreSQL 9.2.4ʸ�� | ||||
---|---|---|---|---|
前のページ | 上に戻る | 第 39章PL/pgSQL - SQL��³������ | 次のページ |
���湽¤�Ϥ����餯PL/pgSQL�κǤ�ͭ�ѡʤ��Ľ��סˤ���ʬ�Ǥ��� PL/pgSQL�����湽¤����Ѥ��ơ�PostgreSQL�Υǡ��������˽��𡢶��Ϥ����뤳�Ȥ��Ǥ��ޤ���
�ؿ�����ǡ������֤�����˻��ѤǤ��륳�ޥ�ɤ�2�Ĥ���ޤ��� RETURN�����RETURN NEXT�Ǥ���
RETURN expression;
�������RETURN�ϴؿ���λ����expression���ͤ�ƤӽФ������֤��ޤ��� ���η����Ͻ�����֤��ʤ�PL/pgSQL�ؿ��ǻ��Ѥ���ޤ���
�����鷿���֤�����Ǥ�դμ�����Ѥ��뤳�Ȥ��Ǥ��ޤ��� ���μ��η�̤ϡ������ΤȤ��������������褦�ˡ���ưŪ�˴ؿ�������ͤη��˥��㥹�Ȥ���ޤ��� ʣ��ʹԡ��ͤ��֤�����ˤϡ�expression�Ȥ��ƥ쥳���ɤ⤷���Ϲ��ѿ��Ҥ��ʤ���Фʤ�ޤ���
���ϥѥ�������ä��ؿ�������������ϡ�����̵��RETURN�Ҥ��Ƥ��������� ���λ����ˤ�������ϥѥ������ͤ��֤���ޤ���
void���֤��褦�˴ؿ�������������Ǥ⡢�ؿ���ľ����ȴ���Ф������RETURN����ѤǤ��ޤ�����RETURN�θ�˼��Ҥ��ʤ��Ǥ���������
�ؿ�������ͤ�̤����Ȥ������ޤޤˤ��뤳�ȤϤǤ��ޤ��� ���椬��RETURNʸ�����Ĥ���ʤ����֤Ǵؿ��κǾ�̤Υ֥��å��ν����ޤ�ã���������¹Ի����顼��ȯ�����ޤ��� ���������������¤Ͻ��ϥѥ�������ä��ؿ��ڤ�void���֤��ؿ��ˤ����ƤϤޤ�ޤ��� ���Τ褦�ʾ��ϺǾ�̤Υ֥��å�������ä�����RETURNʸ����ưŪ�˼¹Ԥ���ޤ���
RETURN NEXT expression;
RETURN QUERY query;
RETURN QUERY EXECUTE command-string [ USING expression [, ... ] ];
PL/pgSQL�ؿ���SETOF sometype���֤��褦�����������硢��³�ν�����¿���㤤�ޤ��� ���ξ�硢����ͤθġ��ι��ܤϡ�RETURN NEXT���ޥ�ɤޤ���RETURN QUERY���ޥ�ɤǻ��ꤵ��ޤ��� �����ơ������Τʤ��Ǹ��RETURN���ޥ�ɤˤ�ꡢ�ؿ����¹Ԥ�λ�������Ȥ�������ޤ��� RETURN NEXT�ϡ������鷿�����ʣ�緿��ξ���ǻ��Ѥ��뤳�Ȥ��Ǥ��ޤ��� ʣ�緿�ξ�硢��̤�"�ơ��֥�"���Τ��֤���ޤ��� RETURN QUERY�ϡ��䤤��碌��¹Ԥ�����̤�ؿ��η�̽�����ɲä��ޤ��� RETURN NEXT��RETURN QUERY�ϡ�ñ��ν�����֤��ؿ�����Ǽ�ͳ�˺���Ǥ��ޤ��� ���ξ�硢Ϣ�뤵�줿��Τ���̤Ȥʤ�ޤ���
�ºݤˤϡ�RETURN NEXT�����RETURN QUERY�ϴؿ��������ޤ��� ñ�˴ؿ��η�̽���˹Ԥ��ɲä��Ƥ�������Ǥ��� �����ơ����μ¹Ԥ�PL/pgSQL�ؿ���μ���ʸ�˷�³���ޤ��� RETURN NEXT�ޤ���RETURN QUERY���ޥ�ɤ�Ϣ³���Ƽ¹Ԥ����ȡ���̽��礬��������ޤ��� �Ǹ�Ρ���������äƤϤʤ�ʤ�RETURN�ˤ�ꡢ�ؿ��ν�λ�����椷�ޤ� (�ޤ��������ؿ��κǸ�˰ܤ����Ȥ��Ǥ��ޤ�)��
RETURN QUERY�ˤ�RETURN QUERY EXECUTE�Ȥ������郎���ꡢ������䤤��碌��ưŪ�˼¹Ԥ���뤳�Ȥ���ꤷ�ޤ��� �ѥ�������EXECUTE���ޥ���������Ʊ���褦�ˡ�USING�ˤ�äƱ黻���줿�䤤��碌ʸ������������뤳�Ȥ��Ǥ��ޤ���
���ϥѥ�������Ĵؿ�������������ϡ�����̵��RETURN NEXT�����Ҥ��Ƥ��������� �¹Ԥ��٤ˡ����λ����ˤ�������ϥѥ������ͤ����ؿ����������ͤΤ���˷�̤ιԤȤ�����¸����ޤ��� ���ϥѥ�������Ľ�����֤��ؿ���������뤿��ˤϡ����ϥѥ�����ʣ���λ���SETOF record���֤��褦�˴ؿ����������ñ���sometype���ν��ϥѥ����λ���SETOF sometype���֤��褦�˴ؿ���������ʤ���Фʤ�ʤ����Ȥ����դ��Ƥ���������
RETURN NEXT����Ѥ���ؿ������ʲ��˼����ޤ���
CREATE TABLE foo (fooid INT, foosubid INT, fooname TEXT); INSERT INTO foo VALUES (1, 2, 'three'); INSERT INTO foo VALUES (4, 5, 'six'); CREATE OR REPLACE FUNCTION getAllFoo() RETURNS SETOF foo AS $BODY$ DECLARE r foo%rowtype; BEGIN FOR r IN SELECT * FROM foo WHERE fooid > 0 LOOP -- can do some processing here RETURN NEXT r; -- return current row of SELECT END LOOP; RETURN; END $BODY$ LANGUAGE 'plpgsql' ; SELECT * FROM getallfoo();
注意: �嵭�Τ褦�ˡ�RETURN NEXT�����RETURN QUERY�θ��ߤμ����Ǥϡ��ؿ������֤�������˷�̽������Τ��ݴɤ��ޤ��� ����ˤ�ꡢPL/pgSQL�ؿ����������̤η�̽�����֤�����硢��ǽ���㲼�����ǽ��������ޤ��� ����θϳ���뤿�ᡢ�ǡ����ϥǥ������˽��ޤ�ޤ��� ���������ؿ����ΤϷ�̽������Τ����������ޤǤ����ޤ��� �����PL/pgSQL�ΥС������Ǥϡ��������¤�������˽�����֤��ؿ���桼��������Ǥ���褦�ˤʤ뤫�⤷��ޤ��� ���ߡ��ǡ������ǥ������˽��ޤ�Ϥޤ������work_mem�����ѿ��ˤ�ä����椵��Ƥ��ޤ��� ���̤η�̽�����ݴɤ���Τ˽�ʬ�ʥ��꤬�����硢�����ԤϤ��Υѥ������ͤ��礭�����뤳�Ȥ��θ���٤��Ǥ���
IF��CASEʸ�Ϥ�����˴�Ť�������Υ��ޥ�ɤ�¹Ԥ����ޤ��� PL/pgSQL�ˤϡ��ʲ��Τ褦�ʣ��Ĥ�IF�η���������ޤ���
IF ... THEN
IF ... THEN ... ELSE
IF ... THEN ... ELSE IF
IF ... THEN ... ELSIF ... THEN ... ELSE
�ޤ����ʲ��Τ褦�ʣ��Ĥ�CASE�η���������ޤ���
CASE ... WHEN ... THEN ... ELSE ... END CASE
CASE WHEN ... THEN ... ELSE ... END CASE
IF boolean-expression THEN statements END IF;
IF-THENʸ�ϺǤ�ñ���IF�η����Ǥ��� THEN��END IF�δ֤�ʸ����郎���ξ��˼¹Ԥ���ޤ��� ����ʤ���Ф��������Ф���ޤ���
�㡧
IF v_user_id <> 0 THEN UPDATE users SET email = v_email WHERE user_id = v_user_id; END IF;
IF boolean-expression THEN statements ELSE statements END IF;
IF-THEN-ELSEʸ��IF-THEN�˲ä������ɾ�������ξ��˼¹Ԥ��٤����ؤȤʤ�ʸ�ν������ꤹ�뤳�Ȥ��Ǥ��ޤ��� �ʤ���ˤϾ�郎NULL��ɾ����������ޤޤ�뤳�Ȥ����դ��Ƥ�����������
�㡧
IF parentid IS NULL OR parentid = '' THEN RETURN fullname; ELSE RETURN hp_true_filename(parentid) || '/' || fullname; END IF;
IF v_count > 0 THEN INSERT INTO users_count (count) VALUES (v_count); RETURN 't'; ELSE RETURN 'f'; END IF;
IF boolean-expression THEN statements [ ELSIF boolean-expression THEN statements [ ELSIF boolean-expression THEN statements ...]] [ ELSE statements ] END IF;
����褬���Ĥ����ǤϤʤ����¿���ˤʤ��礬����ޤ��� IF-THEN-ELSIF�ϡ����֤�ʣ�������ؼ��ʤ����롢�����������ˡ�����ޤ��� IF���Ϻǽ�ο��Ǥ����̤����Ĥ���ޤ�Ϣ³���Ƹ�������ޤ��� �����ƴ�Ϣ����ʸ���¹Ԥ��졢���θ�END IF�ʹߤμ���ʸ�����椬�Ϥ���ޤ��� �ʰʹߤˤ���IF���θ����Ϥ��٤Ƽ¹�����ޤ������� ���Ƥ�IF��郎���Ǥʤ���硢ELSE�֥��å����ʤ⤷¸�ߤ���С˼¹Ԥ���ޤ��� ��ǽŪ�ˤϡ�IF-THEN-ELSE-IF-THEN���ޥ�ɤ�����Ҥˤ�����Τ�Ʊ���Ǥ�����ɬ�פ�END IF��1�Ĥ����Ǥ���
�ʲ�������ޤ���
IF number = 0 THEN result := 'zero'; ELSIF number > 0 THEN result := 'positive'; ELSIF number < 0 THEN result := 'negative'; ELSE -- �դ��ࡢ�Ĥ�ͣ��β�ǽ���Ϥ����ͤ�NULL�Ǥ��뤳�Ȥ� result := 'NULL'; END IF;
ELSIF������ɤ�ELSEIF�Τ褦�˽��Ȥ��Ǥ��ޤ���
Ʊ����Ȥ��Ԥ����̤���ˡ�ϡ��ʲ�����Τ褦��IF-THEN-ELSEʸ������Ҥˤ��뤳�ȤǤ���
IF demo_row.sex = 'm' THEN pretty_sex := 'man'; ELSE IF demo_row.sex = 'f' THEN pretty_sex := 'woman'; END IF; END IF;
��������������ˡ�Ϥ��줾���IF���б�����END IF�ε��Ҥ�ɬ�פǤ��� ���äơ�¿��������褬������ELSIF����Ѥ���������Ǥ���
CASE search-expression WHEN expression [, expression [ ... ]] THEN statements [ WHEN expression [, expression [ ... ]] THEN statements ... ] [ ELSE statements ] END CASE;
CASE��ñ��ʷ����ϥ��ڥ��ɤ��������ˤ�ȤŤ����Ū�¹Ԥ����ޤ��� search-expression�ϡʰ��٤�����ɾ�����졢���θ�WHEN����Τ��줾���expression����Ӥ���ޤ��� ���פ����Τ����Ĥ���ȡ���Ϣ����statements���¹Ԥ��졢END CASE�μ���ʸ�����椬�Ϥ���ޤ��� �ʰʹߤΤ�WHEN����ɾ������ޤ��� ���פ����Τ����Ĥ���ʤ���硢ELSE statements���¹Ԥ���ޤ�����ELSE��̵���Ȥ���CASE_NOT_FOUND�㳰������������ޤ���
�ʲ��ϴ�ñ����Ǥ���
CASE x WHEN 1, 2 THEN msg := 'one or two'; ELSE msg := 'other value than one or two'; END CASE;
CASE WHEN boolean-expression THEN statements [ WHEN boolean-expression THEN statements ... ] [ ELSE statements ] END CASE;
CASE�θ������줿�����������ͼ��ο��η�̤˴�Ť�����դ��¹Ԥ����ޤ��� ���줾���WHEN���boolean-expression��true�Ȥʤ룱�Ĥ����Ĥ���ޤǽ��֤�ɾ������ޤ��� ���θ塢��Ϣ����statements���¹Ԥ��졢���η��END CASE�μ���ʸ�����椬�Ϥ���ޤ��� �ʰʹߤ�WHEN����ɾ������ޤ��� ���Ȥʤ��̤����Ĥ���ʤ���硢ELSE statements���¹Ԥ���ޤ�����ELSE��¸�ߤ��ʤ��Ȥ���CASE_NOT_FOUND�㳰������������ޤ���
�ʲ��ϴ�ñ����Ǥ���
CASE WHEN x BETWEEN 0 AND 10 THEN msg := 'value is between zero and ten'; WHEN x BETWEEN 11 AND 20 THEN msg := 'value is between eleven and twenty'; END CASE;
���η�����CASE�ϡ�Ƚ���ब��ά���줿ELSE���ã�������˲��⤷�ʤ��ΤǤϤʤ����顼�ʤ����������IF-THEN-ELSIF������Ʊ��Ǥ���
LOOP��EXIT��CONTINUE��WHILE��FOR��FOREACHʸ����Ѥ��ơ�PL/pgSQL�ؿ��ǡ���Ϣ�Υ��ޥ�ɤ��֤����Ȥ��Ǥ��ޤ���
[ <<label>> ] LOOP statements END LOOP [ label ];
LOOP�ϡ�EXITʸ�ޤ���RETURNʸ�ˤ�äƽ�λ�����ޤ�̵�¤˷����֤���롢���ʤ��Υ롼�פ�������ޤ��� ��ά��ǽ��label�ϡ�����Ҿ��ˤʤä��롼�פˤ�����EXIT�����CONTINUEʸ���ɤΥ�٥������ҤȤ��뤫����ꤹ�뤿��˻��Ѥ���ޤ���
EXIT [ label ] [ WHEN boolean-expression ];
label�����ꤵ��ʤ���硢�Ǥ���¦�Υ롼�פ�餻��END LOOP�μ���ʸ�����θ�˼¹Ԥ���ޤ��� label�����ꤵ�줿��硢����ϸ��ߤޤ��Ϥ��ξ�̤�����Ҥˤʤä��롼�פ�֥��å��Υ�٥�Ǥ���ɬ�פ�����ޤ��� ���θ塢��̾���줿�롼�פޤ��ϥ֥��å���餻�����Υ롼�פޤ��ϥ֥��å����б�����END�μ���ʸ�������ܤ��ޤ���
WHEN�����ꤵ�줿��硢boolean-expression�����ξ��Τߥ롼�פν�λ��������ޤ��� ����ʤ���С�EXIT�θ�ιԤ����椬�ܤ�ޤ���
EXIT�ϡ����٤Ƥμ���Υ롼�פȶ��˻��ѤǤ��ޤ��� ���ʤ��Υ롼�פǤλ��Ѥ˸��ꤵ��ޤ���
BEGIN�֥��å��ȶ��˻��Ѥ�������EXIT�ˤ��֥��å��μ���ʸ�����椬�ܤ�ޤ��� ������Ū�Τ���˥�٥뤬���Ѥ���ʤ���Фʤ�ʤ����Ȥ����դ��Ƥ��������� ��٥�̵����EXIT��BEGIN�֥��å����б�����ȤϷ褷�ƹͤ����ޤ��� �ʤ���ϡ���٥�̵����EXIT��BEGIN�֥��å����б����뤳�Ȥ���Ƥ���PostgreSQL��8.4������Υ���������ѹ��Ǥ�����
�㡧
LOOP -- ���餫�α黻 IF count > 0 THEN EXIT; -- �롼�פ�ȴ���Ф� END IF; END LOOP; LOOP -- ���餫�α黻 EXIT WHEN count > 0; -- �����Ʊ����� END LOOP; <<ablock>> BEGIN -- ���餫�α黻 IF stocks > 100000 THEN EXIT ablock; -- ����ˤ��BEGIN�֥��å���ȴ���Ф� END IF; -- stokcs > 100000 �Ǥ���Ф����Ǥα黻�Ͼ�ά END;
CONTINUE [ label ] [ WHEN boolean-expression ];
label��̵����硢������¦�Υ롼�פμ��η����֤������Ϥ���ޤ��� ���ʤ�����롼�����ΤλĤ��ʸ�����Ф���ơ�¾�Υ롼�פη����֤���ɬ�פ��ɤ�������뤿�ᡢ���椬�롼�����漰(�⤷¸�ߤ����)�����ޤ��� label��¸�ߤ����硢�¹Ԥ��³����롼�פΥ�٥����ꤷ�ޤ���
WHEN�����ꤵ�줿��硢boolean-expression�����ξ��Τߥ롼�פˤ����뼡�η����֤����Ϥޤ�ޤ��� ����ʤ���С�CONTINUE�θ�ιԤ����椬�ܤ�ޤ���
CONTINUE�����Ƥμ���Υ롼�פǻ��Ѳ�ǽ�Ǥ��� ���ʤ��Υ롼�פ˸��ꤵ��ޤ���
��
LOOP -- ���餫�α黻 EXIT WHEN count > 100; CONTINUE WHEN count < 50; -- 50����100������롢���餫�α黻 END LOOP;
[ <<label>> ] WHILE boolean-expression LOOP statements END LOOP [ label ];
WHILEʸ��boolean-expression��ɾ�������Ǥ���֡���Ϣ��ʸ���֤��ޤ��� ��P�ϡ��롼�����Τ��������ˤΤ߸�������ޤ���
�ʲ�������ޤ���
WHILE amount_owed > 0 AND gift_certificate_balance > 0 LOOP -- �����DZ黻���Ĥ��Ԥ��ޤ��� END LOOP; WHILE NOT done LOOP -- �����DZ黻���Ĥ��Ԥ��ޤ��� END LOOP;
[ <<label>> ] FOR name IN [ REVERSE ] expression .. expression [ BY expression ] LOOP statements END LOOP [ label ];
���η�����FOR�������ͤ��ϰ���Ƿ����֤��롼�פ��������ޤ��� name�ѿ���integer���Ȥ��Ƽ�ưŪ��������졢�롼�������Τߤ�¸�ߤ��ޤ� �ʥ롼�׳�����������Ƥ⡢�롼�������Ǥ�����̵�뤵��ޤ��ˡ� �ϰϤβ��¡���¤Ȥ���Ϳ������2�Ĥμ��ϥ롼�פ����ä����˰��٤���ɾ������ޤ��� BY�����ꤷ�ʤ����η����֤���ߤ�1�Ǥ�����BY����Ѥ��ƻ���Ǥ����롼�פ����ä����˰��٤���ɾ������ޤ��� REVERSE�����ꤵ�줿��硢�����֤���ߤ��ͤϲû������ΤǤϤʤ��������֤����Ȥ˸�������ޤ���
����FOR�롼�פ����ʲ��˼����ޤ���
FOR i IN 1..10 LOOP -- i �ϥ롼����� 1��2��3��4��5��6��7��8��9��10 ���ͤ���ޤ��� END LOOP; FOR i IN REVERSE 10..1 LOOP -- i �ϥ롼����� 10��9��8��7��6��5��4��3��2��1 ���ͤ���ޤ��� END LOOP; FOR i IN REVERSE 10..1 BY 2 LOOP -- i �ϥ롼����� 10��8��6��4��2 ���ͤ���ޤ��� END LOOP;
���¤���¤����礭����REVERSE�ξ��Ϥ�꾮�����˾�硢�롼�����ΤϤޤä����¹Ԥ���ޤ��� ���顼��ȯ�����ޤ���
label��FOR�롼�פ��ղä��뤳�Ȥˤ�ꡢlabel���Ѥ��ƽ�������̾���������롼���ѿ��ȤǤ��ޤ���
�̤μ����FOR�롼�פ���Ѥ��ơ��䤤��碌�η�̤��֤������Υǡ��������Ȥ��Ǥ��ޤ��� �ʲ��˹�ʸ���ޤ���
[ <<label>> ] FOR target IN query LOOP statements END LOOP [ label ];
target�ϡ��쥳�����ѿ������ѿ��ޤ��ϥ���ޤǶ��ڤä��������ѿ��Υꥹ�ȤǤ��� target�ˤϽ缡��query�η�̤����ƤιԤ��������졢�ƹԤ��Ф��ƥ롼�����Τ��¹Ԥ���ޤ��� �ʲ�������ޤ���
CREATE FUNCTION cs_refresh_mviews() RETURNS integer AS $$ DECLARE mviews RECORD; BEGIN RAISE NOTICE 'Refreshing materialized views...'; FOR mviews IN SELECT * FROM cs_materialized_views ORDER BY sort_key LOOP -- ������"mviews"��cs_materialized_views��1�ĤΥ쥳���ɤ�����ޤ� RAISE NOTICE 'Refreshing materialized view %s ...', quote_ident(mviews.mv_name); EXECUTE 'TRUNCATE TABLE ' || quote_ident(mviews.mv_name); EXECUTE 'INSERT INTO ' || quote_ident(mviews.mv_name) || ' ' || mviews.mv_query; END LOOP; RAISE NOTICE 'Done refreshing materialized views.'; RETURN 1; END; $$ LANGUAGE plpgsql;
���Υ롼�פ�EXITʸ�ǽ�λ������硢�Ǹ�˳�����Ƥ�줿�Ԥ��ͤϥ롼�פ�ȴ������Ǥ⥢���������뤳�Ȥ��Ǥ��ޤ���
���μ����FORʸ��query�Ȥ��Ƥϡ��ƤӽФ����˹Ԥ��֤�SQL���ޥ�ɤ٤ƻ��ѤǤ��ޤ��� �̾��SELECT�Ǥ�����RETURNING������INSERT��UPDATE�ޤ���DELETE����ѤǤ��ޤ��� EXPLAIN�ʤɤΥ桼�ƥ���ƥ����ޥ�ɤ��ư���ޤ���
PL/pgSQL�ѿ����䤤��碌�ƥ����Ȥ��֤��������ޤ��� �䤤��碌�ײ�ϡ�項39.10.1�����項39.10.2�ǽҤ٤��褦�ˡ������ѤΤ���˥���å��夵��ޤ���
FOR-IN-EXECUTEʸ�ϹԤ��֤��⤦1�Ĥ���ˡ�Ǥ���
[ <<label>> ] FOR target IN EXECUTE text_expression [ USING expression [, ... ] ] LOOP statements END LOOP [ label ];
������ˡ�ϡ��䤤��碌�Υ�������ʸ���ǻ��ꤵ���������������η����Ȼ��Ƥ��ޤ��� ���μ���FOR�롼�פγƹ��ܤ�ɾ�����졢�Ʒײ褬�Ԥ��ޤ��� ����ˤ�ꡢ�ץ�����ޤϡ��̾��EXECUTEʸ��Ʊ���褦�˻����˷ײ褵�줿�䤤��碌�ˤ���®���ȡ�ưŪ���䤤��碌�λ��Ľ����������뤳�Ȥ��Ǥ��ޤ��� EXECUTE�ξ���Ʊ�͡��ѥ����ͤ�USING�ˤ��ưŪ���ޥ�ɤ������Ǥ��ޤ���
��̤��̤��Ʒ����֤��ʤ���Фʤ�ʤ��䤤��碌����ꤹ��⤦���Ĥ���ˡ�Ȥ��ơ�������������������ޤ��� �����項39.7.4���������ޤ���
FOREACH�롼�פ�FOR�롼�פˤȤƤ�褯���Ƥ��ޤ��� ��������SQL �䤤��碌����Ф����Ԥ��֤�����ˡ���������Ǥ��֤��ޤ��� �ʰ���Ū��FOREACH�ϡ�ʣ���ͤ�ɽ������빽�����Ǥν����̣���ޤ���������Ǥʤ�ʣ���ͤ��밡�郎������ɲä���뤫�⤷��ޤ��� �������FOREACHʸ���ޤ���
[ <<label>> ] FOREACH target [ SLICE number ] IN ARRAY expression LOOP statements END LOOP [ label ];
SLICE���ʤ����ޤ���SLICE 0�����ꤵ�줿��硢�롼�פ�expression�ˤ�ä�ɾ������ƺ������줿����γ����Ǥ��֤��ޤ��� target�ѿ��������Ǥ��ͤ˽缡������Ƥ�졢�����Ǥ��Ф��ƥ롼�����Τ��¹Ԥ���ޤ��� ������������Ǥ�������ޤ���
CREATE FUNCTION sum(int[]) RETURNS int8 AS $$ DECLARE s int8 := 0; x int; BEGIN FOREACH x IN ARRAY $1 LOOP s := s + x; END LOOP; RETURN s; END; $$ LANGUAGE plpgsql;
����μ������˴ط��ʤ������Ǥϳ�Ǽ�������֤ǽ�������ޤ��� �̾�target��ñ����ѿ��Ǥ�����ʣ���͡ʥ쥳���ɡˤ��������Ȥ��ϡ��ѿ��Υꥹ�Ȥ��ǽ�Ǥ��� ���ξ�硢����γ����Ǥ��Ф��ơ��ѿ���ʣ���͡ʥ쥳���ɡˤ���Ϣ³Ū�˳�����Ƥ��ޤ���
����SLICE�ͤ���ľ�硢FOREACH��ñ������ǤǤϤʤ�¿����������㼡����ʬ������̤��Ʒ����֤��ޤ��� SLICE�ͤϡ�����μ�������꾮������������Ǥʤ���Фʤ�ޤ��� target�ѿ�������Ǥʤ���Фʤ�ޤ��� �����ѿ��ϡ������ͤ���Ϣ³������ʬ���������Ȥ�ޤ� ��������ʬ�����SLICE�ǻ��ꤷ�������Ȥʤ�ޤ��� �ʲ���1��������ʬ������̤��������֤�������ޤ���
CREATE FUNCTION scan_rows(int[]) RETURNS void AS $$ DECLARE x int[]; BEGIN FOREACH x SLICE 1 IN ARRAY $1 LOOP RAISE NOTICE 'row = %', x; END LOOP; END; $$ LANGUAGE plpgsql; SELECT scan_rows(ARRAY[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]); NOTICE: row = {1,2,3} NOTICE: row = {4,5,6} NOTICE: row = {7,8,9} NOTICE: row = {10,11,12}
�ǥե���ȤǤϡ�PL/pgSQL�ؿ���������ȯ���������顼�ϴؿ��μ¹Ԥ���ߤ����ºݤ˾�̤Υȥ�������ܡ��Ȥ��ޤ��� BEGIN�֥��å������EXCEPTION�����Ѥ���С����顼����ª���Ƥ��ξ��֤�������Ǥ��ޤ��� ���ι�ʸ���̾��BEGIN�֥��å��ι�ʸ���ĥ������ΤǤ���
[ <<label>> ] [ DECLARE declarations ] BEGIN statements EXCEPTION WHEN condition [ OR condition ... ] THEN handler_statements [ WHEN condition [ OR condition ... ] THEN handler_statements ... ] END;
���顼��ȯ�����ʤ��������η����Υ֥��å���ñ�����Ƥ�statements��¹Ԥ���END�μ���ʸ�����椬�ܤ�ޤ��� ��������statements�������ǥ��顼��ȯ������ȡ�����ʸ��statements�ν��������Ǥ��졢EXCEPTION�ꥹ�Ȥ����椬�ܤ�ޤ��� �����ƥꥹ�Ȥ��椫�顢ȯ���������顼�ȹ��פ���ǽ��condition��õ���ޤ��� ���פ����Τ�����С��б�����handler_statements��¹Ԥ���END�μ���ʸ�����椬�ܤ�ޤ��� ���פ����Τ��ʤ���С�EXCEPTION�礬¸�ߤ��ʤ��Τ�Ʊ���ǡ����顼�ϳ�¦�����Ť��ޤ��� EXCEPTION��ޤ����¦�Υ֥��å��ϥ��顼����ª�Ǥ��ޤ��������Ԥ���ȴؿ��ν��������Ǥ���ޤ���
���Ƥ�condition��̾����付録A�˼�������ΤΤ����줫���뤳�Ȥ��Ǥ��ޤ��� ʬ��̾�Ϥ�����ʬ�व������ƤΥ��顼�˹��פ��ޤ��� OTHERS�Ȥ������̤ξ���̾��QUERY_CANCELED�ʳ������ƤΥ��顼�˹��פ��ޤ��� ��QUERY_CANCELED��̾������ª���뤳�Ȥϲ�ǽ�Ǥ����������ǤϤ���ޤ��� ����̾����ʸ����ʸ������̤��ޤ��� Ʊ���ˡ����顼���֤�SQLSTATE�����ɤǻ����ǽ�Ǥ��� �㤨�аʲ��������Ǥ���
WHEN division_by_zero THEN ... WHEN SQLSTATE '22012' THEN ...
���顼����������handler_statements�����ǿ�����ȯ����������EXCEPTION��Ϥ��Υ��顼����ª�Ǥ������顼�ϳ�¦�����Ť��ޤ��� �ʤ�����̤�EXCEPTION��Ϥ��Υ��顼����ª�Ǥ��ޤ���
EXCEPTION�礬���顼����ª��������PL/pgSQL�ؿ��Υ��������ѿ��ϥ��顼�������ä���ξ��֤��ݤ��ޤ��� ���������֥��å������ˤ������³Ū�ʥǡ����١����ξ��֤ϡ�������Хå�����ޤ��� ���Τ褦�����ʲ��˼����ޤ���
INSERT INTO mytab(firstname, lastname) VALUES('Tom', 'Jones'); BEGIN UPDATE mytab SET firstname = 'Joe' WHERE lastname = 'Jones'; x := x + 1; y := x / 0; EXCEPTION WHEN division_by_zero THEN RAISE NOTICE 'caught division_by_zero'; RETURN x; END;
���椬�ѿ�y�������˰ܤ�ȡ�division_by_zero���顼�ȤʤꡢEXCEPTION�礬���Υ��顼����ª���ޤ��� RETURNʸ�ˤ��ؿ�������ͤϡ�1��û��������x���ͤȤʤ�ޤ�����UPDATE���ޥ�ɤˤ���̤ϥ�����Хå�����ޤ��� �����������Υ֥��å���INSERT���ޥ�ɤϥ�����Хå�����ޤ��� �������äơ��ǡ����١��������Ƥκǽ���̤�Tom Jones�Ǥ��ꡢJoe Jones�ǤϤ���ޤ���
ティップ: EXCEPTION���ޤ���֥��å��μ¹Ԥ��פ�����֤ϡ��ޤޤʤ��֥��å�����٤ƤȤƤ�Ĺ���ʤ�ޤ��� �������äơ�ɬ�פΤʤ�����EXCEPTION����Ѥ��ƤϤ����ޤ���
例 39-2. UPDATE/INSERT���㳰
�����UPDATE�ޤ���INSERT�μ¹Ԥˤ������㳰��������Ѥ���Ŭ��������Ǥ���
CREATE TABLE db (a INT PRIMARY KEY, b TEXT); CREATE FUNCTION merge_db(key INT, data TEXT) RETURNS VOID AS $$ BEGIN LOOP -- �ǽ�˥��������� UPDATE db SET b = data WHERE a = key; IF found THEN RETURN; END IF; -- ������¸�ߤ��ʤ��Τǡ��������������Ԥ��� -- ¾�Ԥ����Ǥ�Ʊ��Υ������������Ƥ����ʤ�� -- ������˰�ȿ�����٤Ȥʤ�ޤ� BEGIN INSERT INTO db(a,b) VALUES (key, data); RETURN; EXCEPTION WHEN unique_violation THEN -- ���⤷�ʤ��ǡ�������ƻ�Ԥ��ޤ� END; END LOOP; END; $$ LANGUAGE plpgsql; SELECT merge_db(1, 'david'); SELECT merge_db(1, 'dennis');
���Υ����ǥ��Ǥ�unique_violation���顼�θ�����INSERT�ˤ���ΤǤ��ꡢ�ơ��֥�Υȥꥬ�ؿ�������INSERT�ˤ���ΤǤʤ��Ȳ��ꤷ�ޤ��� �ޤ����ơ��֥��2�İʾ�ΰ�ե���ǥå�����¸�ߤ�����硢�ɤ���Υ���ǥå��������顼�θ����ˤʤ���������ƻ�Ԥ���Τǡ�����ư�Ȥʤ�ޤ��� ��ª�������顼��ͽ¬������ΤǤ��뤫���ڤ��뤿��ˡ�����ǵ��Ҥ��륨�顼��������Ѥ���С��������Ȥʤ�ޤ���
�㳰�ϥ�ɥ�Ϥ��Ф��С������ä�����Υ��顼���̤���ɬ�פ�����ޤ��� ���ߤ��㳰�˴ؤ����������������ˡ��2�Ĥ���ޤ��� �ü���ѿ���GET STACKED DIAGNOSTICS���ޥ�ɤǤ���
�㳰�ϥ�ɥ�������Ǥϡ��ü���ѿ�SQLSTATE�ѿ��������ä��㳰���б��������顼�����ɡ�表A-1�Υ��顼������ɽ�Ȥ��Ƥ��������ˤ���ͭ���ޤ��� �ü���ѿ�SQLERRM���㳰�˴�Ϣ�������顼��å���������ͭ���ޤ��� �������ѿ��ϡ��㳰�ϥ�ɥ�γ����Ǥ��������Ƥ��ޤ���
�㳰�ϥ�ɥ�������Ǥϡ�GET STACKED DIAGNOSTICS���ޥ�ɤ���Ѥ��ơ����ߤ��㳰�˴ؤ���������Ф����Ȥ�Ǥ��ޤ��� ���Τ褦�ʤ�����Ȥʤ�ޤ���
GET STACKED DIAGNOSTICS variable = item [ , ... ];
Each item is a key word identifying a status value to be assigned to the specified variable (which should be of the right data type to receive it). The currently available status items are shown in 表39-1. --> ��item�ϡ����ꤵ�줿�ѿ��ʤ���ϼ�����뤿����������ǡ������Ǥʤ���Фʤ�ޤ���ˤ��������������ͤ��̤��륭����ɤǤ��� �����Ѳ�ǽ�ʥ��ơ��������ܤ�表39-1��ɽ������Ƥ��ޤ���
表 39-1. ���顼�ο�����
̾�� | �� | ���� |
---|---|---|
RETURNED_SQLSTATE | text | �㳰��SQLSTATE���顼������ |
MESSAGE_TEXT | text | �㳰�μ��פʥ�å������Υƥ����� |
PG_EXCEPTION_DETAIL | text | �㳰�ξܺ٤ʥ�å������Υƥ����ȡ�¸�ߤ����� |
PG_EXCEPTION_HINT | text | �㳰�Υҥ�ȤȤʤ��å������Υƥ����ȡ�¸�ߤ����� |
PG_EXCEPTION_CONTEXT | text | �ƤӽФ������å��Ҥ���ƥ����Ȥι� |
�㳰�����ܤ��ͤ����ꤷ�ʤ���硢��ʸ�����֤���ޤ���
�ʲ�������ޤ���
DECLARE text_var1 text; text_var2 text; text_var3 text; BEGIN -- �㳰��������������� ... EXCEPTION WHEN OTHERS THEN GET STACKED DIAGNOSTICS text_var1 = MESSAGE_TEXT, text_var2 = PG_EXCEPTION_DETAIL, text_var3 = PG_EXCEPTION_HINT; END;