sequel_postgresql_triggers 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4d2e84d8e162f972268dc9839f8f744651ff15ca
-  data.tar.gz: 343a12a7c9531e694a92eeb1a037821095401bc2
+  metadata.gz: e4f87e2b711aa431fa2c58e7775e2f6f7263f86a
+  data.tar.gz: 3053bc8ad102ad616fdb1aa05240e2564553366d
 SHA512:
-  metadata.gz: 931984b649f29b90b738e00546c0c388fbea363136afc736cfcd69a0ff69b36d90ec5f429d2f5c3157b41b246eb9d9aaa13798f30c5eb12a205ed6f4bbe27c54
-  data.tar.gz: 7061eb0436fbe68db834aa130b503a834871bc2f554025fd851ce2411edd3bf964697d84a1feb01a979e40f644862b15ffd386d967a02849ca9b6c0ac45af61f
+  metadata.gz: 139573dfcf3b39b056a844c91f8b397b0a72d38365601624717a60d292a3f92c9213fc981402f62b7dccacedbe50ef35f6ebb2c292e1427c6312538545889b75
+  data.tar.gz: 0b75cb7a59a2f274e988274bf7a5d999bf39eef2878b6685b7a68f8bbfe4296e81c86366a42d9f705da7cc15d9c7a34a93ab083c45d550113f49616ad8ef1117

data/README.rdoc

@@ -100,6 +100,10 @@ or deleted from, records in the main table are updated with the
 count of the corresponding records in the counted table.  The counter
 cache column must have a default of 0 for this to work correctly.
 
+Use pgt_sum_cache with a Sequel expression in summed_column to
+handle any custom logic such as a counter cache that only counts
+certain rows.
+
 Arguments:
 main_table :: name of table holding counter cache column
 main_table_id_column :: column in main table matching counted_table_id_column in counted_table
@@ -115,13 +119,17 @@ of records in the main table, it stores the sum on one of the
 columns in summed table. The sum cache column must have a default
 of 0 for this to work correctly.
 
+Use a Sequel expression in summed_column to handle any custom
+logic such as a counter cache that only counts certain rows, or a
+sum cache that sums the length of a string column.
+
 Arguments:
 main_table :: name of table holding counter cache column
 main_table_id_column :: column in main table matching counted_table_id_column in counted_table
 sum_column :: column in main table containing the sum cache
 summed_table :: name of table being summed
 summed_table_id_column :: column in summed_table matching main_table_id_column in main_table
-summed_column :: column in summed_table being summed
+summed_column :: column in summed_table being summed or a Sequel expression to be evaluated in the context of summed_table
 opts :: options hash
 
 === Sum Through Many Cache - pgt_sum_through_many_cache
@@ -129,6 +137,8 @@ opts :: options hash
 Similar to pgt_sum_cache, except instead of a one-to-many relationship,
 it supports a many-to-many relationship with a single join table. The
 sum cache column must have a default of 0 for this to work correctly.
+Use a Sequel expression in summed_column to handle any custom logic.
+See pgt_sum_cache for details.
 
 This takes a single options hash argument, supporting the following options
 in addition to the standard options:
@@ -137,8 +147,10 @@ in addition to the standard options:
 :sum_column :: column in main table containing the sum cache, must be NOT NULL and default to 0
 :summed_table :: name of table being summed
 :summed_table_id_column :: primary key column in summed_table referenced by summed_table_fk_column (default: :id)
-:summed_column :: column in summed_table being summed, must be NOT NULL
+:summed_column :: column in summed_table being summed or a Sequel expression to be evaluated in the context of summed_table, must be NOT NULL
 :join_table :: name of table which joins main_table with summed_table
+:join_trigger_name :: name of trigger for join table
+:join_function_name :: name of trigger function for join table
 :main_table_fk_column :: column in join_table referencing main_table_id_column, must be NOT NULL
 :summed_table_fk_column :: column in join_table referencing summed_table_id_column, must be NOT NULL
 

data/lib/sequel/extensions/pg_triggers.rb

@@ -73,20 +73,22 @@ module Sequel
 
         table = quote_schema_table(main_table)
         id_column = quote_identifier(summed_table_id_column)
-        summed_column = quote_identifier(summed_column)
+
+        new_table_summed_column = literal(Sequel.deep_qualify(Sequel.lit("NEW"), summed_column))
+        old_table_summed_column = literal(Sequel.deep_qualify(Sequel.lit("OLD"), summed_column))
         main_column = quote_identifier(main_table_id_column)
         sum_column = quote_identifier(sum_column)
 
         pgt_trigger(summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL)
         BEGIN
           IF (TG_OP = 'UPDATE' AND NEW.#{id_column} = OLD.#{id_column}) THEN
-            UPDATE #{table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} - OLD.#{summed_column} WHERE #{main_column} = NEW.#{id_column};
+            UPDATE #{table} SET #{sum_column} = #{sum_column} + #{new_table_summed_column} - #{old_table_summed_column} WHERE #{main_column} = NEW.#{id_column};
           ELSE
             IF ((TG_OP = 'INSERT' OR TG_OP = 'UPDATE') AND NEW.#{id_column} IS NOT NULL) THEN
-              UPDATE #{table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} WHERE #{main_column} = NEW.#{id_column};
+              UPDATE #{table} SET #{sum_column} = #{sum_column} + #{new_table_summed_column} WHERE #{main_column} = NEW.#{id_column};
             END IF;
             IF ((TG_OP = 'DELETE' OR TG_OP = 'UPDATE') AND OLD.#{id_column} IS NOT NULL) THEN
-              UPDATE #{table} SET #{sum_column} = #{sum_column} - OLD.#{summed_column} WHERE #{main_column} = OLD.#{id_column};
+              UPDATE #{table} SET #{sum_column} = #{sum_column} - #{old_table_summed_column} WHERE #{main_column} = OLD.#{id_column};
             END IF;
           END IF;
           IF (TG_OP = 'DELETE') THEN
@@ -108,10 +110,11 @@ module Sequel
         main_table_fk_column = opts.fetch(:main_table_fk_column)
         summed_table_fk_column = opts.fetch(:summed_table_fk_column)
 
-        trigger_name = opts[:trigger_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}__#{summed_column}__#{main_table_fk_column}__#{summed_table_fk_column}"
-        function_name = opts[:function_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}__#{summed_column}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
-        join_trigger_name = opts[:join_trigger_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}__#{summed_column}__#{main_table_fk_column}__#{summed_table_fk_column}"
-        join_function_name = opts[:join_function_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}__#{summed_column}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        summed_column_slug = summed_column.is_a?(String) || summed_column.is_a?(Symbol) ? "__#{summed_column}" : ""
+        trigger_name = opts[:trigger_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}#{summed_column_slug}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        function_name = opts[:function_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}#{summed_column_slug}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        join_trigger_name = opts[:join_trigger_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}#{summed_column_slug}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        join_function_name = opts[:join_function_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}#{summed_column_slug}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
 
         orig_summed_table = summed_table
         orig_join_table = join_table
@@ -119,9 +122,13 @@ module Sequel
         main_table = quote_schema_table(main_table)
         main_table_id_column = quote_schema_table(main_table_id_column)
         sum_column = quote_schema_table(sum_column)
+
+        general_summed_column = literal(Sequel.deep_qualify(summed_table, summed_column))
+        new_table_summed_column = literal(Sequel.deep_qualify(Sequel.lit("NEW"), summed_column))
+        old_table_summed_column = literal(Sequel.deep_qualify(Sequel.lit("OLD"), summed_column))
+
         summed_table = quote_schema_table(summed_table)
         summed_table_id_column = quote_schema_table(summed_table_id_column)
-        summed_column = quote_schema_table(summed_column)
         join_table = quote_schema_table(join_table)
         main_table_fk_column = quote_schema_table(main_table_fk_column)
         summed_table_fk_column = quote_schema_table(summed_table_fk_column)
@@ -129,13 +136,13 @@ module Sequel
         pgt_trigger(orig_summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL)
         BEGIN
           IF (TG_OP = 'UPDATE' AND NEW.#{summed_table_id_column} = OLD.#{summed_table_id_column}) THEN
-            UPDATE #{main_table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} - OLD.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
+            UPDATE #{main_table} SET #{sum_column} = #{sum_column} + #{new_table_summed_column} - #{old_table_summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
           ELSE
             IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + #{new_table_summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
             END IF;
             IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - OLD.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = OLD.#{summed_table_id_column});
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - #{old_table_summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = OLD.#{summed_table_id_column});
             END IF;
           END IF;
           IF (TG_OP = 'DELETE') THEN
@@ -149,10 +156,10 @@ module Sequel
         BEGIN
           IF (NOT (TG_OP = 'UPDATE' AND NEW.#{main_table_fk_column} = OLD.#{main_table_fk_column} AND NEW.#{summed_table_fk_column} = OLD.#{summed_table_fk_column})) THEN
             IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + (SELECT #{summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = NEW.#{summed_table_fk_column}) WHERE #{main_table_id_column} = NEW.#{main_table_fk_column};
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + (SELECT #{general_summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = NEW.#{summed_table_fk_column}) WHERE #{main_table_id_column} = NEW.#{main_table_fk_column};
             END IF;
             IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - (SELECT #{summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = OLD.#{summed_table_fk_column}) WHERE #{main_table_id_column} = OLD.#{main_table_fk_column};
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - (SELECT #{general_summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = OLD.#{summed_table_fk_column}) WHERE #{main_table_id_column} = OLD.#{main_table_fk_column};
             END IF;
           END IF;
           IF (TG_OP = 'DELETE') THEN

data/spec/sequel_postgresql_triggers_spec.rb

@@ -27,13 +27,14 @@ describe "PostgreSQL Triggers" do
     before 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)
+      DB.pgt_counter_cache(:accounts, :id, :num_entries, :entries, :account_id, :function_name=>:spgt_counter_cache)
       DB[:accounts] << {:id=>1}
       DB[:accounts] << {:id=>2}
     end
 
     after do
       DB.drop_table(:entries, :accounts)
+      DB.drop_function(:spgt_counter_cache)
     end
 
     it "Should modify counter cache when adding or removing records" do
@@ -77,11 +78,12 @@ describe "PostgreSQL Triggers" do
   describe "PostgreSQL Created At Trigger" do
     before do
       DB.create_table(:accounts){integer :id; timestamp :added_on}
-      DB.pgt_created_at(:accounts, :added_on)
+      DB.pgt_created_at(:accounts, :added_on, :function_name=>:spgt_created_at)
     end
 
     after do
       DB.drop_table(:accounts)
+      DB.drop_function(:spgt_created_at)
     end
 
     it "Should set the column upon insertion and ignore modifications afterward" do
@@ -101,12 +103,13 @@ describe "PostgreSQL Triggers" do
   describe "PostgreSQL Immutable Trigger" do
     before do
       DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
-      DB.pgt_immutable(:accounts, :balance)
+      DB.pgt_immutable(:accounts, :balance, :function_name=>:spgt_immutable)
       DB[:accounts] << {:id=>1}
     end
 
     after do
       DB.drop_table(:accounts)
+      DB.drop_function(:spgt_immutable)
     end
 
     it "Should allow modifying columns not marked as immutable" do
@@ -135,13 +138,14 @@ describe "PostgreSQL Triggers" do
     before 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)
+      DB.pgt_sum_cache(:accounts, :id, :balance, :entries, :account_id, :amount, :function_name=>:spgt_sum_cache)
       DB[:accounts] << {:id=>1}
       DB[:accounts] << {:id=>2}
     end
 
     after do
       DB.drop_table(:entries, :accounts)
+      DB.drop_function(:spgt_sum_cache)
     end
 
     it "Should modify sum cache when adding, updating, or removing records" do
@@ -185,6 +189,62 @@ describe "PostgreSQL Triggers" do
     end
   end
 
+  describe "PostgreSQL Sum Cache Trigger with arbitrary expression" do
+    before 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}
+    end
+
+    after do
+      DB.drop_table(:entries, :accounts)
+      DB.drop_function(:spgt_sum_cache)
+    end
+
+    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[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 0]
+
+      DB[:entries] << {: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[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
+
+      DB[:entries].where(:id=>3).update(:account_id=>2)
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+
+      DB[:entries].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+
+      DB[:entries].where(:id=>2).update(:account_id=>2)
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
+
+      DB[:entries].where(:id=>2).update(:account_id=>nil)
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 1]
+
+      DB[:entries].where(:id=>2).update(:id=>4)
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 1]
+
+      DB[:entries].where(:id=>4).update(:account_id=>2)
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
+
+      DB[:entries].where(:id=>4).update(:account_id=>nil)
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 1]
+
+      DB[:entries].filter(:id=>4).delete
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 1]
+
+      DB[:entries].delete
+      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [0, 0]
+    end
+  end
+
+
   describe "PostgreSQL Sum Through Many Cache Trigger" do
     before do
       DB.create_table(:parents){primary_key :id; integer :balance, :default=>0, :null=>false}
@@ -197,7 +257,9 @@ describe "PostgreSQL Triggers" do
         :summed_column=>:amount,
         :join_table=>:links,
         :main_table_fk_column=>:parent_id,
-        :summed_table_fk_column=>:child_id
+        :summed_table_fk_column=>:child_id,
+        :function_name=>:spgt_stm_cache,
+        :join_function_name=>:spgt_stm_cache_join
       )
       DB[:parents] << {:id=>1}
       DB[:parents] << {:id=>2}
@@ -205,6 +267,8 @@ describe "PostgreSQL Triggers" do
 
     after do
       DB.drop_table(:links, :parents, :children)
+      DB.drop_function(:spgt_stm_cache)
+      DB.drop_function(:spgt_stm_cache_join)
     end
 
     it "Should modify sum cache when adding, updating, or removing records" do
@@ -274,14 +338,108 @@ describe "PostgreSQL Triggers" do
     end
   end
 
+  describe "PostgreSQL Sum Through Many Cache Trigger with arbitrary expression" do
+    before do
+      DB.create_table(:parents){primary_key :id; integer :nonzero_entries_count, :default=>0, :null=>false}
+      DB.create_table(:children){primary_key :id; integer :amount, :null=>false}
+      DB.create_table(:links){integer :parent_id, :null=>false; integer :child_id, :null=>false; unique [:parent_id, :child_id]}
+      DB.pgt_sum_through_many_cache(
+        :main_table=>:parents,
+        :sum_column=>:nonzero_entries_count,
+        :summed_table=>:children,
+        :summed_column=>Sequel.case({0=>0}, 1, :amount),
+        :join_table=>:links,
+        :main_table_fk_column=>:parent_id,
+        :summed_table_fk_column=>:child_id,
+        :function_name=>:spgt_stm_cache,
+        :join_function_name=>:spgt_stm_cache_join
+      )
+      DB[:parents] << {:id=>1}
+      DB[:parents] << {:id=>2}
+    end
+
+    after do
+      DB.drop_table(:links, :parents, :children)
+      DB.drop_function(:spgt_stm_cache)
+      DB.drop_function(:spgt_stm_cache_join)
+    end
+
+    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[: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[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
+
+      DB[:children] << {: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[: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[: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]
+
+      DB[:links].where(:parent_id=>1, :child_id=>4).update(:parent_id=>2, :child_id=>3)
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+
+      DB[:children].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+
+      DB[:links].where(:parent_id=>1, :child_id=>2).update(:parent_id=>2)
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
+
+      DB[:links].where(:parent_id=>2, :child_id=>2).update(:parent_id=>1)
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+
+      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[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 2]
+
+      DB[:children].filter(:id=>4).delete
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+
+      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[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
+
+      DB[:children].delete
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [0, 0]
+
+      DB[:children].multi_insert([{:id=>2, :amount=>200}, {:id=>1, :amount=>200}, {:id=>3, :amount=>1000}, {:id=>4, :amount=>400}])
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
+
+      DB[:links].where(:child_id=>3).update(:child_id=>2)
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
+
+      DB[:children].update(:amount=>10)
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
+
+      DB[:links].delete
+      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [0, 0]
+    end
+  end
+
   describe "PostgreSQL Updated At Trigger" do
     before do
       DB.create_table(:accounts){integer :id; timestamp :changed_on}
-      DB.pgt_updated_at(:accounts, :changed_on)
+      DB.pgt_updated_at(:accounts, :changed_on, :function_name=>:spgt_updated_at)
     end
 
     after do
       DB.drop_table(:accounts)
+      DB.drop_function(:spgt_updated_at)
     end
 
     it "Should set the column always to the current timestamp" do
@@ -304,10 +462,12 @@ describe "PostgreSQL Triggers" do
 
     after do
       DB.drop_table(:children, :parents)
+      DB.drop_function(:spgt_touch)
+      DB.drop_function(:spgt_touch2) if @spgt_touch2
     end
 
     it "Should update the timestamp column of the related table when adding, updating or removing records" do
-      DB.pgt_touch(:children, :parents, :changed_on, :id1=>:parent_id1)
+      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}
@@ -347,7 +507,7 @@ describe "PostgreSQL Triggers" do
     end
 
     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)
+      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].get(:changed_on).strftime('%F').must_equal Date.today.strftime('%F')
@@ -360,8 +520,9 @@ describe "PostgreSQL Triggers" do
     end
 
     it "Should update timestamps correctly when two tables touch each other" do
-      DB.pgt_touch(:children, :parents, :changed_on, :id1=>:parent_id1)
-      DB.pgt_touch(:parents, :children, :changed_on, :id=>:child_id)
+      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].get(:changed_on).strftime('%F').must_equal Date.today.strftime('%F')
@@ -380,7 +541,7 @@ describe "PostgreSQL Triggers" do
     end
 
     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)
+      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}
       changed_on = DB[:parents].get(:changed_on)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_postgresql_triggers
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-28 00:00:00.000000000 Z
+date: 2017-05-08 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.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Database enforced timestamps, immutable columns, counter/sum caches, and