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

38.6. ���湽¤

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

38.6.1. �ؿ����������

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

38.6.1.1. RETURN

RETURN expression;

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

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

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

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

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

38.6.1.2. RETURN NEXT�����RETURN QUERY

RETURN NEXT expression;
RETURN QUERY query;

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 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����Ѥ���ؿ��ϡ�FROM��ǥơ��֥�Υ������Ȥ��ƸƤӽФ���ʤ���Фʤ����Ȥ����դ��Ƥ���������

注意: �嵭�Τ褦�ˡ�RETURN NEXT�����RETURN QUERY�θ��ߤμ����Ǥϡ��ؿ������֤�������˷�̽������Τ��ݴɤ��ޤ��� ����ˤ�ꡢPL/pgSQL�ؿ����������̤η�̽�����֤�����硢��ǽ���㲼�����ǽ��������ޤ��� ����ξ��פ��򤱤뤿�ᡢ�ǡ����ϥǥ������˽񤭹��ޤ�ޤ��� ���������ؿ����ΤϷ�̽������Τ����������ޤǤ��֤�ޤ��� �����PL/pgSQL�ΥС������Ǥϡ��������¤�������˽�����֤��ؿ���桼��������Ǥ���褦�ˤʤ뤫�⤷��ޤ��� ���ߡ��ǥ������˽񤭹��ޤ��ǡ����γ�������work_mem�����ѿ��ˤ�ä����椵��Ƥ��ޤ��� ���̤η�̽�����ݴɤ���Τ˽�ʬ�ʥ��꤬�����硢�����ԤϤ��Υѥ�᡼�����ͤ��礭�����뤳�Ȥ��θ���٤��Ǥ���

38.6.2. ���ʬ��

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

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

38.6.2.2. IF-THEN-ELSE

IF boolean-expression THEN
    statements
ELSE
    statements
END IF;

IF-THEN-ELSEʸ��IF-THEN�˲ä������ɾ�������ξ��˼¹Ԥ��٤�ʸ�ν������ꤵ���뤳�Ȥ��Ǥ��ޤ���

�㡧

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;

38.6.2.3. IF-THEN-ELSE IF

�ʲ�����Τ褦��IFʸ������Ҥˤ��뤳�Ȥ��Ǥ��ޤ���

IF demo_row.sex = 'm' THEN
    pretty_sex := 'man';
ELSE
    IF demo_row.sex = 'f' THEN
        pretty_sex := 'woman';
    END IF;
END IF;

���η�������Ѥ����硢�ºݤ�IFʸ��¦��IFʸ��ELSE����ʬ����¦������Ҥˤ��Ƥ��ޤ��� �������äơ�����Ҥˤ���IF���Ȥ�1�Ĥ�END IFʸ�������οƤȤʤ�IF-ELSE��1�Ĥ�END IFʸ��ɬ�פǤ��� ����ˤ�������ư��Ǥ��ޤ������������٤����䤬¿��������Ͼ�Ĺ�ˤʤ�ޤ��� ���η�̡����η����Ǥ���

38.6.2.4. IF-THEN-ELSIF-ELSE

IF boolean-expression THEN
    statements
[ ELSIF boolean-expression THEN
    statements
[ ELSIF boolean-expression THEN
    statements
    ...]]
[ ELSE
    statements ]
END IF;

IF-THEN-ELSIF-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;

38.6.2.5. IF-THEN-ELSEIF-ELSE

ELSEIF��ELSIF����̾�Ǥ���

38.6.3. ñ��ʥ롼��

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

38.6.3.1. LOOP

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

LOOP�ϡ�EXITʸ�ޤ���RETURNʸ�ˤ�äƽ�λ�����ޤ�̵�¤˷����֤���롢���ʤ��Υ롼�פ�������ޤ��� ���ץ�����label�ϡ�����Ҿ��롼�����EXIT�ڤ�CONTINUEʸ�ǡ��ɤΥ�٥������Ҥ�Ŭ�Ѥ��뤫����ꤹ�뤿��˻��Ѥ���ޤ���

38.6.3.2. EXIT

EXIT [ label ] [ WHEN boolean-expression ];

label�����ꤵ��ʤ���硢�Ǥ���¦�Υ롼�פ򽪤�餻��END LOOP�μ���ʸ�����θ�˼¹Ԥ���ޤ��� label �����ꤵ�줿��硢����ϸ��ߤΥ롼�ס��⤷��������Ҥˤʤä��롼�פ�֥��å��γ�¦�Υ�٥�Υ�٥�Ǥ���ɬ�פ�����ޤ��� ���θ塢��̾���줿�롼�פޤ��ϥ֥��å��򽪤�餻�����Υ롼�פޤ��ϥ֥��å����б�����END�μ���ʸ�������ܤ��ޤ���

WHEN�����ꤵ�줿��硢boolean-expression�����ξ��Τߥ롼�פν�λ��������ޤ��� ����ʤ���С�EXIT�θ�ιԤ����椬�ܤ�ޤ���

EXIT�ϡ�������롼�פȶ��˻��ѤǤ������ʤ��Υ롼�פ˸��ꤵ��ޤ��� BEGIN�֥��å��ȶ��˻��Ѥ�������EXIT�ˤ��֥��å��μ���ʸ�����椬�ܤ�ޤ���

�㡧

LOOP
    -- ���餫�α黻
    IF count > 0 THEN
        EXIT;  -- �롼�פ�ȴ���Ф�
    END IF;
END LOOP;

LOOP
    -- ���餫�α黻
    EXIT WHEN count > 0;  -- �����Ʊ�����
END LOOP;

BEGIN
    -- ���餫�α黻
    IF stocks > 100000 THEN
        EXIT;  -- ����ˤ��BEGIN�֥��å���ȴ���Ф�
    END IF;
END;

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

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

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

38.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
    PERFORM cs_log('Refreshing materialized views...');

    FOR mviews IN SELECT * FROM cs_materialized_views ORDER BY sort_key LOOP
        -- ������"mviews"��cs_materialized_views��1�ĤΥ쥳���ɤ�����ޤ�
        PERFORM cs_log('Refreshing materialized view ' || 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;

    PERFORM cs_log('Done refreshing materialized views.');
    RETURN 1;
END;
$$ LANGUAGE plpgsql;

���Υ롼�פ�EXITʸ�ǽ�λ������硢�Ǹ�˳�����Ƥ�줿�Ԥ��ͤϥ롼�פ�ȴ������Ǥ⥢���������뤳�Ȥ��Ǥ��ޤ���

���η���FORʸ��query�Ȥ��ơ��Ԥ��֤����Ƥ�SQL���ޥ�ɤ���ѤǤ��ޤ��� �̾��SELECT�Ǥ�����RETURNING���ȼ�ä�INSERT��UPDATE�ޤ���DELETE����ѤǤ��ޤ��� EXPLAIN�ʤɤΥ桼�ƥ���ƥ����ޥ�ɤ��ư���ޤ���

PL/pgSQL�ѿ����䤤��碌�ƥ����Ȥ��֤��������ޤ��� �䤤��碌�ײ�ϡ�項38.10.1�����項38.10.2�ǽҤ٤��褦�ˡ������ѤΤ���˥���å��夵��ޤ���

FOR-IN-EXECUTE ʸ�ϹԤ򷫤��֤��⤦1�Ĥ���ˡ�Ǥ���

[ <<label>> ]
FOR target IN EXECUTE text_expression LOOP 
    statements
END LOOP [ label ];

������ˡ�ϡ��䤤��碌�Υ�������ʸ���󼰤ǻ��ꤵ���������������η����Ȼ��Ƥ��ޤ��� ���μ���FOR�롼�פγƥ���ȥ��ɾ�����졢�Ʒײ褬�Ԥ��ޤ��� ����ˤ�ꡢ�ץ�����ޤϡ��̾��EXECUTEʸ��Ʊ���褦�˻����˷ײ褵�줿�䤤��碌�ˤ���®���ȡ�ưŪ���䤤��碌�λ��Ľ����������򤹤뤳�Ȥ��Ǥ��ޤ���

38.6.5. ���顼����ª

�ǥե���ȤǤϡ�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��ޤ����¦�Υ֥��å��ϥ��顼����ª�Ǥ��ޤ��������Ԥ���ȴؿ��ν��������Ǥ���ޤ���

���Ƥ�����̾��付録A�˼������Ȥ��Ǥ��ޤ��� ʬ��̾�Ϥ�����ʬ�व������ƤΥ��顼�˹��פ��ޤ��� OTHERS�Ȥ������̤ξ���̾��QUERY_CANCELED�ʳ������ƤΥ��顼�˹��פ��ޤ� ��QUERY_CANCELED��̾������ª���뤳�Ȥϲ�ǽ�Ǥ����������ǤϤ���ޤ���ˡ� ����̾�ϡ���ʸ���Ⱦ�ʸ������̤��ޤ���

���顼����������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�������˰ܤ�ȡ������dz�뤿��division_by_zero���顼�ȤʤꡢEXCEPTION�礬���Υ��顼����ª���ޤ��� RETURNʸ�ˤ��ؿ�������ͤϡ�1��û��������x���ͤȤʤ�ޤ�����UPDATE���ޥ�ɤˤ���̤ϥ�����Хå�����ޤ��� ��������BEGIN�֥��å�������INSERT���ޥ�ɤϥ�����Хå�����ޤ��� �������äơ��ǡ����١��������Ƥκǽ���̤�Tom Jones�Ǥ��ꡢJoe Jones�ǤϤ���ޤ���

ティップ: EXCEPTION���ޤ���֥��å��μ¹Ԥ��פ�����֤ϡ��ޤޤʤ��֥��å�����٤ƤȤƤ�Ĺ���ʤ�ޤ��� �������äơ�ɬ�פΤʤ�����EXCEPTION����Ѥ��ƤϤ����ޤ���

�㳰�ϥ�ɥ�������Ǥϡ�SQLSTATE�ѿ��������ä��㳰���б��������顼�����ɤ���ͭ���ޤ��� (表A-1�Υ��顼������ɽ�򻲾Ȥ��Ƥ�������)�� SQLERRM�ѿ����㳰���б��������顼��å���������ͭ���ޤ��� �������ѿ��ϡ��㳰�ϥ�ɥ�γ����Ǥ��������Ƥ��ޤ���

例 38-1. 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');