globegit-postgresql-plruby 0.5.4

data/test/plp/test_mklang.sql

@@ -0,0 +1,8 @@
+ 
+   create function plruby_call_handler() returns language_handler
+    as '/home/dberger/Repositories/postgresql-plruby/src/plruby.so'
+   language 'C';
+ 
+   create trusted procedural language 'plruby'
+        handler plruby_call_handler
+        lancompiler 'PL/Ruby';

data/test/plp/test_queries.sql

@@ -0,0 +1,273 @@
+
+--
+-- First we build the house - so we create the rooms
+--
+insert into Room values ('001', 'Entrance');
+insert into Room values ('002', 'Office');
+insert into Room values ('003', 'Office');
+insert into Room values ('004', 'Technical');
+insert into Room values ('101', 'Office');
+insert into Room values ('102', 'Conference');
+insert into Room values ('103', 'Restroom');
+insert into Room values ('104', 'Technical');
+insert into Room values ('105', 'Office');
+insert into Room values ('106', 'Office');
+
+--
+-- Second we install the wall connectors
+--
+insert into WSlot values ('WS.001.1a', '001', '', '');
+insert into WSlot values ('WS.001.1b', '001', '', '');
+insert into WSlot values ('WS.001.2a', '001', '', '');
+insert into WSlot values ('WS.001.2b', '001', '', '');
+insert into WSlot values ('WS.001.3a', '001', '', '');
+insert into WSlot values ('WS.001.3b', '001', '', '');
+
+insert into WSlot values ('WS.002.1a', '002', '', '');
+insert into WSlot values ('WS.002.1b', '002', '', '');
+insert into WSlot values ('WS.002.2a', '002', '', '');
+insert into WSlot values ('WS.002.2b', '002', '', '');
+insert into WSlot values ('WS.002.3a', '002', '', '');
+insert into WSlot values ('WS.002.3b', '002', '', '');
+
+insert into WSlot values ('WS.003.1a', '003', '', '');
+insert into WSlot values ('WS.003.1b', '003', '', '');
+insert into WSlot values ('WS.003.2a', '003', '', '');
+insert into WSlot values ('WS.003.2b', '003', '', '');
+insert into WSlot values ('WS.003.3a', '003', '', '');
+insert into WSlot values ('WS.003.3b', '003', '', '');
+
+insert into WSlot values ('WS.101.1a', '101', '', '');
+insert into WSlot values ('WS.101.1b', '101', '', '');
+insert into WSlot values ('WS.101.2a', '101', '', '');
+insert into WSlot values ('WS.101.2b', '101', '', '');
+insert into WSlot values ('WS.101.3a', '101', '', '');
+insert into WSlot values ('WS.101.3b', '101', '', '');
+
+insert into WSlot values ('WS.102.1a', '102', '', '');
+insert into WSlot values ('WS.102.1b', '102', '', '');
+insert into WSlot values ('WS.102.2a', '102', '', '');
+insert into WSlot values ('WS.102.2b', '102', '', '');
+insert into WSlot values ('WS.102.3a', '102', '', '');
+insert into WSlot values ('WS.102.3b', '102', '', '');
+
+insert into WSlot values ('WS.105.1a', '105', '', '');
+insert into WSlot values ('WS.105.1b', '105', '', '');
+insert into WSlot values ('WS.105.2a', '105', '', '');
+insert into WSlot values ('WS.105.2b', '105', '', '');
+insert into WSlot values ('WS.105.3a', '105', '', '');
+insert into WSlot values ('WS.105.3b', '105', '', '');
+
+insert into WSlot values ('WS.106.1a', '106', '', '');
+insert into WSlot values ('WS.106.1b', '106', '', '');
+insert into WSlot values ('WS.106.2a', '106', '', '');
+insert into WSlot values ('WS.106.2b', '106', '', '');
+insert into WSlot values ('WS.106.3a', '106', '', '');
+insert into WSlot values ('WS.106.3b', '106', '', '');
+
+--
+-- Now create the patch fields and their slots
+--
+insert into PField values ('PF0_1', 'Wallslots basement');
+
+--
+-- The cables for these will be made later, so they are unconnected for now
+--
+insert into PSlot values ('PS.base.a1', 'PF0_1', '', '');
+insert into PSlot values ('PS.base.a2', 'PF0_1', '', '');
+insert into PSlot values ('PS.base.a3', 'PF0_1', '', '');
+insert into PSlot values ('PS.base.a4', 'PF0_1', '', '');
+insert into PSlot values ('PS.base.a5', 'PF0_1', '', '');
+insert into PSlot values ('PS.base.a6', 'PF0_1', '', '');
+
+--
+-- These are already wired to the wall connectors
+--
+insert into PSlot values ('PS.base.b1', 'PF0_1', '', 'WS.002.1a');
+insert into PSlot values ('PS.base.b2', 'PF0_1', '', 'WS.002.1b');
+insert into PSlot values ('PS.base.b3', 'PF0_1', '', 'WS.002.2a');
+insert into PSlot values ('PS.base.b4', 'PF0_1', '', 'WS.002.2b');
+insert into PSlot values ('PS.base.b5', 'PF0_1', '', 'WS.002.3a');
+insert into PSlot values ('PS.base.b6', 'PF0_1', '', 'WS.002.3b');
+
+insert into PSlot values ('PS.base.c1', 'PF0_1', '', 'WS.003.1a');
+insert into PSlot values ('PS.base.c2', 'PF0_1', '', 'WS.003.1b');
+insert into PSlot values ('PS.base.c3', 'PF0_1', '', 'WS.003.2a');
+insert into PSlot values ('PS.base.c4', 'PF0_1', '', 'WS.003.2b');
+insert into PSlot values ('PS.base.c5', 'PF0_1', '', 'WS.003.3a');
+insert into PSlot values ('PS.base.c6', 'PF0_1', '', 'WS.003.3b');
+
+--
+-- This patchfield will be renamed later into PF0_2 - so its
+-- slots references in pfname should follow
+--
+insert into PField values ('PF0_X', 'Phonelines basement');
+
+insert into PSlot values ('PS.base.ta1', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.ta2', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.ta3', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.ta4', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.ta5', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.ta6', 'PF0_X', '', '');
+
+insert into PSlot values ('PS.base.tb1', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.tb2', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.tb3', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.tb4', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.tb5', 'PF0_X', '', '');
+insert into PSlot values ('PS.base.tb6', 'PF0_X', '', '');
+
+insert into PField values ('PF1_1', 'Wallslots 1st floor');
+
+insert into PSlot values ('PS.1st.a1', 'PF1_1', '', 'WS.101.1a');
+insert into PSlot values ('PS.1st.a2', 'PF1_1', '', 'WS.101.1b');
+insert into PSlot values ('PS.1st.a3', 'PF1_1', '', 'WS.101.2a');
+insert into PSlot values ('PS.1st.a4', 'PF1_1', '', 'WS.101.2b');
+insert into PSlot values ('PS.1st.a5', 'PF1_1', '', 'WS.101.3a');
+insert into PSlot values ('PS.1st.a6', 'PF1_1', '', 'WS.101.3b');
+
+insert into PSlot values ('PS.1st.b1', 'PF1_1', '', 'WS.102.1a');
+insert into PSlot values ('PS.1st.b2', 'PF1_1', '', 'WS.102.1b');
+insert into PSlot values ('PS.1st.b3', 'PF1_1', '', 'WS.102.2a');
+insert into PSlot values ('PS.1st.b4', 'PF1_1', '', 'WS.102.2b');
+insert into PSlot values ('PS.1st.b5', 'PF1_1', '', 'WS.102.3a');
+insert into PSlot values ('PS.1st.b6', 'PF1_1', '', 'WS.102.3b');
+
+insert into PSlot values ('PS.1st.c1', 'PF1_1', '', 'WS.105.1a');
+insert into PSlot values ('PS.1st.c2', 'PF1_1', '', 'WS.105.1b');
+insert into PSlot values ('PS.1st.c3', 'PF1_1', '', 'WS.105.2a');
+insert into PSlot values ('PS.1st.c4', 'PF1_1', '', 'WS.105.2b');
+insert into PSlot values ('PS.1st.c5', 'PF1_1', '', 'WS.105.3a');
+insert into PSlot values ('PS.1st.c6', 'PF1_1', '', 'WS.105.3b');
+
+insert into PSlot values ('PS.1st.d1', 'PF1_1', '', 'WS.106.1a');
+insert into PSlot values ('PS.1st.d2', 'PF1_1', '', 'WS.106.1b');
+insert into PSlot values ('PS.1st.d3', 'PF1_1', '', 'WS.106.2a');
+insert into PSlot values ('PS.1st.d4', 'PF1_1', '', 'WS.106.2b');
+insert into PSlot values ('PS.1st.d5', 'PF1_1', '', 'WS.106.3a');
+insert into PSlot values ('PS.1st.d6', 'PF1_1', '', 'WS.106.3b');
+
+--
+-- Now we wire the wall connectors 1a-2a in room 001 to the
+-- patchfield. In the second update we make an error, and
+-- correct it after
+--
+update PSlot set backlink = 'WS.001.1a' where slotname = 'PS.base.a1';
+update PSlot set backlink = 'WS.001.1b' where slotname = 'PS.base.a3';
+select * from WSlot where roomno = '001' order by slotname;
+select * from PSlot where slotname ~ 'PS.base.a' order by slotname;
+update PSlot set backlink = 'WS.001.2a' where slotname = 'PS.base.a3';
+select * from WSlot where roomno = '001' order by slotname;
+select * from PSlot where slotname ~ 'PS.base.a' order by slotname;
+update PSlot set backlink = 'WS.001.1b' where slotname = 'PS.base.a2';
+select * from WSlot where roomno = '001' order by slotname;
+select * from PSlot where slotname ~ 'PS.base.a' order by slotname;
+
+--
+-- Same procedure for 2b-3b but this time updating the WSlot instead
+-- of the PSlot. Due to the triggers the result is the same:
+-- WSlot and corresponding PSlot point to each other.
+--
+update WSlot set backlink = 'PS.base.a4' where slotname = 'WS.001.2b';
+update WSlot set backlink = 'PS.base.a6' where slotname = 'WS.001.3a';
+select * from WSlot where roomno = '001' order by slotname;
+select * from PSlot where slotname ~ 'PS.base.a' order by slotname;
+update WSlot set backlink = 'PS.base.a6' where slotname = 'WS.001.3b';
+select * from WSlot where roomno = '001' order by slotname;
+select * from PSlot where slotname ~ 'PS.base.a' order by slotname;
+update WSlot set backlink = 'PS.base.a5' where slotname = 'WS.001.3a';
+select * from WSlot where roomno = '001' order by slotname;
+select * from PSlot where slotname ~ 'PS.base.a' order by slotname;
+
+insert into PField values ('PF1_2', 'Phonelines 1st floor');
+
+insert into PSlot values ('PS.1st.ta1', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.ta2', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.ta3', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.ta4', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.ta5', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.ta6', 'PF1_2', '', '');
+
+insert into PSlot values ('PS.1st.tb1', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.tb2', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.tb3', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.tb4', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.tb5', 'PF1_2', '', '');
+insert into PSlot values ('PS.1st.tb6', 'PF1_2', '', '');
+
+--
+-- Fix the wrong name for patchfield PF0_2
+--
+update PField set name = 'PF0_2' where name = 'PF0_X';
+
+select * from PSlot order by slotname;
+select * from WSlot order by slotname;
+
+--
+-- Install the central phone system and create the phone numbers.
+-- They are weired on insert to the patchfields. Again the
+-- triggers automatically tell the PSlots to update their
+-- backlink field.
+--
+insert into PLine values ('PL.001', '-0', 'Central call', 'PS.base.ta1');
+insert into PLine values ('PL.002', '-101', '', 'PS.base.ta2');
+insert into PLine values ('PL.003', '-102', '', 'PS.base.ta3');
+insert into PLine values ('PL.004', '-103', '', 'PS.base.ta5');
+insert into PLine values ('PL.005', '-104', '', 'PS.base.ta6');
+insert into PLine values ('PL.006', '-106', '', 'PS.base.tb2');
+insert into PLine values ('PL.007', '-108', '', 'PS.base.tb3');
+insert into PLine values ('PL.008', '-109', '', 'PS.base.tb4');
+insert into PLine values ('PL.009', '-121', '', 'PS.base.tb5');
+insert into PLine values ('PL.010', '-122', '', 'PS.base.tb6');
+insert into PLine values ('PL.015', '-134', '', 'PS.1st.ta1');
+insert into PLine values ('PL.016', '-137', '', 'PS.1st.ta3');
+insert into PLine values ('PL.017', '-139', '', 'PS.1st.ta4');
+insert into PLine values ('PL.018', '-362', '', 'PS.1st.tb1');
+insert into PLine values ('PL.019', '-363', '', 'PS.1st.tb2');
+insert into PLine values ('PL.020', '-364', '', 'PS.1st.tb3');
+insert into PLine values ('PL.021', '-365', '', 'PS.1st.tb5');
+insert into PLine values ('PL.022', '-367', '', 'PS.1st.tb6');
+insert into PLine values ('PL.028', '-501', 'Fax entrance', 'PS.base.ta2');
+insert into PLine values ('PL.029', '-502', 'Fax 1st floor', 'PS.1st.ta1');
+
+--
+-- Buy some phones, plug them into the wall and patch the
+-- phone lines to the corresponding patchfield slots.
+--
+insert into PHone values ('PH.hc001', 'Hicom standard', 'WS.001.1a');
+update PSlot set slotlink = 'PS.base.ta1' where slotname = 'PS.base.a1';
+insert into PHone values ('PH.hc002', 'Hicom standard', 'WS.002.1a');
+update PSlot set slotlink = 'PS.base.ta5' where slotname = 'PS.base.b1';
+insert into PHone values ('PH.hc003', 'Hicom standard', 'WS.002.2a');
+update PSlot set slotlink = 'PS.base.tb2' where slotname = 'PS.base.b3';
+insert into PHone values ('PH.fax001', 'Canon fax', 'WS.001.2a');
+update PSlot set slotlink = 'PS.base.ta2' where slotname = 'PS.base.a3';
+
+--
+-- Install a hub at one of the patchfields, plug a computers
+-- ethernet interface into the wall and patch it to the hub.
+--
+insert into Hub values ('base.hub1', 'Patchfield PF0_1 hub', 16);
+insert into System values ('orion', 'PC');
+insert into IFace values ('IF', 'orion', 'eth0', 'WS.002.1b');
+update PSlot set slotlink = 'HS.base.hub1.1' where slotname = 'PS.base.b2';
+
+--
+-- Now we take a look at the patchfield
+--
+select * from PField_v1 where pfname = 'PF0_1' order by slotname;
+select * from PField_v1 where pfname = 'PF0_2' order by slotname;
+
+--
+-- Finally we want errors
+--
+insert into PField values ('PF1_1', 'should fail due to unique index');
+update PSlot set backlink = 'WS.not.there' where slotname = 'PS.base.a1';
+update PSlot set backlink = 'XX.illegal' where slotname = 'PS.base.a1';
+update PSlot set slotlink = 'PS.not.there' where slotname = 'PS.base.a1';
+update PSlot set slotlink = 'XX.illegal' where slotname = 'PS.base.a1';
+insert into HSlot values ('HS', 'base.hub1', 1, '');
+insert into HSlot values ('HS', 'base.hub1', 20, '');
+delete from HSlot;
+insert into IFace values ('IF', 'notthere', 'eth0', '');
+insert into IFace values ('IF', 'orion', 'ethernet_interface_name_too_long', '');

data/test/plp/test_setup.sql

@@ -0,0 +1,931 @@
+
+create table Room (
+    roomno    varchar(8),
+    comment    text
+);
+
+create unique index Room_rno on Room using btree (roomno varchar_ops);
+
+
+create table WSlot (
+    slotname    varchar(20),
+    roomno    varchar(8),
+    slotlink    varchar(20),
+    backlink    varchar(20)
+);
+
+create unique index WSlot_name on WSlot using btree (slotname varchar_ops);
+
+
+create table PField (
+    name    text,
+    comment    text
+);
+
+create unique index PField_name on PField using btree (name text_ops);
+
+
+create table PSlot (
+    slotname    varchar(20),
+    pfname    text,
+    slotlink    varchar(20),
+    backlink    varchar(20)
+);
+
+create unique index PSlot_name on PSlot using btree (slotname varchar_ops);
+
+
+create table PLine (
+    slotname    varchar(20),
+    phonenumber    varchar(20),
+    comment    text,
+    backlink    varchar(20)
+);
+
+create unique index PLine_name on PLine using btree (slotname varchar_ops);
+
+
+create table Hub (
+    name    varchar(14),
+    comment    text,
+    nslots    int4
+);
+
+create unique index Hub_name on Hub using btree (name varchar_ops);
+
+
+create table HSlot (
+    slotname    varchar(20),
+    hubname    varchar(14),
+    slotno    int4,
+    slotlink    varchar(20)
+);
+
+create unique index HSlot_name on HSlot using btree (slotname varchar_ops);
+create index HSlot_hubname on HSlot using btree (hubname varchar_ops);
+
+
+create table System (
+    name    text,
+    comment    text
+);
+
+create unique index System_name on System using btree (name text_ops);
+
+
+create table IFace (
+    slotname    varchar(20),
+    sysname    text,
+    ifname    text,
+    slotlink    varchar(20)
+);
+
+create unique index IFace_name on IFace using btree (slotname varchar_ops);
+
+
+create table PHone (
+    slotname    varchar(20),
+    comment    text,
+    slotlink    varchar(20)
+);
+
+create unique index PHone_name on PHone using btree (slotname varchar_ops);
+
+
+-- ************************************************************
+-- * AFTER UPDATE on Room
+-- *    - If room no changes let wall slots follow
+-- ************************************************************
+create function tg_room_au() returns trigger as '
+    if !$Plans[tg["name"]]
+       $Plans[tg["name"]] = PL::Plan.new("update WSlot set roomno = $1
+                                              where roomno = $2",
+                                              ["varchar", "varchar"]).save
+    end
+    if new["roomno"] != old["roomno"]
+        $Plans[tg["name"]].exec(new["roomno"], old["roomno"])
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_room_au after update
+    on Room for each row execute procedure tg_room_au();
+
+
+-- ************************************************************
+-- * AFTER DELETE on Room
+-- *    - delete wall slots in this room
+-- ************************************************************
+create function tg_room_ad() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = PL::Plan.new("delete from WSlot 
+                                               where roomno = $1", 
+                                          ["varchar"]).save
+    end
+    $Plans[tg["name"]].exec([old["roomno"]])
+    PL::OK
+' language 'plruby';
+
+create trigger tg_room_ad after delete
+    on Room for each row execute procedure tg_room_ad();
+
+
+-- ************************************************************
+-- * BEFORE INSERT or UPDATE on WSlot
+-- *    - Check that room exists
+-- ************************************************************
+create function tg_wslot_biu() returns trigger as '
+    if !$Plans.key?(tg["name"])
+        $Plans[tg["name"]] = 
+             PL::Plan.new("select count(*) as cnt from Room 
+                             where roomno = $1", ["varchar"]).save
+    end
+    n = $Plans[tg["name"]].exec([new["roomno"]], 1)
+    if ! n["cnt"]
+        raise "Room #{new[''roomno'']} does not exist"
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_wslot_biu before insert or update
+    on WSlot for each row execute procedure tg_wslot_biu();
+
+
+-- ************************************************************
+-- * AFTER UPDATE on PField
+-- *    - Let PSlots of this field follow
+-- ************************************************************
+create function tg_pfield_au() returns trigger as '
+    if !$Plans.key?(tg["name"])
+        $Plans[tg["name"]] = 
+            PL::Plan.new("update PSlot set pfname = $1
+                            where pfname = $2", ["text", "text"]).save
+    end
+    if new["name"] != old["name"]
+        $Plans[tg["name"]].exec([new["name"], old["name"]])
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_pfield_au after update
+    on PField for each row execute procedure tg_pfield_au();
+
+
+-- ************************************************************
+-- * AFTER DELETE on PField
+-- *    - Remove all slots of this patchfield
+-- ************************************************************
+create function tg_pfield_ad() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = PL::Plan.new("delete from PSlot 
+                                             where pfname = $1", 
+                                          ["text"]).save
+    end
+    $Plans[tg["name"]].exec([old["name"]])
+    PL::OK
+' language 'plruby';
+
+create trigger tg_pfield_ad after delete
+    on PField for each row execute procedure tg_pfield_ad();
+
+
+-- ************************************************************
+-- * BEFORE INSERT or UPDATE on PSlot
+-- *    - Ensure that our patchfield does exist
+-- ************************************************************
+create function tg_pslot_biu() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = PL::Plan.new("select count(*) as cnt
+                                             from PField where name = $1", 
+                                          ["text"]).save
+    end
+    if ! $Plans[tg["name"]].exec([new["name"]], 1)["cnt"]
+        raise "Patchfield #{new[''name'']} does not exist"
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_pslot_biu before insert or update
+    on PSlot for each row execute procedure tg_pslot_biu();
+
+
+-- ************************************************************
+-- * AFTER UPDATE on System
+-- *    - If system name changes let interfaces follow
+-- ************************************************************
+create function tg_system_au() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = PL::Plan.new("update IFace set sysname = $1
+                                             where sysname = $2", 
+                                          ["text", "text"]).save
+    end
+    if new["name"] != old["name"]
+        $Plans[tg["name"]].exec([new["name"], old["name"]])
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_system_au after update
+    on System for each row execute procedure tg_system_au();
+
+
+-- ************************************************************
+-- * BEFORE INSERT or UPDATE on IFace
+-- *    - set the slotname to IF.sysname.ifname
+-- ************************************************************
+create function tg_iface_biu() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = PL::Plan.new("select count(*) as cnt from system
+                                             where name = $1", ["text"]).save
+    end
+    if ! $Plans[tg["name"]].exec([new["sysname"]], 1)["cnt"]
+        raise "system #{new[''sysname'']} does not exist"
+    end
+    sname = "IF.#{new[''sysname'']}.#{new[''ifname'']}"
+    if sname.size > 20
+        raise "IFace slotname #{sname} too long (20 char max)"
+    end
+    new["slotname"] = sname
+    new
+' language 'plruby';
+
+create trigger tg_iface_biu before insert or update
+    on IFace for each row execute procedure tg_iface_biu();
+
+
+-- ************************************************************
+-- * AFTER INSERT or UPDATE or DELETE on Hub
+-- *    - insert/delete/rename slots as required
+-- ************************************************************
+create function tg_hub_a() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = PL::Plan.new("update HSlot set hubname = $1
+                                             where hubname = $2", 
+                                          ["varchar", "varchar"]).save
+    end
+    case tg["op"]
+    when PL::INSERT
+        hub_adjustslots(new["name"], 0, new["nslots"].to_i)
+    when PL::UPDATE
+        if old["name"] != new["name"]
+            $Plans[tg["name"]].exec([new["name"], old["name"]])
+        end
+        hub_adjustslots(new["name"], old["nslots"].to_i, new["nslots"].to_i)
+    when PL::DELETE
+        hub_adjustslots(old["name"], old["nslots"].to_i, 0)
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_hub_a after insert or update or delete
+    on Hub for each row execute procedure tg_hub_a();
+
+-- ************************************************************
+-- * BEFORE INSERT or UPDATE on HSlot
+-- *    - prevent from manual manipulation
+-- *    - set the slotname to HS.hubname.slotno
+-- ************************************************************
+create function tg_hslot_biu() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = 
+           PL::Plan.new("select * from Hub where name = $1", ["varchar"]).save
+    end
+    hubrec = $Plans[tg["name"]].exec([new["hubname"]],1)
+    if !hubrec || new["slotno"].to_i < 1 || 
+       new["slotno"].to_i > hubrec["nslots"].to_i
+        raise "no manual manipulation of HSlot"
+    end
+    if (tg["og"] == PL::UPDATE) && (new["hubname"] != old["hubname"]) &&
+       $Plans[tg["name"]].exec([old["hubname"]], 1)
+        raise "no manual manipulation of HSlot"
+    end
+    sname = "HS.#{new[''hubname'']}.#{new[''slotno'']}"
+    if sname.size > 20
+        raise "HSlot slotname #{sname} too long (20 char max)"
+    end
+    new["slotname"] = sname
+    new
+' language 'plruby';
+
+create trigger tg_hslot_biu before insert or update
+    on HSlot for each row execute procedure tg_hslot_biu();
+
+
+-- ************************************************************
+-- * BEFORE DELETE on HSlot
+-- *    - prevent from manual manipulation
+-- ************************************************************
+create function tg_hslot_bd() returns trigger as '
+    if ! $Plans.key?(tg["name"])
+        $Plans[tg["name"]] = 
+           PL::Plan.new("select * from Hub where name = $1", ["varchar"]).save
+    end
+    hubrec = $Plans[tg["name"]].exec([old["hubname"]],1)
+    if !hubrec || old["slotno"].to_i > hubrec["nslots"].to_i
+        return PL::OK
+    end
+    raise "no manual manipulation of HSlot"
+' language 'plruby';
+
+create trigger tg_hslot_bd before delete
+    on HSlot for each row execute procedure tg_hslot_bd();
+
+
+-- ************************************************************
+-- * BEFORE INSERT on all slots
+-- *    - Check name prefix
+-- ************************************************************
+create function tg_chkslotname() returns trigger as '
+    if new["slotname"][0, 2] != args[0]
+        raise "slotname must begin with #{args[0]}"
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_chkslotname before insert
+    on PSlot for each row execute procedure tg_chkslotname('PS');
+
+create trigger tg_chkslotname before insert
+    on WSlot for each row execute procedure tg_chkslotname('WS');
+
+create trigger tg_chkslotname before insert
+    on PLine for each row execute procedure tg_chkslotname('PL');
+
+create trigger tg_chkslotname before insert
+    on IFace for each row execute procedure tg_chkslotname('IF');
+
+create trigger tg_chkslotname before insert
+    on PHone for each row execute procedure tg_chkslotname('PH');
+
+
+-- ************************************************************
+-- * BEFORE INSERT or UPDATE on all slots with slotlink
+-- *    - Set slotlink to empty string if NULL value given
+-- ************************************************************
+create function tg_chkslotlink() returns trigger as '
+    if ! new["slotlink"]
+        new["slotlink"] = ""
+        return new
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_chkslotlink before insert or update
+    on PSlot for each row execute procedure tg_chkslotlink();
+
+create trigger tg_chkslotlink before insert or update
+    on WSlot for each row execute procedure tg_chkslotlink();
+
+create trigger tg_chkslotlink before insert or update
+    on IFace for each row execute procedure tg_chkslotlink();
+
+create trigger tg_chkslotlink before insert or update
+    on HSlot for each row execute procedure tg_chkslotlink();
+
+create trigger tg_chkslotlink before insert or update
+    on PHone for each row execute procedure tg_chkslotlink();
+
+
+-- ************************************************************
+-- * BEFORE INSERT or UPDATE on all slots with backlink
+-- *    - Set backlink to empty string if NULL value given
+-- ************************************************************
+create function tg_chkbacklink() returns trigger as '
+    if ! new["backlink"]
+        new["backlink"] = ""
+        return new
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_chkbacklink before insert or update
+    on PSlot for each row execute procedure tg_chkbacklink();
+
+create trigger tg_chkbacklink before insert or update
+    on WSlot for each row execute procedure tg_chkbacklink();
+
+create trigger tg_chkbacklink before insert or update
+    on PLine for each row execute procedure tg_chkbacklink();
+
+
+-- ************************************************************
+-- * BEFORE UPDATE on PSlot
+-- *    - do delete/insert instead of update if name changes
+-- ************************************************************
+create function tg_pslot_bu() returns trigger as '
+    if ! $Plans.key?("pslot_bu_del")
+        $Plans["pslot_bu_del"] =
+            PL::Plan.new("delete from PSlot where slotname = $1", 
+                         ["varchar"]).save
+        $Plans["pslot_bu_ins"] =
+            PL::Plan.new("insert into PSlot
+                            (slotname, pfname, slotlink, backlink)
+                            values ($1, $2, $3, $4)",
+                           ["varchar", "varchar", "varchar", "varchar"]).save
+    end
+    if new["slotname"] != old["slotname"]
+       $Plans["pslot_bu_del"].exec([old["slotname"]])
+       $Plans["pslot_bu_ins"].exec([new["slotname"], new["pfname"],
+                                    new["slotlink"], new["backlink"]])
+       return PL::SKIP
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_pslot_bu before update
+    on PSlot for each row execute procedure tg_pslot_bu();
+
+
+-- ************************************************************
+-- * BEFORE UPDATE on WSlot
+-- *    - do delete/insert instead of update if name changes
+-- ************************************************************
+create function tg_wslot_bu() returns trigger as '
+    if ! $Plans.key?("wslot_bu_del")
+        $Plans["wslot_bu_del"] =
+            PL::Plan.new("delete from WSlot where slotname = $1", 
+                         ["varchar"]).save
+        $Plans["wslot_bu_ins"] =
+            PL::Plan.new("insert into WSlot
+                            (slotname, roomno, slotlink, backlink)
+                            values ($1, $2, $3, $4)",
+                           ["varchar", "int4", "varchar", "varchar"]).save
+    end
+    if new["slotname"] != old["slotname"]
+       $Plans["wslot_bu_del"].exec([old["slotname"]])
+       $Plans["wslot_bu_ins"].exec([new["slotname"], new["roomno"],
+                                    new["slotlink"], new["backlink"]])
+       return PL::SKIP
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_wslot_bu before update
+    on WSlot for each row execute procedure tg_Wslot_bu();
+
+
+-- ************************************************************
+-- * BEFORE UPDATE on PLine
+-- *    - do delete/insert instead of update if name changes
+-- ************************************************************
+create function tg_pline_bu() returns trigger as '
+    if ! $Plans.key?("pline_bu_del")
+        $Plans["pline_bu_del"] =
+            PL::Plan.new("delete from Pline where slotname = $1", 
+                         ["varchar"]).save
+        $Plans["pline_bu_ins"] =
+            PL::Plan.new("insert into Pline
+                            (slotname, phonenumber, comment, backlink)
+                            values ($1, $2, $3, $4)",
+                           ["varchar", "int4", "varchar", "varchar"]).save
+    end
+    if new["slotname"] != old["slotname"]
+       $Plans["pline_bu_del"].exec([old["slotname"]])
+       $Plans["pline_bu_ins"].exec([new["slotname"], new["phonenumber"],
+                                    new["comment"], new["backlink"]])
+       return PL::SKIP
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_pline_bu before update
+    on PLine for each row execute procedure tg_pline_bu();
+
+
+-- ************************************************************
+-- * BEFORE UPDATE on IFace
+-- *    - do delete/insert instead of update if name changes
+-- ************************************************************
+create function tg_iface_bu() returns trigger as '
+    if ! $Plans.key?("iface_bu_del")
+        $Plans["iface_bu_del"] =
+            PL::Plan.new("delete from Iface where slotname = $1", 
+                         ["varchar"]).save
+        $Plans["iface_bu_ins"] =
+            PL::Plan.new("insert into Iface
+                            (slotname, sysname, ifname, slotlink)
+                            values ($1, $2, $3, $4)",
+                           ["varchar", "varchar", "varchar", "varchar"]).save
+    end
+    if new["slotname"] != old["slotname"]
+       $Plans["iface_bu_del"].exec([old["slotname"]])
+       $Plans["iface_bu_ins"].exec([new["slotname"], new["sysname"],
+                                    new["ifname"], new["slotlink"]])
+       return PL::SKIP
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_iface_bu before update
+    on IFace for each row execute procedure tg_iface_bu();
+
+
+-- ************************************************************
+-- * BEFORE UPDATE on HSlot
+-- *    - do delete/insert instead of update if name changes
+-- ************************************************************
+create function tg_hslot_bu() returns trigger as '
+    if ! $Plans.key?("hslot_bu_del")
+        $Plans["hslot_bu_del"] =
+            PL::Plan.new("delete from Hslot where slotname = $1", 
+                         ["varchar"]).save
+        $Plans["hslot_bu_ins"] =
+            PL::Plan.new("insert into Hslot
+                            (slotname, hubname, slotno, slotlink)
+                            values ($1, $2, $3, $4)",
+                           ["varchar", "varchar", "int4", "varchar"]).save
+    end
+    if new["slotname"] != old["slotname"]
+       $Plans["hslot_bu_del"].exec([old["slotname"]])
+       $Plans["hslot_bu_ins"].exec([new["slotname"], new["hubname"],
+                                    new["slotno"], new["slotlink"]])
+       return PL::SKIP
+    end
+    PL::OK
+' language 'plruby';
+
+create trigger tg_hslot_bu before update
+    on HSlot for each row execute procedure tg_hslot_bu();
+
+
+-- ************************************************************
+-- * BEFORE UPDATE on PHone
+-- *    - do delete/insert instead of update if name changes
+-- ************************************************************
+create function tg_phone_bu() returns trigger as '
+    if ! $Plans.key?("phone_bu_del")
+        $Plans["phone_bu_del"] =
+            PL::Plan.new("delete from Phone where slotname = $1", 
+                         ["varchar"]).save
+        $Plans["phone_bu_ins"] =
+            PL::Plan.new("insert into Phone
+                            (slotname, comment, slotlink)
+                            values ($1, $2, $3)",
+                           ["varchar", "varchar", "varchar"]).save
+    end
+    if new["slotname"] != old["slotname"]
+       $Plans["phone_bu_del"].exec([old["slotname"]])
+       $Plans["phone_bu_ins"].exec([new["slotname"], new["comment"],
+                                    new["slotlink"]])
+       return PL::SKIP
+    end
+' language 'plruby';
+
+create trigger tg_phone_bu before update
+    on PHone for each row execute procedure tg_phone_bu();
+
+
+-- ************************************************************
+-- * AFTER INSERT or UPDATE or DELETE on slot with backlink
+-- *    - Ensure that the opponent correctly points back to us
+-- ************************************************************
+create function tg_backlink_a() returns trigger as '
+    case tg["op"]
+    when PL::INSERT
+        if ! new["backlink"].empty?
+            backlink_set(new["backlink"], new["slotname"])
+        end
+    when PL::UPDATE
+        if new["backlink"] != old["backlink"]
+            if ! old["backlink"].empty?
+                backlink_unset(old["backlink"], old["slotname"])
+            end
+            if ! new["backlink"].empty?
+                backlink_set(new["backlink"], new["slotname"])
+            end
+        else
+            if new["slotname"] != old["slotname"] && ! new["backlink"].empty?
+                slotlink_set(new["backlink"], new["slotname"])
+            end
+        end
+    when PL::DELETE
+        if ! old["backlink"].empty?
+            backlink_unset(old["backlink"], old["slotname"]);
+        end
+    end
+    PL::OK
+' language 'plruby';
+
+
+create trigger tg_backlink_a after insert or update or delete
+    on PSlot for each row execute procedure tg_backlink_a('PS');
+
+create trigger tg_backlink_a after insert or update or delete
+    on WSlot for each row execute procedure tg_backlink_a('WS');
+
+create trigger tg_backlink_a after insert or update or delete
+    on PLine for each row execute procedure tg_backlink_a('PL');
+
+-- ************************************************************
+-- * AFTER INSERT or UPDATE or DELETE on slot with slotlink
+-- *    - Ensure that the opponent correctly points back to us
+-- ************************************************************
+create function tg_slotlink_a() returns trigger as '
+    case tg["op"]
+    when PL::INSERT
+        if ! new["slotlink"].empty?
+            slotlink_set(new["slotlink"], new["slotname"])
+        end
+    when PL::UPDATE
+        if new["slotlink"] != old["slotlink"]
+            if ! old["slotlink"].empty?
+                stlotlink_unset(old["slotlink"], old["slotname"])
+            end
+            if ! new["slotlink"].empty?
+                slotlink_set(new["slotlink"], new["slotname"])
+            end
+        else
+            if new["slotname"] != old["slotname"] && ! new["slotlink"].empty?
+                slotlink_set(new["slotlink"], new["slotname"])
+            end
+        end
+    when PL::DELETE
+        if ! old["slotlink"].empty?
+            stlotlink_unset(old["slotlink"], old["slotname"])
+        end
+    end
+    PL::OK
+' language 'plruby';
+
+
+create trigger tg_slotlink_a after insert or update or delete
+    on PSlot for each row execute procedure tg_slotlink_a('PS');
+
+create trigger tg_slotlink_a after insert or update or delete
+    on WSlot for each row execute procedure tg_slotlink_a('WS');
+
+create trigger tg_slotlink_a after insert or update or delete
+    on IFace for each row execute procedure tg_slotlink_a('IF');
+
+create trigger tg_slotlink_a after insert or update or delete
+    on HSlot for each row execute procedure tg_slotlink_a('HS');
+
+create trigger tg_slotlink_a after insert or update or delete
+    on PHone for each row execute procedure tg_slotlink_a('PH');
+
+-- ************************************************************
+-- * Describe the backside of a patchfield slot
+-- ************************************************************
+create function pslot_backlink_view(varchar)
+returns text as '
+    if ! $Plans.key?("pslot_view")
+        $Plans["pslot_view"] =
+          PL::Plan.new("select * from PSlot where slotname = $1", 
+                       ["varchar"]).save
+    end
+    rec = $Plans["pslot_view"].exec([args[0]], 1)
+    return "" if ! rec
+    return "-" if rec["backlink"].empty?
+    bltype = rec["backlink"][0, 2]
+    case bltype
+    when "PL"
+        rec = PL.exec("select * from PLine where slotname = ''#{rec[''backlink'']}''", 1)
+        retval = "Phone line #{rec[''phonenumber''].strip}"
+        if ! rec["comment"].empty?
+            retval << " (#{rec[''comment'']})"
+        end
+        return retval
+    when "WS"
+        rec = PL.exec("select * from WSlot where slotname = ''#{rec[''backlink'']}''", 1)
+        retval = "#{rec[''slotname''].strip} in room "
+        retval << rec["roomno"].strip + " -> "
+        rec = PL.exec("select wslot_slotlink_view(''#{rec[''slotname'']}''::varchar) as ws_result", 1)
+        return retval + rec["ws_result"]
+    end
+    rec["backlink"]
+' language 'plruby';
+
+
+-- ************************************************************
+-- * Describe the front of a patchfield slot
+-- ************************************************************
+create function pslot_slotlink_view(varchar)
+returns text as '
+    if ! $Plans.key?("pslot_view")
+        $Plans["pslot_view"] =
+          PL::Plan.new("select * from PSlot where slotname = $1", 
+                       ["varchar"]).save
+    end
+    rec = $Plans["pslot_view"].exec([args[0]], 1)
+    return "" if ! rec
+    return "-" if rec["slotlink"].empty?
+    case rec["slotlink"][0, 2]
+    when "PS"
+        retval = rec["slotlink"].strip + " -> "
+        rec = PL.exec("select pslot_backlink_view(''#{rec[''slotlink'']}''::varchar) as bac", 1)
+        return retval + rec["bac"]
+    when "HS"
+        comm = PL.exec("select comment from Hub H, HSlot HS
+                where HS.slotname = ''#{rec[''slotlink'']}''
+                            and H.name = HS.hubname", 1)
+        retval = ""
+        if ! comm["comment"].empty?
+            retval << comm["comment"]
+        end
+        retval << " slot "
+        comm = PL.exec("select slotno from HSlot
+                            where slotname = ''#{rec[''slotlink'']}''", 1)
+        return retval + comm["slotno"].to_s
+    end
+    rec["slotlink"]
+' language 'plruby';
+
+
+-- ************************************************************
+-- * Describe the front of a wall connector slot
+-- ************************************************************
+create function wslot_slotlink_view(varchar)
+returns text as '
+    if ! $Plans.key?("wslot_view")
+        $Plans["wslot_view"] =
+          PL::Plan.new("select * from WSlot where slotname = $1", 
+                       ["varchar"]).save
+    end
+    rec = $Plans["wslot_view"].exec([args[0]], 1)
+    return "" if ! rec
+    return "-" if rec["slotlink"].empty?
+    case rec["slotlink"][0, 2]
+    when "PH"
+        rec = PL.exec("select * from PHone where slotname = ''#{rec[''slotlink'']}''", 1)
+        retval = "Phone " + rec["slotname"].strip
+        if ! rec["comment"].empty?
+            retval << " (#{rec[''comment'']})"
+        end
+        return retval
+    when "IF"
+        ifrow = PL.exec("select * from IFace where slotname = ''#{rec[''slotlink'']}''", 1)
+        syrow = PL.exec("select * from System where name = ''#{ifrow[''sysname'']}''", 1)
+        retval = syrow["name"] + " IF " + ifrow["ifname"]
+        if ! syrow["comment"].empty?
+            retval << " (#{syrow[''comment'']})"
+        end
+        return retval
+    end
+    rec["slotlink"]
+' language 'plruby';
+
+
+
+-- ************************************************************
+-- * View of a patchfield describing backside and patches
+-- ************************************************************
+create view Pfield_v1 as select PF.pfname, PF.slotname,
+    pslot_backlink_view(PF.slotname) as backside,
+    pslot_slotlink_view(PF.slotname) as patch
+    from PSlot PF;
+
+
+--
+--
+--
+
+create table plruby_singleton_methods (
+    name varchar(60),
+    args varchar(60),
+    body text,
+    comment text
+);
+
+
+create unique index plr_s_m_i on plruby_singleton_methods (name);
+
+insert into plruby_singleton_methods values
+('hub_adjustslots', 'name, oldsl, newsl', '
+    if ! $Plans.key?("hub_adjust_del")
+        $Plans["hub_adjust_del"] = 
+            PL::Plan.new("delete from HSlot 
+                            where hubname = $1 and slotno > $2",
+                           ["varchar", "int4"]).save
+        $Plans["hub_adjust_ins"] =
+            PL::Plan.new("insert into HSlot (slotname, hubname, slotno, slotlink)
+                            values ($1, $2, $3, $4)",
+                            ["varchar", "varchar", "int4", "varchar"]).save
+    end
+    return if oldsl == newsl
+    if newsl < oldsl
+        $Plans["hub_adjust_del"].exec([name, newsl])
+    else
+        (oldsl+1).upto(newsl) do |x|
+            $Plans["hub_adjust_ins"].exec(["HS.dummy", name, x, ""])
+        end
+    end
+', 'Support function to add/remove slots of Hub');
+
+insert into plruby_singleton_methods values
+('backlink_set', 'myname, blname', '
+    mytype = myname[0, 2]
+    link = mytype + blname[0, 2]
+    if link == "PLPL"
+        raise "backlink between two phone lines does not make sense"
+    end
+    if link == "PLWS" || link == "WSPL"
+        raise "direct link of phone line to wall slot not permitted"
+    end
+    rel = case mytype
+          when "PS"
+              "PSlot"
+          when "WS"
+              "WSlot"
+          when "PL"
+              "PLine"
+          else
+              raise "illegal backlink beginning with #{mytype}"
+          end
+    rec = PL.exec("select * from #{rel} where slotname = ''#{myname}''", 1)
+    if ! rec
+        raise "#{myname} does not exist in #{rel}"
+    end
+    if rec["backlink"] != blname
+       PL.exec("update #{rel} set backlink = ''#{blname}''
+                    where slotname = ''#{myname}''")
+    end
+', ' Support function to set the opponents backlink field
+ if it does not already point to the requested slot');
+
+insert into plruby_singleton_methods values
+('backlink_unset' , 'myname, blname', '
+    rel = case myname[0, 2]
+          when "PS"
+              "PSlot"
+          when "WS"
+              "WSlot"
+          when "PL"
+              "PLine"
+          else
+              raise "illegal backlink beginning with #{myname[0, 2]}"
+          end
+    rec = PL.exec("select * from #{rel} where slotname = ''#{myname}''", 1)
+    return if ! rec
+    if rec["backlink"] == blname
+       PL.exec("update #{rel} set backlink = ''''
+                    where slotname = ''#{myname}''")
+    end
+', ' Support function to clear out the backlink field if
+ it still points to specific slot');
+
+insert into plruby_singleton_methods values
+('slotlink_set', 'myname, blname', '
+    mytype = myname[0, 2]
+    link = mytype + blname[0, 2]
+    if link == "PHPH"
+        raise "slotlink between two phones does not make sense"
+    end
+    if link == "PHHS" || link == "HSPH"
+        raise "link of phone to hub does not make sense"
+    end
+    if link == "PHIF" || link == "IFPH"
+        raise "link of phone to hub does not make sense"
+    end
+    if link == "PSWS" || link == "WSPS"
+        raise "slotlink from patchslot to wallslot not permitted"
+    end
+    rel = case mytype
+          when "PS"
+              "PSlot"
+          when "WS"
+              "WSlot"
+          when "IF"
+              "IFace"
+          when "HS"
+              "HSlot"
+          when "PH"
+              "PHone"
+          else
+              raise "illegal slotlink beginning with <#{mytype}>"
+          end
+    rec = PL.exec("select * from #{rel} where slotname = ''#{myname}''", 1)
+    if ! rec
+        raise "#{myname} does not exists in #{rel}"
+    end
+    if rec["slotlink"] != blname
+       PL.exec("update #{rel} set slotlink = ''#{blname}''
+                    where slotname = ''#{myname}''")
+    end
+', ' Support function to set the opponents slotlink field
+ if it does not already point to the requested slot');
+
+insert into plruby_singleton_methods values
+('slotlink_unset', 'myname, blname', '
+    rel = case myname[0, 2]
+          when "PS"
+              "PSlot"
+          when "WS"
+              "WSlot"
+          when "IF"
+              "IFace"
+          when "HS"
+              "HSlot"
+          when "PH"
+              "PHone"
+          else
+              raise "illegal slotlink beginning with #{myname[0, 2]}"
+          end
+    rec = PL.exec("select * from #{rel} where slotname = ''#{myname}''", 1)
+    return if ! rec
+    if rec["slotlink"] == blname
+       PL.exec("update #{rel} set slotlink = ''''
+                    where slotname = ''#{myname}''")
+    end
+', ' Support function to clear out the slotlink field if
+ it still points to specific slot');
+