Chapter 9. ����ǥå�����ĥ��ǽ�ؤΥ��󥿡��ե�����

����ޤǤΤȤ����Ǥϡ����������俷�����ؿ�������ӿ������黻�� ��ɤ��ͤ�������뤫�ˤĤ����������Ƥ��ޤ������������ʤ��顢�� �������䤽�α黻�Ҥ��Ф����B-tree�� R-tree ��ϥå��奢�������᥽�åɤʤɤ�Ȥ� ���ˣ�������ǥå����ˤĤ��Ƥ��������Ƥ��ޤ���Ǥ�����

��� Postgres �����ƥ५������ �� �⤦�����ɤ��֤��ƤߤƤ��������������Υڡ����α�Ⱦʬ�Ǥϡ��桼 ������η�����ӡ��ޤ��ϥ���ǥå����դ��Υ桼������黻�ҡʤ� �ʤ�� pg_am, pg_amop, pg_amproc, pg_operators ����� pg_opclass �ˤλȤ����� Postgres ���Ф��������뤿��ˡ��ѹ�����ɬ�פΤ��륫 �������˴ؤ��ƾҲ𤷤Ƥ��ޤ�����ǰ�ʤ��顢�����Τ��Ȥ��ñ�˹� �����ޥ�ɤϤ���ޤ��󡣤����Ǥϡ������Υ����������ѹ�������ˡ ��ʣ�ǿ����ͤ������ͤξ���˥����Ȥ��롢 B-tree ���������᥽�åɤ�Ȥä��������黻�ҥ��饹����Ȥ�������̤��� �Ҳ𤷤ޤ���

pg_am ���饹�ˤϡ��桼������γƥ������� �᥽�å��ѤΥ��󥹥��󥹤���Ĥ��Ĵޤޤ�Ƥ��ޤ��� Postgres �ˤϥҡ��ץ��������᥽�åɤ��Ȥ߹��ޤ� �Ƥ��ޤ�����¾�Τ��٤ƤΥ��������᥽�åɤϤ��Υ��饹�˵��Ҥ���� ���ޤ����������ޤϰʲ����̤�Ǥ���

Table 9-1. ����ǥå����Υ�������

°������
amname���������᥽�å�̾
amownerpg_user �ˤ����롢��ͭ�ԤΥ��󥹥��󥹤Υ��� ��������ID
amkind���ߤϻȤ��Ƥ��ޤ���'o' �Ȥ���ʸ�������� �ΰ����ݤ��Ƥ��ޤ���
amstrategies���Υ��������᥽�å��ѤΥ��ȥ�ƥ��ο��ʸ�ҡ�
amsupport���Υ��������᥽�å��ѤΥ��ݡ��ȥ롼����ο��ʸ�ҡ�
amgettuple 
aminsert 
...���������᥽�åɤؤΥ��󥿡��ե������롼���� �ѤΥץ��������㼱�̻ҡ����Ȥ��� regproc id �ϡ������ǾҲ𤹤륢�������᥽�åɤ򥪡��ץ� ���������������ꡢ�������饤�󥹥��󥹤������ ���ꤹ�뤿��Τ�ΤǤ���

pg_am �ˤ����륤�󥹥��󥹤� ���֥������ȼ��̻� �ϡ�����¾��¿���Υ��饹 �ˤ����Ƴ��������Ȥ��ƻ��Ѥ���ޤ������Υ��饹�˿����� ���󥹥��󥹤��ɲä���ɬ�פϤ���ޤ���ɬ�פʤΤϡ��� ĥ���������������᥽�åɤΥ��󥹥��󥹤� ���֥� �����ȼ��̻� �����Ǥ���

SELECT oid FROM pg_am WHERE amname = 'btree';

         +----+
         |oid |
         +----+
         |403 |
         +----+
   
��� WHERE ����ˤƤ��� SELECT ��Ȥ��ޤ���

amstrategies °���ϡ��ǡ�������ޤ� ������ӽ�����ɸ�ಽ���뤿��Τ�ΤǤ������Ȥ��� B-tree �ξ�硢�������������������礭 �����ظ�̩���¤�Ǥ��ʤ���Фʤ�ޤ��� Postgres �Ǥϥ桼�����黻�Ҥ�����Ǥ��ޤ��� �ǡ�Postgres �ϱ黻�ҡʤ��Ȥ��� ">" �� "<"�ˤ�̾���򸫤Ĥ������α黻�Ҥ��ɤΤ褦����Ӥ� �Ԥʤ��Τ��ϲ��ޤ��� �ºݡ����������᥽�åɤˤ�äƤϤޤä�����������ꤷ�ʤ� ��Τ⤢��ޤ������Ȥ��� R-tree �ϻͳѷ� ���Ĥ����ط���ɽ���ޤ��������Υϥå���ǡ����ι�¤�ϥϥå��� �ؿ����ͤˤ�äƥӥå�����������ɽ���Ƥ�������Ǥ��� Postgres �ϡ�������������ä� ��ˡ�ǡ������꡼��ξ�����Ф����黻�Ҥ�õ��������ǥ� ���������Ѳ�ǽ���ɤ�������ꤹ��ɬ�פ�����ޤ����Ȥ������� �ϡ� Postgres �ϡ����Ȥ��� "<=" �� ">" �黻�Ҥ�B-tree ����ڤ�Ȥ����� �Ȥ��ΤäƤ���ɬ�פ����뤳�Ȥˤʤ�ޤ��� Postgres �ϥ��ȥ�ƥ����Ѥ��ơ��黻�Ҥȥ��� �ǥå����򥹥���󤹤���ˡ�Ȥδ֤Τ����δط���ɽ������ ���ޤ���

���������ȥ�ƥ������åȤ������������ϰϤǤϤ���ޤ��󤬡� �������黻�ҥ��饹���ɲä��뤿���ɬ�פǤ��Τǡ������� B-tree ���ȥ�ƥ����ɤΤ褦��ư��뤫 ���������뤳�Ȥˤ��ޤ��� pg_am ���饹�� ������amstrategies °���ϡ����Υ��������᥽�å��Ѥ�������� �����ȥ�ƥ��ο��򼨤��ޤ��� B-tree �Ǥϡ� ���ο��� 5 �Ǥ��������Υ��ȥ�ƥ��ϡ��ʲ��Τ褦���б����� ���ޤ���

Table 9-2. B-tree ���ȥ�ƥ�

���ڥ졼���������ǥå���
��꾮����1
����������꾮����2
������3
������������礭��4
����礭��5

�ͤ����Ȥ��Ƥϡ���Ҥ������ˡ���б���������� pg_amop ��졼�����ʸ�ҡˤ��ɲä��� ɬ�פ�����Ȥ������ȤǤ��� B-tree ��ɤ�ʬ �䤹�뤫����������ɤ��׻����뤫�ʤɤ򸫤Ĥ��뤿��ˡ������� ���᥽�åɤΥ����ɤϡ��ǡ������ˤ�����餺�����Υ��ȥ�ƥ� �ֹ����Ѥ��뤳�Ȥ��Ǥ��ޤ����������ɲä��뤿��ζ���Ū���� ˡ�ˤĤ��ƤϤޤ����ˤ����뤳�ȤϤ���ޤ��� B-tree �����Ǥ��� int2, int4, oid �䤽��¾�Υǡ������ˤϡ������ν�����ɬ�פǤ���Ȥ������� ������Ǥ���Ф褤�ΤǤ���

���ȥ�ƥ��������ƥ���Ф��ƥ���ǥå�����Ȥ���ˡ�򸫤Ĥ���Τ˽�ʬ�� �������äƤ��ʤ����⤢��ޤ������������᥽�åɤ���ˤϡ�����ư��� ����¾�Υ��ݡ��ȥ롼����ɬ�פʤ�Τ⤢��ޤ������Ȥ��� B-tree ���������᥽�åɤϡ����ĤΥ�������Ӥ��� ����礭���Τ����������Τ�����꾮�����Τ������Ǥ��ʤ���� �ʤ�ޤ���Ʊ�ͤˡ� R-tree ���������᥽�åɤ� �ͳѷ��ζ�����ʬ���½��硢�򺹤��ٹ�ʤɤ�׻��Ǥ��ʤ���Фʤ�ޤ��� ���������� SQL �����꡼�ˤ�����桼�������ꤷ������ ���б����ޤ��󡣤���������Ū�˥��������᥽�åɤ����Ѥ��� �����롼����Ǥ���

���٤Ƥ� Postgres ���������᥽�åɤ��Ф��� �͡��ʥ��ݡ��ȥ롼���������Ū�˴������뤿��ˡ�pg_am ��amsupport �ȸƤФ��°���� �ޤ�Ǥ��ޤ�������°���ϡ����ĤΥ��������᥽�åɤ���Ȥ���롼 ����ο�������ޤ��� B-tree �ˤ����ƤϤ��ο��� 1 �Ǥ������Υ롼�����2�ĤΥ���������Ȥ����ǽ�Υ����������ܤ� ������꾮���������������礭�����ˤ�ꡢ���줾�� -1, 0, +1 ���� ���ޤ���

Note: ��̩�˸����ȡ����Υ롼��������( < 0 )��0 ������� 0 �Ǥʤ�����( > 0 )�� �֤��ޤ���

pg_am �� amstrategies ����ȥ�ϡ��о� �Ȥ��Ƥ��륢�������᥽�å��Ѥ�������줿���ȥ�ƥ��ο��˲� ���ޤ��󡣡֤�꾮�����ס�������������꾮�����פ����Ȥ��� �������� pg_am �ˤϸ���ޤ���Ʊ�ͤˡ� amsupport �ϥ��������᥽�åɤ��׵᤹ �륵�ݡ��ȥ롼����ο��˲᤮�ޤ��󡣼ºݤΥ롼������̤� �Ȥ������������Ƥ��ޤ���

���˽��פʥ��饹�ϡ� pg_opclass �Ǥ������Υ��饹��̾���ȴ��� ���� oid ���Ϣ�դ��뤿�������¸�ߤ��ޤ��� pg_amop �ˤ����Ƥϡ� ���٤Ƥ� B-tree �黻�ҥ��饹�ϡ���ҤΤ褦 �ˡ������飵�ޤǤν������åȤ���äƤ��ޤ�����¸�� opclass �Ȥ��ơ� int2_ops, int4_ops, oid_ops ���� ��ޤ�������� opclass ̾(�㤨�� complex_abs_ops )����ä����󥹥��󥹤�pg_opclass ���ɲä��ʤ��ƤϤʤ�ޤ��󡣤��Υ��󥹥��󥹤� oid ��¾�Υ��饹�ˤ����볰�������Ȥʤ�� ����

INSERT INTO pg_opclass (opcname, opcdeftype)
    SELECT 'complex_abs_ops', oid FROM pg_type WHERE typname = 'complex_abs';

SELECT oid, opcname, opcdeftype
    FROM pg_opclass
    WHERE opcname = 'complex_abs_ops';

         +------+-----------------+------------+
         |oid   | opcname         | opcdeftype |
         +------+-----------------+------------+
         |17314 | complex_abs_ops |      29058 |
         +------+-----------------+------------+
   
�����ƥ�ˤ�ä� pg_opclass ���󥹥��󥹤� oid �� ����ͤȤϰۤʤ�ޤ������Τ��Ȥϵ��ˤ��ʤ��Ǥ��������������Ƿ��� oid �Ȥ������������ͤ򡢤��θ�Ǥ⥷���ƥफ�����ꤷ���ͤȤ��ƻ��Ѥ��ޤ���

����ǥ��������᥽�åɤȱ黻�ҥ��饹���Ǥ��ޤ��������ˡ��黻�Ҥ� ���åȤ�ɬ�פˤʤ�ޤ����黻�Ҥ������������Ϥ��Υޥ˥奢�� �����Ҥ��ޤ����� Btrees ��� complex_abs_ops �黻�ҤǤϡ��ʲ� �α黻�Ҥ�ɬ�פǤ���

        absolute value less-than
        absolute value less-than-or-equal
        absolute value equal
        absolute value greater-than-or-equal
        absolute value greater-than
   

������줿�ؿ���������륳���ɤϡ� PGROOT/src/tutorial/complex.c �˳�Ǽ����Ƥ����ΤȤ��ޤ���

�����ɤΰ�����ʲ��˼����ޤ��������ա�������λĤ����ʬ�Ǥϡ� ��������黻�ҤΤߤ򼨤����Ȥˤ��ޤ���¾�Σ��Ĥα黻�Ҥ��ɤ� ���Ƥ��ޤ����ܺ٤ϡ� complex.c �ޤ��� complex.source ����������������

#define Mag(c) ((c)->x*(c)->x + (c)->y*(c)->y)

         bool
         complex_abs_eq(Complex *a, Complex *b)
         {
             double amag = Mag(a), bmag = Mag(b);
             return (amag==bmag);
         }
   

�����ǽ��פʤ��Ȥ����Ĥۤɤ���ޤ���

�ޤ��� int4 �ѤΡ��֤�꾮�����ס� ������������꾮�����ס����������ס���������������礭���ס� �֤���礭���פ�Ƚ�ꤹ�뤿��α黻�Ҥ��������褦�Ȥ��Ƥ���Ȥ��� ���ȤǤ��� int4 �ѤΤ����α黻�Ҥϡ� <��<=��=�� >= ��> �Ȥ���̾���Ǥ��Ǥ��������Ƥ��ޤ��� ������󿷤����黻�Ҥϰۤʤä������񤤤򤷤ޤ��� Postgres ���Ť��黻�ҤǤʤ������ο��� ���黻�Ҥ�Ȥ����Ȥ��ݾڤ��뤿��ˡ������ˤϸŤ���ΤȤϰۤʤä� ̾�����դ��ʤ���Фʤ�ޤ��󡣤������ο��Ǥ������ΰ��������ä� �黻�Ҥ��������Ƥ��ʤ����ˤΤߡ� Postgres �DZ黻�Ҥ򥪡��С������ɤ��� ���Ȥ��Ǥ��ޤ��� ���ʤ����(int4, int4) �Ѥ� < �������硢 ��������������뤳�ȤϤǤ��ޤ��󡣱黻�Ҥ��������ݤˡ� Postgres �Ϥ��ν�ʣ������å����ޤ���Τ� ���դ��Ʋ�����������������򤱤뤿��ˡ��黻�Ҥˤ����Ѥ���̾���� �Ȥ��ޤ������줬����ʤ��ȡ���������¹Ԥ���ݤˡ� ���������᥽�åɤϥ���å���򵯤����Ƥ��ޤ����⤷��ޤ���

�⤦���Ĥν��פ����ϡ����٤Ƥα黻�Ҵؿ��ϥ֡����ͤ��֤��Ȥ��� ���ȤǤ������������᥽�åɤϤ��Τ��Ȥ˰�¸���Ƥ��ޤ����ʰ����� ���ݡ��ȴؿ�������Υ��������᥽�åɤ����Ԥ����� -- ���ξ��Ǥ� ����դ����� -- ���֤��ޤ����� �ե�������κǸ�Υ롼����ϡ�pg_am���饹�� amsupport °��������������˽Ҥ٤� "���ݡ��ȥ롼����" �Ǥ��� ����ϸ�ǻȤ��ޤ��Τǡ�����̵�뤷�Ƥ����Ƥ��ޤ��ޤ���

CREATE FUNCTION complex_abs_eq(complex_abs, complex_abs)
              RETURNS bool
              AS 'PGROOT/tutorial/obj/complex.so'
              LANGUAGE 'c';
   

�����Ǥ�������Ѥ���黻�Ҥ�������ޤ������դ����褦�ˡ� �黻�Ҥ�̾���ϡ����Ĥ� int4 ���ڥ��ɤ��� ���٤Ƥα黻�Ҥδ֤ǰ�դǤʤ���Фʤ�ޤ��󡣸�Ҥ��롢����Ѥ� �黻��̾�ΰ���������ˤϡ� pg_operator ���Ф��ƥ����꡼��ȯ�Ԥ��ޤ���

    /*
     * ���Υ����꡼�ϡ�����ɽ���黻�� (~) ��Ȥäơ�ʸ�� & ��
     * ����룳ʸ���α黻��̾�򸫤Ĥ��ޤ���
     */
    SELECT *
     FROM pg_operator
     WHERE oprname ~ '^..&$'::text;
   

Ʊ�ͤ˻Ȥ�������������ˤȤ�黻��̾��ʬ����ޤ��� ����������ʤ��Ȥϡ�procedure�ʾ�ξ��� C �δؿ��� �� restrict �� join ����ؿ��Ǥ������ʤ��ϸ�Ҥˤ����ƻȤ��Ƥ��� ��Τ�Ȥ��٤��Ǥ� -- ���ա��֤�꾮�����ס����������ס��֤���礭���� �Τ��줾��Υ������ˤ����ơ������δؿ����ۤʤ뤳�Ȥ����դ��Ʋ������� ����餬�󶡤���ʤ��ȡ����������᥽�åɤ����α黻�Ҥ�Ȥ����Ȥ���� ����å��夷�Ƥ��ޤ���restrict �� join ��̾���ϥ��ԡ�����٤� �Ǥ����� procedure ̾�ˤ����Υ��ƥåפ����������Τ�ȤäƲ�������

CREATE OPERATOR = (
     leftarg = complex_abs, rightarg = complex_abs,
     procedure = complex_abs_eq,
     restrict = eqsel, join = eqjoinsel
         )
   

���ա��֤�꾮�����ס�������������꾮�����ס����������ס� �֤���礭���ס�����ӡ�������������礭���פ��б��������� �α黻�Ҥ��������ޤ���

�������⤦�����ǽ����Ǥ����Ǹ�ˡ�pg_amop ��졼�����򹹿����ʤ���Фʤ�ޤ��󡣤���ˤϰʲ���°���� ɬ�פǤ���

Table 9-3. pg_amproc ��������

°������
amopid B-Tree�Ѥ� pg_am ���󥹥��� ��oid(== 403, ����)
amopclaid complex_abs_ops �Ѥ� pg_opclass ���󥹥��󥹤� oid(17314�������������Ρ�����)
amopopr opclass�α黻�Ҥ�oid��(������˼������ޤ���)
amopselect, amopnpages�����ȴؿ�
�����ȴؿ��ϡ������꡼���ץƥ��ޥ�����Ϳ����줿����ǥå����� �������ǻȤ����ɤ�������ꤹ�뤿��˻Ȥ��ޤ��������ʤ��Ȥˡ� �����Ϥ��Ǥˤ���ޤ��� B-tree ��Ȥ����ɤ�����ɾ������ btreesel �ȡ� �ĥ꡼��Ǹ����롼���󤬻Ȥ��ڡ�������ͽ¬���뤿��� btreenpage �Σ��Ĥδؿ���Ȥ��ޤ���

�����ǡ���������黻�Ҥ� oid ��ɬ�פˤʤ�ޤ��� ���Ĥ� complex ���뤹�٤Ƥα黻�Ҥ�̾�� �򸡺����������椫��ɬ�פʤΤ�Τ���Ф��Ƥߤޤ���

    SELECT o.oid AS opoid, o.oprname
     INTO TABLE complex_ops_tmp
     FROM pg_operator o, pg_type t
     WHERE o.oprleft = t.oid and o.oprright = t.oid
      and t.typname = 'complex_abs';

         +------+---------+
         |oid   | oprname |
         +------+---------+
         |17321 | <       |
         +------+---------+
         |17322 | <=      |
         +------+---------+
         |17323 |  =      |
         +------+---------+
         |17324 | >=      |
         +------+---------+
         |17325 | >       |
         +------+---------+
   
(Again, some of your oid numbers will almost certainly be different.) The operators we are interested in are those with oids 17321 through 17325. The values you get will probably be different, and you should substitute them for the values below. We will do this with a select statement. (�����ǺƤӡ������ƥ�ˤ�ä� oid �ֹ�Ϥۤ� ��ɳμ¤˰ۤʤ�ޤ���) �������Τꤿ���黻�Ҥ� oid ��17321����17325�ޤǤΤ�ΤǤ������ʤ��������ͤϤ��� �餯�ۤʤäƤ���Τǡ��ʲ��ǤϤ��ʤ��������ͤ��֤������ƹͤ��� �����������ܽ�ǤϤ����ͤ� select ʸ��ȤäƤ����ޤ���

����ǿ������黻�ҥ��饹�� pg_amop �򹹿��� ��������Ǥ��ޤ������������ΤǺǤ����ڤʤ��Ȥϡ�pg_amop ����Ǥϱ黻�Ҥϡ�������������꾮�����ס����� ��������������礭���פޤǤ����֤��¤�Ǥ���Ȥ������ȤǤ���ɬ�� �ʥ��󥹥��󥹤��ɲä��Ƥߤޤ���

    INSERT INTO pg_amop (amopid, amopclaid, amopopr, amopstrategy,
                amopselect, amopnpages) 
        SELECT am.oid, opcl.oid, c.opoid, 1,
                'btreesel'::regproc, 'btreenpage'::regproc
        FROM pg_am am, pg_opclass opcl, complex_abs_ops_tmp c
        WHERE amname = 'btree' AND
            opcname = 'complex_abs_ops' AND
            c.oprname = '<';
   
Now do this for the other operators substituting for the "1" in the third line above and the "<" in the last line. Note the order: "less than" is 1, "less than or equal" is 2, "equal" is 3, "greater than or equal" is 4, and "greater than" is 5. ¾�α黻�ҤˤĤ��ƤϾ��3���ܤ� "1" �ȺǸ�� "<" ���֤����� �ƥ��󥹥��󥹤��ɲä��ޤ�������: ���֤�"��꾮����"�� 1 �� "����������꾮����"�� 2 ��"������"�� 3 ��"������������礭��" �� 4 ��"����礭��"�� 5 �Ǥ���

���Υ��ƥåפϡ�pg_am �������ΤȤ����� �������ޤ�����"���ݡ��ȥ롼����"����Ͽ�Ǥ������ݡ��ȥ롼���� �� oid �� pg_amproc ���饹�˳�Ǽ����Ƥ��ꡢ���������᥽�åɤ� oid �ȱ黻�ҥ��饹�� oid �������ˤʤäƤ��ޤ��� �ǽ�� Postgres �˴ؿ�����Ͽ����ɬ �פ�����ޤ���(�黻�ҥ롼�������������ե�����κǸ�ˡ��� �Υ롼������������ C �����ɤ��֤������Ȥ� �פ��Ф��Ʋ�������)

    CREATE FUNCTION complex_abs_cmp(complex, complex)
     RETURNS int4
     AS 'PGROOT/tutorial/obj/complex.so'
     LANGUAGE 'c';

    SELECT oid, proname FROM pg_proc
     WHERE proname = 'complex_abs_cmp';

         +------+-----------------+
         |oid   | proname         |
         +------+-----------------+
         |17328 | complex_abs_cmp |
         +------+-----------------+
   
(Again, your oid number will probably be different and you should substitute the value you see for the value below.) We can add the new instance as follows: (�Ƥӡ������ƥ�ˤ�ä����ꤹ�� oid �ֹ�Ϥ����餯 �ۤʤäƤ��ޤ��Τǡ��ʹߤǤϤ��ʤ��������ͤ��֤������Ƥ���������) ���Τ褦�˿��������󥹥��󥹤��ɲäǤ��ޤ���
    INSERT INTO pg_amproc (amid, amopclaid, amproc, amprocnum)
        SELECT a.oid, b.oid, c.oid, 1
            FROM pg_am a, pg_opclass b, pg_proc c
            WHERE a.amname = 'btree' AND
                b.opcname = 'complex_abs_ops' AND
                c.proname = 'complex_abs_cmp';
   

�����ǡ����η��ˤĤ��ƥ���ǥå���������Ǥ���褦�˥ϥå��� ���ȥ�ƥ����ɲä���ɬ�פ�����ޤ���pg_am ���¾�η�����Ѥ��� �ԤäƤ��ޤ�����Ʊ���黻�Ҥ�����Ѥ��ޤ���

    INSERT INTO pg_amop (amopid, amopclaid, amopopr, amopstrategy,
                amopselect, amopnpages)
        SELECT am.oid, opcl.oid, c.opoid, 1,
                'hashsel'::regproc, 'hashnpage'::regproc
        FROM pg_am am, pg_opclass opcl, complex_abs_ops_tmp c
        WHERE amname = 'hash' AND
            opcname = 'complex_abs_ops' AND
            c.oprname = '=';
   

���Υ���ǥå����� where ��ǻ��Ѥ��뤿��ˡ�pg_operator ���饹�򼡤Τ褦���ѹ����ޤ���

    UPDATE pg_operator
        SET oprrest = 'eqsel'::regproc, oprjoin = 'eqjoinsel'
        WHERE oprname = '=' AND
            oprleft = oprright AND
            oprleft = (SELECT oid FROM pg_type WHERE typname = 'complex_abs');
    
    UPDATE pg_operator
        SET oprrest = 'neqsel'::regproc, oprjoin = 'neqjoinsel'
        WHERE oprname = '' AND
            oprleft = oprright AND
            oprleft = (SELECT oid FROM pg_type WHERE typname = 'complex_abs');
    
    UPDATE pg_operator
        SET oprrest = 'neqsel'::regproc, oprjoin = 'neqjoinsel'
        WHERE oprname = '' AND
            oprleft = oprright AND
            oprleft = (SELECT oid FROM pg_type WHERE typname = 'complex_abs');
    
    UPDATE pg_operator
        SET oprrest = 'intltsel'::regproc, oprjoin = 'intltjoinsel'
        WHERE oprname = '<' AND 
            oprleft = oprright AND
            oprleft = (SELECT oid FROM pg_type WHERE typname = 'complex_abs');
    
    UPDATE pg_operator
        SET oprrest = 'intltsel'::regproc, oprjoin = 'intltjoinsel'
        WHERE oprname = '<=' AND
            oprleft = oprright AND
            oprleft = (SELECT oid FROM pg_type WHERE typname = 'complex_abs');
    
    UPDATE pg_operator
        SET oprrest = 'intgtsel'::regproc, oprjoin = 'intgtjoinsel'
        WHERE oprname = '>' AND
            oprleft = oprright AND
            oprleft = (SELECT oid FROM pg_type WHERE typname = 'complex_abs');
    
    UPDATE pg_operator
        SET oprrest = 'intgtsel'::regproc, oprjoin = 'intgtjoinsel'
        WHERE oprname = '>=' AND
            oprleft = oprright AND
            oprleft = (SELECT oid FROM pg_type WHERE typname = 'complex_abs');
   

�Ǹ��(�Ǹ�Ǥ�!)���η��ˤĤ��Ƥ�����ʸ����Ͽ���ޤ���

    INSERT INTO pg_description (objoid, description) 
    SELECT oid, 'Two part G/L account'
	    FROM pg_type WHERE typname = 'complex_abs';