sequel_postgresql_triggers 1.0.8 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12a05702b972f0adb894a4c5e678400debab6f7a
-  data.tar.gz: cd51e2bf9105506ed4d992a2eafa231c45346ad4
+  metadata.gz: c908ae3d087271626842952b60bc22365793a3d9
+  data.tar.gz: 1cf7c4c70437c36ab0852d566d600756314c90d5
 SHA512:
-  metadata.gz: cfcd7fe87e24a790f79c1158fabd01f38f0411ad4632e5b4c2a18cce5e27dab8cb32832f8b3a8edd14d879f6427e6bd00c231409db5f2740b8dd9104cc5be833
-  data.tar.gz: ff1c7f9c541f44e00217e65ed434a16b45e1418517f47e76c1df84590a548fc021f5d3a54454ddca403256c1dc80c2f55b4d0b8ebf202097eceb4d475a8829aa
+  metadata.gz: 6f10299a3e24a54147217af11e85317484b02b43a0f9faba1120f5f1bfdd402b8f281c4b403f0f785175c94196d6079a9719667965383102e5732f6e0ca1c9b9
+  data.tar.gz: 06f7baa57db107b2fec9d169ebe03f87b737f611adbc302e8af3f0dda2695d0c96d74dd68b50be4b1c7cb0715c4f40b1b17318f41bdf1ed2755defdf94e70ea2

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2014 Jeremy Evans
+Copyright (c) 2008-2016 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

@@ -37,13 +37,21 @@ differs that upon update, the column is also set to CURRENT_TIMESTAMP.
 This takes quite a few arguments (see the RDoc) and sets up a
 counter cache so that when the counted table is inserted to
 or deleted from, records in the main table are updated with the
-count of the corresponding records in the counted table.
+count of the corresponding records in the counted table.  The counter
+cache column must have a default of 0 for this to work correctly.
 
 === Sum Cache - pgt_sum_cache
 
 Similar to pgt_counter_cache, except instead of storing a count
 of records in the main table, it stores the sum on one of the
-columns in summed table.
+columns in summed table. The sum cache column must have a default
+of 0 for this to work correctly.
+
+=== Sum Through Many Cache - pgt_sum_through_many_cache
+
+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.
 
 === Immutable Columns - pgt_immutable
 

data/lib/sequel_postgresql_triggers.rb

@@ -137,6 +137,89 @@ module Sequel
         SQL
       end
 
+      # Turns a column in the main table into a sum cache through a join table.
+      # A sum cache is a column in the main table with the sum of a column in the
+      # summed table for the matching id. The join table must have NOT NULL constraints
+      # on the foreign keys to the main table and summed table and a
+      # composite unique constraint on both foreign keys.
+      # 
+      # Arguments:
+      # * opts : option hash, see module documentation, and below.
+      # * :main_table: name of table holding sum cache column
+      # * :main_table_id_column: primary key column in main table referenced by main_table_fk_column (default: :id)
+      # * :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
+      # * :join_table: name of table which joins main_table with summed_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
+      def pgt_sum_through_many_cache(opts={})
+        main_table = opts.fetch(:main_table)
+        main_table_id_column = opts.fetch(:main_table_id_column, :id)
+        sum_column = opts.fetch(:sum_column)
+        summed_table = opts.fetch(:summed_table)
+        summed_table_id_column = opts.fetch(:summed_table_id_column, :id)
+        summed_column = opts.fetch(:summed_column)
+        join_table = opts.fetch(:join_table)
+        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}"
+
+        orig_summed_table = summed_table
+        orig_join_table = join_table
+
+        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)
+        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)
+
+        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});
+          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});
+            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});
+            END IF;
+          END IF;
+          IF (TG_OP = 'DELETE') THEN
+            RETURN OLD;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+
+        pgt_trigger(orig_join_table, join_trigger_name, join_function_name, [:insert, :delete, :update], <<-SQL)
+        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};
+            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};
+            END IF;
+          END IF;
+          IF (TG_OP = 'DELETE') THEN
+            RETURN OLD;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+      end
+
       # When rows in a table are updated, touches a timestamp of related rows
       # in another table.
       # Arguments:

data/spec/sequel_postgresql_triggers_spec.rb

@@ -1,6 +1,8 @@
-#!/usr/bin/env spec
+#!/usr/bin/env ruby
 require 'rubygems'
 require 'sequel'
+require 'minitest/spec'
+require 'minitest/autorun'
 
 DB = Sequel.connect(ENV['PGT_SPEC_DB']||'postgres:///spgt_test?user=postgres')
 
@@ -26,7 +28,7 @@ describe "PostgreSQL Triggers" do
     DB.drop_language(:plpgsql, :cascade=>true) if DB.server_version < 90000
   end
 
-  context "PostgreSQL Counter Cache Trigger" do
+  describe "PostgreSQL Counter Cache Trigger" do
     before do
       DB.create_table(:accounts){integer :id; integer :num_entries, :default=>0}
       DB.create_table(:entries){integer :id; integer :account_id}
@@ -39,45 +41,45 @@ describe "PostgreSQL Triggers" do
       DB.drop_table(:entries, :accounts)
     end
 
-    specify "Should modify counter cache when adding or removing records" do
-      DB[:accounts].order(:id).select_map(:num_entries).should == [0, 0]
+    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[:accounts].order(:id).select_map(:num_entries).should == [1, 0]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 0]
 
       DB[:entries] << {:id=>2, :account_id=>1}
-      DB[:accounts].order(:id).select_map(:num_entries).should == [2, 0]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [2, 0]
       
       DB[:entries] << {:id=>3, :account_id=>nil}
-      DB[:accounts].order(:id).select_map(:num_entries).should == [2, 0]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [2, 0]
       
       DB[:entries].where(:id=>3).update(:account_id=>2)
-      DB[:accounts].order(:id).select_map(:num_entries).should == [2, 1]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [2, 1]
       
       DB[:entries].where(:id=>2).update(:account_id=>2)
-      DB[:accounts].order(:id).select_map(:num_entries).should == [1, 2]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 2]
       
       DB[:entries].where(:id=>2).update(:account_id=>nil)
-      DB[:accounts].order(:id).select_map(:num_entries).should == [1, 1]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 1]
       
       DB[:entries].where(:id=>2).update(:id=>4)
-      DB[:accounts].order(:id).select_map(:num_entries).should == [1, 1]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 1]
       
       DB[:entries].where(:id=>4).update(:account_id=>2)
-      DB[:accounts].order(:id).select_map(:num_entries).should == [1, 2]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 2]
       
       DB[:entries].where(:id=>4).update(:account_id=>nil)
-      DB[:accounts].order(:id).select_map(:num_entries).should == [1, 1]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 1]
       
       DB[:entries].filter(:id=>4).delete
-      DB[:accounts].order(:id).select_map(:num_entries).should == [1, 1]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 1]
       
       DB[:entries].delete
-      DB[:accounts].order(:id).select_map(:num_entries).should == [0, 0]
+      DB[:accounts].order(:id).select_map(:num_entries).must_equal [0, 0]
     end
   end
 
-  context "PostgreSQL Created At Trigger" 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)
@@ -87,21 +89,21 @@ describe "PostgreSQL Triggers" do
       DB.drop_table(:accounts)
     end
 
-    specify "Should set the column upon insertion and ignore modifications afterward" do
+    it "Should set the column upon insertion and ignore modifications afterward" do
       DB[:accounts] << {:id=>1}
       t = DB[:accounts].get(:added_on)
-      t.strftime('%F').should == Date.today.strftime('%F')
+      t.strftime('%F').must_equal Date.today.strftime('%F')
       DB[:accounts].update(:added_on=>Date.today - 60)
-      DB[:accounts].get(:added_on).should == t
+      DB[:accounts].get(:added_on).must_equal t
       DB[:accounts] << {: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].should == true
+      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)
-      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>3)).as(:x)).first[:x].should == true
+      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>2)) > ds.filter(:id=>3)).as(:x)).first[:x].must_equal true
     end
   end
 
-  context "PostgreSQL Immutable Trigger" do
+  describe "PostgreSQL Immutable Trigger" do
     before do
       DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
       DB.pgt_immutable(:accounts, :balance)
@@ -112,29 +114,29 @@ describe "PostgreSQL Triggers" do
       DB.drop_table(:accounts)
     end
 
-    specify "Should allow modifying columns not marked as immutable" do
-      proc{DB[:accounts].update(:id=>2)}.should_not raise_error
+    it "Should allow modifying columns not marked as immutable" do
+      DB[:accounts].update(:id=>2)
     end
 
-    specify "Should allow updating a column to its existing value" do
-      proc{DB[:accounts].update(:balance=>0)}.should_not raise_error
-      proc{DB[:accounts].update(:balance=>Sequel.*(:balance, :balance))}.should_not raise_error
+    it "Should allow updating a column to its existing value" do
+      DB[:accounts].update(:balance=>0)
+      DB[:accounts].update(:balance=>Sequel.*(:balance, :balance))
     end
 
-    specify "Should not allow modifying a column's value" do
-      proc{DB[:accounts].update(:balance=>1)}.should raise_error(Sequel::DatabaseError)
+    it "Should not allow modifying a column's value" do
+      proc{DB[:accounts].update(:balance=>1)}.must_raise(Sequel::DatabaseError)
     end
 
-    specify "Should handle NULL values correctly" do
-      proc{DB[:accounts].update(:balance=>nil)}.should raise_error(Sequel::DatabaseError)
+    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}
-      proc{DB[:accounts].update(:balance=>nil)}.should_not raise_error
-      proc{DB[:accounts].update(:balance=>0)}.should raise_error(Sequel::DatabaseError)
+      DB[:accounts].update(:balance=>nil)
+      proc{DB[:accounts].update(:balance=>0)}.must_raise(Sequel::DatabaseError)
     end
   end
 
-  context "PostgreSQL Sum Cache Trigger" do
+  describe "PostgreSQL Sum Cache Trigger" do
     before do
       DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
       DB.create_table(:entries){integer :id; integer :account_id; integer :amount}
@@ -147,48 +149,137 @@ describe "PostgreSQL Triggers" do
       DB.drop_table(:entries, :accounts)
     end
 
-    specify "Should modify sum cache when adding, updating, or removing records" do
-      DB[:accounts].order(:id).select_map(:balance).should == [0, 0]
+    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[:accounts].order(:id).select_map(:balance).should == [100, 0]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [100, 0]
 
       DB[:entries] << {:id=>2, :account_id=>1, :amount=>200}
-      DB[:accounts].order(:id).select_map(:balance).should == [300, 0]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [300, 0]
       
       DB[:entries] << {:id=>3, :account_id=>nil, :amount=>500}
-      DB[:accounts].order(:id).select_map(:balance).should == [300, 0]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [300, 0]
       
       DB[:entries].where(:id=>3).update(:account_id=>2)
-      DB[:accounts].order(:id).select_map(:balance).should == [300, 500]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [300, 500]
       
       DB[:entries].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
-      DB[:accounts].order(:id).select_map(:balance).should == [400, 1000]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [400, 1000]
       
       DB[:entries].where(:id=>2).update(:account_id=>2)
-      DB[:accounts].order(:id).select_map(:balance).should == [200, 1200]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1200]
       
       DB[:entries].where(:id=>2).update(:account_id=>nil)
-      DB[:accounts].order(:id).select_map(:balance).should == [200, 1000]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
       
       DB[:entries].where(:id=>2).update(:id=>4)
-      DB[:accounts].order(:id).select_map(:balance).should == [200, 1000]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
       
       DB[:entries].where(:id=>4).update(:account_id=>2)
-      DB[:accounts].order(:id).select_map(:balance).should == [200, 1200]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1200]
       
       DB[:entries].where(:id=>4).update(:account_id=>nil)
-      DB[:accounts].order(:id).select_map(:balance).should == [200, 1000]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
       
       DB[:entries].filter(:id=>4).delete
-      DB[:accounts].order(:id).select_map(:balance).should == [200, 1000]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
       
       DB[:entries].delete
-      DB[:accounts].order(:id).select_map(:balance).should == [0, 0]
+      DB[:accounts].order(:id).select_map(:balance).must_equal [0, 0]
     end
   end
 
-  context "PostgreSQL Updated At Trigger" do
+  describe "PostgreSQL Sum Through Many Cache Trigger" do
+    before do
+      DB.create_table(:parents){primary_key :id; integer :balance, :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=>:balance,
+        :summed_table=>:children,
+        :summed_column=>:amount,
+        :join_table=>:links,
+        :main_table_fk_column=>:parent_id,
+        :summed_table_fk_column=>:child_id
+      )
+      DB[:parents] << {:id=>1}
+      DB[:parents] << {:id=>2}
+    end
+
+    after do
+      DB.drop_table(:links, :parents, :children)
+    end
+
+    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[: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[:parents].order(:id).select_map(:balance).must_equal [300, 0]
+
+      DB[:children] << {:id=>3, :amount=>500}
+      DB[:parents].order(:id).select_map(:balance).must_equal [300, 0]
+      DB[:links] << {: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[:links].where(:parent_id=>1, :child_id=>3).update(:child_id=>4)
+      DB[:parents].order(:id).select_map(:balance).must_equal [700, 0]
+
+      DB[:links].where(:parent_id=>1, :child_id=>4).update(:parent_id=>2, :child_id=>3)
+      DB[:parents].order(:id).select_map(:balance).must_equal [300, 500]
+
+      DB[:children].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
+      DB[:parents].order(:id).select_map(:balance).must_equal [400, 1000]
+
+      DB[:links].where(:parent_id=>1, :child_id=>2).update(:parent_id=>2)
+      DB[:parents].order(:id).select_map(:balance).must_equal [200, 1200]
+
+      DB[:links].where(:parent_id=>2, :child_id=>2).update(:parent_id=>1)
+      DB[:parents].order(:id).select_map(:balance).must_equal [400, 1000]
+
+      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[:parents].order(:id).select_map(:balance).must_equal [1200, 1800]
+
+      DB[:children].filter(:id=>4).delete
+      DB[:parents].order(:id).select_map(:balance).must_equal [1200, 1000]
+
+      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[:parents].order(:id).select_map(:balance).must_equal [1000, 1400]
+
+      DB[:children].delete
+      DB[:parents].order(:id).select_map(:balance).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(:balance).must_equal [1000, 1400]
+
+      DB[:links].where(:child_id=>3).update(:child_id=>2)
+      DB[:parents].order(:id).select_map(:balance).must_equal [200, 600]
+
+      DB[:children].update(:amount=>10)
+      DB[:parents].order(:id).select_map(:balance).must_equal [10, 20]
+
+      DB[:links].delete
+      DB[:parents].order(:id).select_map(:balance).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)
@@ -198,19 +289,19 @@ describe "PostgreSQL Triggers" do
       DB.drop_table(:accounts)
     end
 
-    specify "Should set the column always to the current timestamp" do
+    it "Should set the column always to the current timestamp" do
       DB[:accounts] << {:id=>1}
       t = DB[:accounts].get(:changed_on)
-      t.strftime('%F').should == Date.today.strftime('%F')
+      t.strftime('%F').must_equal Date.today.strftime('%F')
       DB[:accounts] << {: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].should == true
+      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)
-      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>3)) > ds.filter(:id=>2)).as(:x)).first[:x].should == true
+      DB[:accounts].select((Sequel::SQL::NumericExpression.new(:NOOP, ds.filter(:id=>3)) > ds.filter(:id=>2)).as(:x)).first[:x].must_equal true
     end
   end
 
-  context "PostgreSQL Touch Trigger" do
+  describe "PostgreSQL Touch Trigger" do
     before do
       DB.create_table(:parents){integer :id1; integer :id2; integer :child_id; timestamp :changed_on}
       DB.create_table(:children){integer :id; integer :parent_id1; integer :parent_id2; timestamp :changed_on}
@@ -220,86 +311,86 @@ describe "PostgreSQL Triggers" do
       DB.drop_table(:children, :parents)
     end
 
-    specify "Should update the timestamp column of the related table when adding, updating or removing records" do
+    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)
       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].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d.strftime('%F'), d30.strftime('%F')]
+      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)
       DB[:children].update(:id=>2)
-      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d.strftime('%F'), d30.strftime('%F')]
+      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)
       DB[:children].update(:parent_id1=>2)
-      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d.strftime('%F'), d.strftime('%F')]
+      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.must_equal [d.strftime('%F'), d.strftime('%F')]
 
       DB[:parents].update(:changed_on=>d30)
       DB[:children].update(:parent_id1=>nil)
-      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d30.strftime('%F'), d.strftime('%F')]
+      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].update(:parent_id2=>1)
-      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d30.strftime('%F'), d30.strftime('%F')]
+      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.must_equal [d30.strftime('%F'), d30.strftime('%F')]
 
       DB[:parents].update(:changed_on=>d30)
       DB[:children].update(:parent_id1=>2)
-      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d30.strftime('%F'), d.strftime('%F')]
+      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].delete
-      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d30.strftime('%F'), d.strftime('%F')]
+      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[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.should == [d30.strftime('%F'), d30.strftime('%F')]
+      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')}.should == [d30.strftime('%F'), d30.strftime('%F')]
+      DB[:parents].order(:id1).select_map(:changed_on).map{|t| t.strftime('%F')}.must_equal [d30.strftime('%F'), d30.strftime('%F')]
     end
 
-    specify "Should update the timestamp column of the related table when there is a composite foreign key" 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)
       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').should == Date.today.strftime('%F')
+      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)
-      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      DB[:parents].get(:changed_on).strftime('%F').must_equal Date.today.strftime('%F')
       DB[:parents].update(:changed_on=>Date.today - 30)
       DB[:children].delete
-      DB[:parents].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      DB[:parents].get(:changed_on).strftime('%F').must_equal Date.today.strftime('%F')
     end
 
-    specify "Should update timestamps correctly when two tables touch each other" do
+    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[: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').should == Date.today.strftime('%F')
-      DB[:children].get(:changed_on).strftime('%F').should == Date.today.strftime('%F')
+      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)
       DB[:parents].update(:id2=>4)
-      DB[:parents].get(:changed_on).should > time
-      DB[:children].get(:changed_on).should > time
+      DB[:parents].get(:changed_on).must_be :>,  time
+      DB[:children].get(:changed_on).must_be :>,  time
       time = DB[:parents].get(:changed_on)
       DB[:children].update(:id=>1)
-      DB[:parents].get(:changed_on).should > time
-      DB[:children].get(:changed_on).should > time
+      DB[:parents].get(:changed_on).must_be :>,  time
+      DB[:children].get(:changed_on).must_be :>,  time
       time = DB[:parents].get(:changed_on)
       DB[:children].delete
-      DB[:parents].get(:changed_on).should > time
+      DB[:parents].get(:changed_on).must_be :>,  time
     end
 
-    specify "Should update the timestamp on the related table if that timestamp is initially NULL" 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)
       DB[:parents] << {:id1=>1, :changed_on=>nil}
       DB[:children] << {:id=>1, :parent_id1=>1}
       changed_on = DB[:parents].get(:changed_on)
-      changed_on.should_not == nil
-      changed_on.strftime('%F').should == Date.today.strftime('%F')
+      changed_on.wont_equal nil
+      changed_on.strftime('%F').must_equal Date.today.strftime('%F')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_postgresql_triggers
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.1.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-07 00:00:00.000000000 Z
+date: 2016-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -62,7 +62,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Database enforced timestamps, immutable columns, and counter/sum caches