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

39.6. ���湽¤

���湽¤�Ϥ����餯PL/pgSQL�κǤ�ͭ�ѡʤ��Ľ��סˤ���ʬ�Ǥ��� PL/pgSQL�����湽¤����Ѥ��ơ�PostgreSQL�Υǡ��������˽��𡢶��Ϥ����뤳�Ȥ��Ǥ��ޤ���

39.6.1. �ؿ����������

�ؿ�����ǡ������֤�����˻��ѤǤ��륳�ޥ�ɤ�2�Ĥ���ޤ��� RETURN�����RETURN NEXT�Ǥ���

39.6.1.1. RETURN

RETURN expression;

�������RETURN�ϴؿ���λ����expression���ͤ�ƤӽФ������֤��ޤ��� ���η����Ͻ�����֤��ʤ�PL/pgSQL�ؿ��ǻ��Ѥ���ޤ���

�����鷿���֤�����Ǥ�դμ�����Ѥ��뤳�Ȥ��Ǥ��ޤ��� ���μ��η�̤ϡ������ΤȤ��������������褦�ˡ���ưŪ�˴ؿ�������ͤη��˥��㥹�Ȥ���ޤ��� ʣ��ʹԡ��ͤ��֤�����ˤϡ�expression�Ȥ��ƥ쥳���ɤ⤷���Ϲ��ѿ��򵭽Ҥ��ʤ���Фʤ�ޤ���

���ϥѥ�᡼������ä��ؿ�������������ϡ�����̵��RETURN�򵭽Ҥ��Ƥ��������� ���λ����ˤ�������ϥѥ�᡼�����ͤ��֤���ޤ���

void���֤��褦�˴ؿ�������������Ǥ⡢�ؿ���ľ����ȴ���Ф������RETURN����ѤǤ��ޤ�����RETURN�θ�˼��򵭽Ҥ��ʤ��Ǥ���������

�ؿ�������ͤ�̤����Ȥ������ޤޤˤ��뤳�ȤϤǤ��ޤ��� ���椬��RETURNʸ�����Ĥ���ʤ����֤Ǵؿ��κǾ�̤Υ֥��å��ν����ޤ�ã���������¹Ի����顼��ȯ�����ޤ��� ���������������¤Ͻ��ϥѥ�᡼������ä��ؿ��ڤ�void���֤��ؿ��ˤ����ƤϤޤ�ޤ��� ���Τ褦�ʾ��ϺǾ�̤Υ֥��å�������ä�����RETURNʸ����ưŪ�˼¹Ԥ���ޤ���

39.6.1.2. RETURN NEXT�����RETURN QUERY

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�����ѿ��ˤ�ä����椵��Ƥ��ޤ��� ���̤η�̽�����ݴɤ���Τ˽�ʬ�ʥ��꤬�����硢�����ԤϤ��Υѥ�᡼�����ͤ��礭�����뤳�Ȥ��θ���٤��Ǥ���

39.6.2. ���ʬ��

IF��CASEʸ�Ϥ�����˴�Ť�������Υ��ޥ�ɤ�¹Ԥ����ޤ��� PL/pgSQL�ˤϡ��ʲ��Τ褦�ʣ��Ĥ�IF�η���������ޤ���

�ޤ����ʲ��Τ褦�ʣ��Ĥ�CASE�η���������ޤ���

39.6.2.1. IF-THEN

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;

39.6.2.2. IF-THEN-ELSE

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;

39.6.2.3. IF-THEN-ELSIF

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����Ѥ���������Ǥ���

39.6.2.4. �CASE

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;

39.6.2.5. �����դ�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������Ʊ��Ǥ���

39.6.3. ñ��ʥ롼��

LOOP��EXIT��CONTINUE��WHILE��FOR��FOREACHʸ����Ѥ��ơ�PL/pgSQL�ؿ��ǡ���Ϣ�Υ��ޥ�ɤ򷫤��֤����Ȥ��Ǥ��ޤ���

39.6.3.1. LOOP

[ <<label>> ]
LOOP
    statements
END LOOP [ label ];

LOOP�ϡ�EXITʸ�ޤ���RETURNʸ�ˤ�äƽ�λ�����ޤ�̵�¤˷����֤���롢���ʤ��Υ롼�פ�������ޤ��� ��ά��ǽ��label�ϡ�����Ҿ��ˤʤä��롼�פˤ�����EXIT�����CONTINUEʸ���ɤΥ�٥������Ҥ򻲾Ȥ��뤫����ꤹ�뤿��˻��Ѥ���ޤ���

39.6.3.2. EXIT

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;

39.6.3.3. CONTINUE

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;

39.6.3.4. WHILE

[ <<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;

39.6.3.5. FOR������FOR�롼�ס�

[ <<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���Ѥ��ƽ�������̾���������롼���ѿ��򻲾ȤǤ��ޤ���

39.6.4. �䤤��碌��̤ˤ�뷫���֤�

�̤μ����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���������ޤ���

39.6.5. �������

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}

39.6.6. ���顼����ª

�ǥե���ȤǤϡ�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�İʾ�ΰ�ե���ǥå�����¸�ߤ�����硢�ɤ���Υ���ǥå��������顼�θ����ˤʤ���������ƻ�Ԥ���Τǡ�����ư�Ȥʤ�ޤ��� ��ª�������顼��ͽ¬������ΤǤ��뤫���ڤ��뤿��ˡ�����ǵ��Ҥ��륨�顼��������Ѥ���С��������Ȥʤ�ޤ���

39.6.6.1. ���顼�˴ؤ������μ���

�㳰�ϥ�ɥ�Ϥ��Ф��С������ä�����Υ��顼���̤���ɬ�פ�����ޤ��� ���ߤ��㳰�˴ؤ����������������ˡ��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_SQLSTATEtext�㳰��SQLSTATE���顼������
MESSAGE_TEXTtext�㳰�μ��פʥ�å������Υƥ�����
PG_EXCEPTION_DETAILtext�㳰�ξܺ٤ʥ�å������Υƥ����ȡ�¸�ߤ�����
PG_EXCEPTION_HINTtext�㳰�Υҥ�ȤȤʤ��å������Υƥ����ȡ�¸�ߤ�����
PG_EXCEPTION_CONTEXTtext�ƤӽФ������å��򵭽Ҥ���ƥ����Ȥι�

�㳰�����ܤ��ͤ����ꤷ�ʤ���硢��ʸ�����֤���ޤ���

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

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;