sequel_postgresql_triggers 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e4f87e2b711aa431fa2c58e7775e2f6f7263f86a
-  data.tar.gz: 3053bc8ad102ad616fdb1aa05240e2564553366d
+SHA256:
+  metadata.gz: 3b5d81f0071528eb70130d8ebe3093a365c0d024e250583d8ea7e35d5b7af263
+  data.tar.gz: 18bb2a79d2642636f34fce1f0f4be315e90592c3be8c8a8d5f587d753061d360
 SHA512:
-  metadata.gz: 139573dfcf3b39b056a844c91f8b397b0a72d38365601624717a60d292a3f92c9213fc981402f62b7dccacedbe50ef35f6ebb2c292e1427c6312538545889b75
-  data.tar.gz: 0b75cb7a59a2f274e988274bf7a5d999bf39eef2878b6685b7a68f8bbfe4296e81c86366a42d9f705da7cc15d9c7a34a93ab083c45d550113f49616ad8ef1117
+  metadata.gz: 615949150a244df98c696da8472ebeb40ae5c09812457f5ecca61197a10754e489c431a68d2a44df91eb5f17e229e6e39b4d3b4f4cf6ca28be520b2145345e3c
+  data.tar.gz: ca67361ebd569731121ad3f482e47d0320d0658144fd4d7bd21734fcf3542ae84d3fb592483813980fbb4f7e8b52866575c4f0c7efb8566d34760d884f66207c

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2016 Jeremy Evans
+Copyright (c) 2008-2017 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -7,6 +7,7 @@ a user to easily handle the following types of columns:
 * Counter/Sum Caches
 * Immutable Columns
 * Touch Propogation
+* Foreign Key Arrays (Referential Integrity Checks)
 
 It handles these internally to the database via triggers, so even if
 other applications access the database (without using Sequel), things
@@ -177,6 +178,26 @@ column :: name of timestamp column to be touched
 expr :: hash or array that represents the columns that define the relationship
 opts :: options hash
 
+=== Foreign Key Arrays - pgt_foreign_key_array
+
+This takes a single options hash, and sets up triggers on both
+tables involved.  The table with the foreign key array has insert/update
+triggers to make sure newly inserted/updated rows reference valid rows
+in the referenced table.  The table being referenced has update/delete
+triggers to make sure the value before update or delete is not still
+being referenced.
+
+Note that this will not catch all referential integrity violations, but
+it should catch the most common ones.
+
+Options:
+:table :: table with foreign key array
+:column :: foreign key array column
+:referenced_table :: table referenced by foreign key array
+:referenced_column :: column referenced by foreign key array (generally primary key)
+:referenced_function_name :: function name for trigger function on referenced table
+:referenced_trigger_name :: trigger name for referenced table
+
 == License
 
 This library is released under the MIT License.  See the MIT-LICENSE

data/lib/sequel/extensions/pg_triggers.rb

@@ -213,6 +213,66 @@ module Sequel
         SQL
       end
 
+      def pgt_foreign_key_array(opts={})
+        table, column, rtable, rcolumn = opts.values_at(:table, :column, :referenced_table, :referenced_column)
+        trigger_name = opts[:trigger_name] || "pgt_fka_#{column}"
+        function_name = opts[:function_name] || "pgt_fka_#{table}__#{column}"
+        rtrigger_name = opts[:referenced_trigger_name] || "pgt_rfka_#{column}"
+        rfunction_name = opts[:referenced_function_name] || "pgt_rfka_#{table}__#{column}"
+        col = quote_identifier(column)
+        tab = quote_identifier(table)
+        rcol = quote_identifier(rcolumn)
+        rtab = quote_identifier(rtable)
+
+        pgt_trigger(table, trigger_name, function_name, [:insert, :update], <<-SQL)
+        DECLARE
+          arr #{tab}.#{col}%TYPE;
+          temp_count1 int;
+          temp_count2 int;
+        BEGIN
+          arr := NEW.#{col};
+          temp_count1 := array_ndims(arr);
+          IF arr IS NULL OR temp_count1 IS NULL THEN
+            RETURN NEW;
+          END IF;
+
+          IF temp_count1 IS DISTINCT FROM 1 THEN
+              RAISE EXCEPTION 'Foreign key array #{tab}.#{col} has more than 1 dimension: %, dimensions: %', arr, temp_count1;
+          END IF;
+
+          SELECT count(*) INTO temp_count1 FROM unnest(arr);
+          SELECT count(*) INTO temp_count2 FROM (SELECT DISTINCT * FROM unnest(arr)) AS t;
+          IF temp_count1 IS DISTINCT FROM temp_count2 THEN
+              RAISE EXCEPTION 'Duplicate entry in foreign key array #{tab}.#{col}: %', arr;
+          END IF;
+
+          SELECT COUNT(*) INTO temp_count1 FROM #{rtab} WHERE #{rcol} = ANY(arr);
+          temp_count2 := array_length(arr, 1);
+          IF temp_count1 IS DISTINCT FROM temp_count2 THEN
+              RAISE EXCEPTION 'Entry in foreign key array #{tab}.#{col} not in referenced column #{rtab}.#{rcol}: %', arr;
+          END IF;
+
+          RETURN NEW;
+        END;
+        SQL
+
+        pgt_trigger(rtable, rtrigger_name, rfunction_name, [:delete, :update], <<-SQL)
+        DECLARE
+          val #{rtab}.#{rcol}%TYPE;
+          temp_count int;
+        BEGIN
+          val := OLD.#{rcol};
+          IF (TG_OP = 'DELETE') OR val IS DISTINCT FROM NEW.#{rcol} THEN
+            SELECT COUNT(*) INTO temp_count FROM #{tab} WHERE #{col} @> ARRAY[val];
+            IF temp_count IS DISTINCT FROM 0 THEN
+                RAISE EXCEPTION 'Entry in referenced column #{rtab}.#{rcol} still in foreign key array #{tab}.#{col}: %, count: %', val, temp_count;
+            END IF;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+      end
+
       private
 
       # Add or replace a function that returns trigger to handle the action,

data/spec/sequel_postgresql_triggers_spec.rb

@@ -14,6 +14,7 @@ else
   puts "Running specs with extension"
   DB.extension :pg_triggers 
 end
+DB.extension :pg_array
 
 describe "PostgreSQL Triggers" do
   before do
@@ -28,8 +29,8 @@ describe "PostgreSQL Triggers" do
       DB.create_table(:accounts){integer :id; integer :num_entries, :default=>0}
       DB.create_table(:entries){integer :id; integer :account_id}
       DB.pgt_counter_cache(:accounts, :id, :num_entries, :entries, :account_id, :function_name=>:spgt_counter_cache)
-      DB[:accounts] << {:id=>1}
-      DB[:accounts] << {:id=>2}
+      DB[:accounts].insert(:id=>1)
+      DB[:accounts].insert(:id=>2)
     end
 
     after do
@@ -40,13 +41,13 @@ describe "PostgreSQL Triggers" do
     it "Should modify counter cache when adding or removing records" do
       DB[:accounts].order(:id).select_map(:num_entries).must_equal [0, 0]
 
-      DB[:entries] << {:id=>1, :account_id=>1}
+      DB[:entries].insert(:id=>1, :account_id=>1)
       DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 0]
 
-      DB[:entries] << {:id=>2, :account_id=>1}
+      DB[:entries].insert(:id=>2, :account_id=>1)
       DB[:accounts].order(:id).select_map(:num_entries).must_equal [2, 0]
       
-      DB[:entries] << {:id=>3, :account_id=>nil}
+      DB[:entries].insert(:id=>3, :account_id=>nil)
       DB[:accounts].order(:id).select_map(:num_entries).must_equal [2, 0]
       
       DB[:entries].where(:id=>3).update(:account_id=>2)
@@ -87,12 +88,12 @@ describe "PostgreSQL Triggers" do
     end
 
     it "Should set the column upon insertion and ignore modifications afterward" do
-      DB[:accounts] << {:id=>1}
+      DB[:accounts].insert(:id=>1)
       t = DB[:accounts].get(:added_on)
       t.strftime('%F').must_equal Date.today.strftime('%F')
       DB[:accounts].update(:added_on=>Date.today - 60)
       DB[:accounts].get(:added_on).must_equal t
-      DB[:accounts] << {:id=>2}
+      DB[:accounts].insert(:id=>2)
       ds = DB[:accounts].select(:added_on)
       DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>1)).as(:x)).first[:x].must_equal true
       DB[:accounts].filter(:id=>1).update(:id=>3)
@@ -104,7 +105,7 @@ describe "PostgreSQL Triggers" do
     before do
       DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
       DB.pgt_immutable(:accounts, :balance, :function_name=>:spgt_immutable)
-      DB[:accounts] << {:id=>1}
+      DB[:accounts].insert(:id=>1)
     end
 
     after do
@@ -128,7 +129,7 @@ describe "PostgreSQL Triggers" do
     it "Should handle NULL values correctly" do
       proc{DB[:accounts].update(:balance=>nil)}.must_raise(Sequel::DatabaseError)
       DB[:accounts].delete
-      DB[:accounts] << {:id=>1, :balance=>nil}
+      DB[:accounts].insert(:id=>1, :balance=>nil)
       DB[:accounts].update(:balance=>nil)
       proc{DB[:accounts].update(:balance=>0)}.must_raise(Sequel::DatabaseError)
     end
@@ -139,8 +140,8 @@ describe "PostgreSQL Triggers" do
       DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
       DB.create_table(:entries){integer :id; integer :account_id; integer :amount}
       DB.pgt_sum_cache(:accounts, :id, :balance, :entries, :account_id, :amount, :function_name=>:spgt_sum_cache)
-      DB[:accounts] << {:id=>1}
-      DB[:accounts] << {:id=>2}
+      DB[:accounts].insert(:id=>1)
+      DB[:accounts].insert(:id=>2)
     end
 
     after do
@@ -151,13 +152,13 @@ describe "PostgreSQL Triggers" do
     it "Should modify sum cache when adding, updating, or removing records" do
       DB[:accounts].order(:id).select_map(:balance).must_equal [0, 0]
 
-      DB[:entries] << {:id=>1, :account_id=>1, :amount=>100}
+      DB[:entries].insert(:id=>1, :account_id=>1, :amount=>100)
       DB[:accounts].order(:id).select_map(:balance).must_equal [100, 0]
 
-      DB[:entries] << {:id=>2, :account_id=>1, :amount=>200}
+      DB[:entries].insert(:id=>2, :account_id=>1, :amount=>200)
       DB[:accounts].order(:id).select_map(:balance).must_equal [300, 0]
       
-      DB[:entries] << {:id=>3, :account_id=>nil, :amount=>500}
+      DB[:entries].insert(:id=>3, :account_id=>nil, :amount=>500)
       DB[:accounts].order(:id).select_map(:balance).must_equal [300, 0]
       
       DB[:entries].where(:id=>3).update(:account_id=>2)
@@ -194,8 +195,8 @@ describe "PostgreSQL Triggers" do
       DB.create_table(:accounts){integer :id; integer :nonzero_entries_count, :default=>0}
       DB.create_table(:entries){integer :id; integer :account_id; integer :amount}
       DB.pgt_sum_cache(:accounts, :id, :nonzero_entries_count, :entries, :account_id, Sequel.case({0=>0}, 1, :amount), :function_name=>:spgt_sum_cache)
-      DB[:accounts] << {:id=>1}
-      DB[:accounts] << {:id=>2}
+      DB[:accounts].insert(:id=>1)
+      DB[:accounts].insert(:id=>2)
     end
 
     after do
@@ -206,13 +207,13 @@ describe "PostgreSQL Triggers" do
     it "Should modify sum cache when adding, updating, or removing records" do
       DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [0, 0]
 
-      DB[:entries] << {:id=>1, :account_id=>1, :amount=>100}
+      DB[:entries].insert(:id=>1, :account_id=>1, :amount=>100)
       DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 0]
 
-      DB[:entries] << {:id=>2, :account_id=>1, :amount=>200}
+      DB[:entries].insert(:id=>2, :account_id=>1, :amount=>200)
       DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
 
-      DB[:entries] << {:id=>3, :account_id=>nil, :amount=>500}
+      DB[:entries].insert(:id=>3, :account_id=>nil, :amount=>500)
       DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
 
       DB[:entries].where(:id=>3).update(:account_id=>2)
@@ -261,8 +262,8 @@ describe "PostgreSQL Triggers" do
         :function_name=>:spgt_stm_cache,
         :join_function_name=>:spgt_stm_cache_join
       )
-      DB[:parents] << {:id=>1}
-      DB[:parents] << {:id=>2}
+      DB[:parents].insert(:id=>1)
+      DB[:parents].insert(:id=>2)
     end
 
     after do
@@ -274,23 +275,23 @@ describe "PostgreSQL Triggers" do
     it "Should modify sum cache when adding, updating, or removing records" do
       DB[:parents].order(:id).select_map(:balance).must_equal [0, 0]
 
-      DB[:children] << {:id=>1, :amount=>100}
-      DB[:links] << {:parent_id=>1, :child_id=>1}
+      DB[:children].insert(:id=>1, :amount=>100)
+      DB[:links].insert(:parent_id=>1, :child_id=>1)
       DB[:parents].order(:id).select_map(:balance).must_equal [100, 0]
 
-      DB[:children] << {:id=>2, :amount=>200}
-      DB[:links] << {:parent_id=>1, :child_id=>2}
+      DB[:children].insert(:id=>2, :amount=>200)
+      DB[:links].insert(:parent_id=>1, :child_id=>2)
       DB[:parents].order(:id).select_map(:balance).must_equal [300, 0]
 
-      DB[:children] << {:id=>3, :amount=>500}
+      DB[:children].insert(:id=>3, :amount=>500)
       DB[:parents].order(:id).select_map(:balance).must_equal [300, 0]
-      DB[:links] << {:parent_id=>2, :child_id=>3}
+      DB[:links].insert(:parent_id=>2, :child_id=>3)
       DB[:parents].order(:id).select_map(:balance).must_equal [300, 500]
 
       DB[:links].where(:parent_id=>2, :child_id=>3).update(:parent_id=>1)
       DB[:parents].order(:id).select_map(:balance).must_equal [800, 0]
 
-      DB[:children] << {:id=>4, :amount=>400}
+      DB[:children].insert(:id=>4, :amount=>400)
       DB[:links].where(:parent_id=>1, :child_id=>3).update(:child_id=>4)
       DB[:parents].order(:id).select_map(:balance).must_equal [700, 0]
 
@@ -309,7 +310,7 @@ describe "PostgreSQL Triggers" do
       DB[:links].where(:parent_id=>1, :child_id=>2).update(:child_id=>3)
       DB[:parents].order(:id).select_map(:balance).must_equal [1200, 1000]
 
-      DB[:links] << {:parent_id=>2, :child_id=>4}
+      DB[:links].insert(:parent_id=>2, :child_id=>4)
       DB[:parents].order(:id).select_map(:balance).must_equal [1200, 1800]
 
       DB[:children].filter(:id=>4).delete
@@ -318,7 +319,7 @@ describe "PostgreSQL Triggers" do
       DB[:links].filter(:parent_id=>1, :child_id=>1).delete
       DB[:parents].order(:id).select_map(:balance).must_equal [1000, 1000]
 
-      DB[:children] << {:id=>4, :amount=>400}
+      DB[:children].insert(:id=>4, :amount=>400)
       DB[:parents].order(:id).select_map(:balance).must_equal [1000, 1400]
 
       DB[:children].delete
@@ -354,8 +355,8 @@ describe "PostgreSQL Triggers" do
         :function_name=>:spgt_stm_cache,
         :join_function_name=>:spgt_stm_cache_join
       )
-      DB[:parents] << {:id=>1}
-      DB[:parents] << {:id=>2}
+      DB[:parents].insert(:id=>1)
+      DB[:parents].insert(:id=>2)
     end
 
     after do
@@ -367,23 +368,23 @@ describe "PostgreSQL Triggers" do
     it "Should modify sum cache when adding, updating, or removing records" do
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [0, 0]
 
-      DB[:children] << {:id=>1, :amount=>100}
-      DB[:links] << {:parent_id=>1, :child_id=>1}
+      DB[:children].insert(:id=>1, :amount=>100)
+      DB[:links].insert(:parent_id=>1, :child_id=>1)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 0]
 
-      DB[:children] << {:id=>2, :amount=>200}
-      DB[:links] << {:parent_id=>1, :child_id=>2}
+      DB[:children].insert(:id=>2, :amount=>200)
+      DB[:links].insert(:parent_id=>1, :child_id=>2)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
 
-      DB[:children] << {:id=>3, :amount=>500}
+      DB[:children].insert(:id=>3, :amount=>500)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
-      DB[:links] << {:parent_id=>2, :child_id=>3}
+      DB[:links].insert(:parent_id=>2, :child_id=>3)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
 
       DB[:links].where(:parent_id=>2, :child_id=>3).update(:parent_id=>1)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [3, 0]
 
-      DB[:children] << {:id=>4, :amount=>400}
+      DB[:children].insert(:id=>4, :amount=>400)
       DB[:links].where(:parent_id=>1, :child_id=>3).update(:child_id=>4)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [3, 0]
 
@@ -402,7 +403,7 @@ describe "PostgreSQL Triggers" do
       DB[:links].where(:parent_id=>1, :child_id=>2).update(:child_id=>3)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
 
-      DB[:links] << {:parent_id=>2, :child_id=>4}
+      DB[:links].insert(:parent_id=>2, :child_id=>4)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 2]
 
       DB[:children].filter(:id=>4).delete
@@ -411,7 +412,7 @@ describe "PostgreSQL Triggers" do
       DB[:links].filter(:parent_id=>1, :child_id=>1).delete
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 1]
 
-      DB[:children] << {:id=>4, :amount=>400}
+      DB[:children].insert(:id=>4, :amount=>400)
       DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
 
       DB[:children].delete
@@ -443,10 +444,10 @@ describe "PostgreSQL Triggers" do
     end
 
     it "Should set the column always to the current timestamp" do
-      DB[:accounts] << {:id=>1}
+      DB[:accounts].insert(:id=>1)
       t = DB[:accounts].get(:changed_on)
       t.strftime('%F').must_equal Date.today.strftime('%F')
-      DB[:accounts] << {:id=>2}
+      DB[:accounts].insert(:id=>2)
       ds = DB[:accounts].select(:changed_on)
       DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>1)).as(:x)).first[:x].must_equal true
       DB[:accounts].filter(:id=>1).update(:id=>3)
@@ -470,9 +471,9 @@ describe "PostgreSQL Triggers" do
       DB.pgt_touch(:children, :parents, :changed_on, {:id1=>:parent_id1}, :function_name=>:spgt_touch)
       d = Date.today
       d30 = Date.today - 30
-      DB[:parents] << {:id1=>1, :changed_on=>d30}
-      DB[:parents] << {:id1=>2, :changed_on=>d30}
-      DB[:children] << {:id=>1, :parent_id1=>1}
+      DB[:parents].insert(:id1=>1, :changed_on=>d30)
+      DB[:parents].insert(:id1=>2, :changed_on=>d30)
+      DB[:children].insert(:id=>1, :parent_id1=>1)
       DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.must_equal [d.strftime('%F'), d30.strftime('%F')]
 
       DB[:parents].update(:changed_on=>d30)
@@ -500,7 +501,7 @@ describe "PostgreSQL Triggers" do
       DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.must_equal [d30.strftime('%F'), d.strftime('%F')]
 
       DB[:parents].update(:changed_on=>d30)
-      DB[:children] << {:id=>2, :parent_id1=>nil}
+      DB[:children].insert(:id=>2, :parent_id1=>nil)
       DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.must_equal [d30.strftime('%F'), d30.strftime('%F')]
       DB[:children].where(:id=>2).delete
       DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.must_equal [d30.strftime('%F'), d30.strftime('%F')]
@@ -508,8 +509,8 @@ describe "PostgreSQL Triggers" do
 
     it "Should update the timestamp column of the related table when there is a composite foreign key" do
       DB.pgt_touch(:children, :parents, :changed_on, {:id1=>:parent_id1, :id2=>:parent_id2}, :function_name=>:spgt_touch)
-      DB[:parents] << {:id1=>1, :id2=>2, :changed_on=>Date.today - 30}
-      DB[:children] << {:id=>1, :parent_id1=>1, :parent_id2=>2}
+      DB[:parents].insert(:id1=>1, :id2=>2, :changed_on=>Date.today - 30)
+      DB[:children].insert(:id=>1, :parent_id1=>1, :parent_id2=>2)
       DB[:parents].get(:changed_on).strftime('%F').must_equal Date.today.strftime('%F')
       DB[:parents].update(:changed_on=>Date.today - 30)
       DB[:children].update(:id=>2)
@@ -523,8 +524,8 @@ describe "PostgreSQL Triggers" do
       DB.pgt_touch(:children, :parents, :changed_on, {:id1=>:parent_id1}, :function_name=>:spgt_touch)
       @spgt_touch2 = true
       DB.pgt_touch(:parents, :children, :changed_on, {:id=>:child_id}, :function_name=>:spgt_touch2)
-      DB[:parents] << {:id1=>1, :child_id=>1, :changed_on=>Date.today - 30}
-      DB[:children] << {:id=>1, :parent_id1=>1, :changed_on=>Date.today - 30}
+      DB[:parents].insert(:id1=>1, :child_id=>1, :changed_on=>Date.today - 30)
+      DB[:children].insert(:id=>1, :parent_id1=>1, :changed_on=>Date.today - 30)
       DB[:parents].get(:changed_on).strftime('%F').must_equal Date.today.strftime('%F')
       DB[:children].get(:changed_on).strftime('%F').must_equal Date.today.strftime('%F')
       time = DB[:parents].get(:changed_on)
@@ -542,11 +543,51 @@ describe "PostgreSQL Triggers" do
 
     it "Should update the timestamp on the related table if that timestamp is initially NULL" do
       DB.pgt_touch(:children, :parents, :changed_on, {:id1=>:parent_id1}, :function_name=>:spgt_touch)
-      DB[:parents] << {:id1=>1, :changed_on=>nil}
-      DB[:children] << {:id=>1, :parent_id1=>1}
+      DB[:parents].insert(:id1=>1, :changed_on=>nil)
+      DB[:children].insert(:id=>1, :parent_id1=>1)
       changed_on = DB[:parents].get(:changed_on)
       changed_on.wont_equal nil
       changed_on.strftime('%F').must_equal Date.today.strftime('%F')
     end
   end
+
+  describe "PostgreSQL Array Foreign Key Trigger" do
+    before do
+      DB.create_table(:accounts){Integer :id, :primary_key=>true}
+      DB.create_table(:entries){Integer :id, :primary_key=>true; column :account_ids, 'integer[]'}
+      DB.pgt_foreign_key_array(:table=>:entries, :column=>:account_ids, :referenced_table=>:accounts, :referenced_column=>:id, :function_name=>:spgt_foreign_key_array, :referenced_function_name=>:spgt_referenced_foreign_key_array)
+    end
+
+    after do
+      DB.drop_table(:entries, :accounts)
+      DB.drop_function(:spgt_foreign_key_array)
+      DB.drop_function(:spgt_referenced_foreign_key_array)
+    end
+
+    it "should raise error for queries that violate referential integrity, and allow other queries" do
+      proc{DB[:entries].insert(:id=>10, :account_ids=>Sequel.pg_array([1]))}.must_raise Sequel::DatabaseError
+      DB[:entries].insert(:id=>10, :account_ids=>nil)
+      DB[:entries].update(:account_ids=>Sequel.pg_array([], :integer))
+      DB[:accounts].insert(:id=>1)
+      proc{DB[:entries].insert(:id=>10, :account_ids=>Sequel.pg_array([1, 1]))}.must_raise Sequel::DatabaseError
+      DB[:entries].update(:account_ids=>Sequel.pg_array([1]))
+      proc{DB[:entries].update(:account_ids=>Sequel.pg_array([2]))}.must_raise Sequel::DatabaseError
+      DB[:accounts].insert(:id=>2)
+      proc{DB[:entries].insert(:id=>10, :account_ids=>Sequel.pg_array([[1], [2]]))}.must_raise Sequel::DatabaseError
+      DB[:entries].update(:account_ids=>Sequel.pg_array([2]))
+      DB[:entries].all.must_equal [{:id=>10, :account_ids=>[2]}]
+      DB[:entries].update(:account_ids=>Sequel.pg_array([1, 2]))
+      DB[:entries].all.must_equal [{:id=>10, :account_ids=>[1, 2]}]
+      DB[:entries].update(:account_ids=>Sequel.pg_array([1]))
+      DB[:accounts].where(:id=>1).update(:id=>1)
+      DB[:accounts].where(:id=>2).update(:id=>3)
+      proc{DB[:accounts].where(:id=>1).update(:id=>2)}.must_raise Sequel::DatabaseError
+      proc{DB[:accounts].where(:id=>1).delete}.must_raise Sequel::DatabaseError
+      DB[:accounts].where(:id=>3).count.must_equal 1
+      DB[:accounts].where(:id=>3).delete
+      proc{DB[:accounts].delete}.must_raise Sequel::DatabaseError
+      DB[:entries].delete
+      DB[:accounts].delete
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_postgresql_triggers
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-08 00:00:00.000000000 Z
+date: 2018-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -63,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Database enforced timestamps, immutable columns, counter/sum caches, and