pg_triggers 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cf39423a3020619969aa1b391430c208a7c4f51
-  data.tar.gz: 3bd05b9d325a80182451ea7e48d854dc019f358b
+  metadata.gz: 5595adfac3ae67d7262d42108d3c0eb0c22f0fe2
+  data.tar.gz: ba76d00baf5284c9e1b87d49caae8cfd8b16e5d0
 SHA512:
-  metadata.gz: 83754258a0258ad61666dc1e1efcda3139dd7b1a06b9d443a1b68748d34e60aa3fe7ac07a721292d210f29ed7d98933c2cfa42ebc7d79d85d82e3e10c0dff760
-  data.tar.gz: ea9522861e095a447c9b3ce1352e26920a960ed4e9b6e7657bb76c81e6123289db1fc8e2c85e3bf66c3d0023818871bad000c7c5c3a2e7af4e284e6aec96b468
+  metadata.gz: fd7455f77c46996d2950859a56896d3a94afcef07cbab6756c554c1c543efb9a2d7ae6a2677e95c284ebef9752be038e4e16c1131afbee8459759b448e9d3615
+  data.tar.gz: b599f05a7f96e8954abe0c2a72e4860cb116c7d2c3b8ae725f37e0bbdd1f2cd03f7ef3ffba944c765fafa1c15f99cfdc2d91a23541a2f7c26e95cdd81a5819dd

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.3.0 (2014-11-07)
+
+*   Add sum_cache trigger.
+
 ### 0.2.1 (2014-10-31)
 
 *   Add :name option to counter_cache to support custom names for the function and trigger.

data/lib/pg_triggers/version.rb

@@ -1,3 +1,3 @@
 module PgTriggers
-  VERSION = '0.2.1'
+  VERSION = '0.3.0'
 end

data/lib/pg_triggers.rb

@@ -53,6 +53,57 @@ module PgTriggers
       SQL
     end
 
+    def sum_cache(main_table, sum_column, summed_table, summed_column, relationship, options = {})
+      where      = proc { |source| relationship.map{|k, v| "#{k} = #{source}.#{v}"}.join(' AND ') }
+      columns    = relationship.values
+      changed    = columns.map{|c| "((OLD.#{c} <> NEW.#{c}) OR (OLD.#{c} IS NULL <> NEW.#{c} IS NULL))"}.join(' OR ')
+      multiplier = (options[:multiplier] || 1).to_i
+      name       = options[:name] || "pt_sc_#{main_table}_#{sum_column}"
+
+      condition = proc do |source|
+        a = []
+        a << columns.map{|c| "#{source}.#{c} IS NOT NULL"}.join(' AND ')
+        a << options[:where].gsub('ROW.', "#{source}.") if options[:where]
+        a.join(' AND ')
+      end
+
+      <<-SQL
+        CREATE OR REPLACE FUNCTION #{name}() RETURNS trigger
+          LANGUAGE plpgsql
+          AS $$
+            BEGIN
+              IF (TG_OP = 'INSERT') THEN
+                IF (#{condition['NEW']}) THEN
+                  UPDATE #{main_table} SET #{sum_column} = #{sum_column} + (NEW.#{summed_column} * #{multiplier}) WHERE #{where['NEW']};
+                END IF;
+                RETURN NEW;
+              ELSIF (TG_OP = 'UPDATE') THEN
+                IF (#{changed}) OR ((#{condition['OLD']}) <> (#{condition['NEW']})) OR (OLD.#{summed_column} <> NEW.#{summed_column}) THEN
+                  IF (#{condition['OLD']}) THEN
+                    UPDATE #{main_table} SET #{sum_column} = #{sum_column} - (OLD.#{summed_column} * #{multiplier}) WHERE #{where['OLD']};
+                  END IF;
+                  IF (#{condition['NEW']}) THEN
+                    UPDATE #{main_table} SET #{sum_column} = #{sum_column} + (NEW.#{summed_column} * #{multiplier}) WHERE #{where['NEW']};
+                  END IF;
+                END IF;
+                RETURN NEW;
+              ELSIF (TG_OP = 'DELETE') THEN
+                IF (#{condition['OLD']}) THEN
+                  UPDATE #{main_table} SET #{sum_column} = #{sum_column} - (OLD.#{summed_column} * #{multiplier}) WHERE #{where['OLD']};
+                END IF;
+                RETURN OLD;
+              END IF;
+            END;
+          $$;
+
+        DROP TRIGGER IF EXISTS #{name} ON #{summed_table};
+
+        CREATE TRIGGER #{name}
+        AFTER INSERT OR UPDATE OR DELETE ON #{summed_table}
+        FOR EACH ROW EXECUTE PROCEDURE #{name}();
+      SQL
+    end
+
     def updated_at(table, column)
       <<-SQL
         CREATE OR REPLACE FUNCTION pt_u_#{table}_#{column}() RETURNS trigger

data/spec/sum_cache_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+
+describe PgTriggers, 'sum_cache' do
+  before do
+    DB.drop_table?(:summer_table)
+    DB.drop_table?(:summed_table)
+  end
+
+  it "should increment and decrement the count of related items in the associated table as rows are inserted and updated and deleted" do
+    DB.create_table :summer_table do
+      integer :id, null: false
+      integer :summer_sum, null: false, default: 0
+    end
+
+    DB.create_table :summed_table do
+      integer :id, null: false
+      integer :summer_id, null: false
+      integer :summed_count, null: false, default: 0
+    end
+
+    DB.run PgTriggers.sum_cache :summer_table, :summer_sum, :summed_table, :summed_count, {id: :summer_id}
+
+    DB[:summer_table].insert(id: 1)
+    DB[:summer_table].insert(id: 2)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 0
+
+    DB[:summed_table].insert(id: 1, summer_id: 1)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 0
+
+    DB[:summed_table].where(id: 1).update(:summed_count => 3).should == 1
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 3
+
+    DB[:summed_table].insert(id: 2, summer_id: 1)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 3
+
+    DB[:summed_table].where(id: 2).update(:summed_count => 4).should == 1
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 7
+
+    DB[:summed_table].where(id: 1).delete.should == 1
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 4
+
+    DB[:summed_table].insert(id: 3, summer_id: 1, summed_count: 5)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 9
+  end
+
+  it "should work when the tables are related by multiple columns" do
+    DB.create_table :summer_table do
+      integer :id1, null: false
+      integer :id2, null: false
+      integer :summer_sum, null: false, default: 0
+    end
+
+    DB.create_table :summed_table do
+      integer :id, null: false
+      integer :summer_id1, null: false
+      integer :summer_id2, null: false
+      integer :summed_count, null: false, default: 0
+    end
+
+    DB.run PgTriggers.sum_cache :summer_table, :summer_sum, :summed_table, :summed_count, {id1: :summer_id1, id2: :summer_id2}
+
+    DB[:summer_table].insert(id1: 1, id2: 1)
+    DB[:summer_table].insert(id1: 2, id2: 1)
+    DB[:summer_table].where(id1: 1).get(:summer_sum).should == 0
+
+    DB[:summed_table].insert(id: 1, summer_id1: 1, summer_id2: 1, summed_count: 2)
+    DB[:summer_table].where(id1: 1).get(:summer_sum).should == 2
+
+    DB[:summed_table].insert(id: 2, summer_id1: 1, summer_id2: 1, summed_count: 3)
+    DB[:summer_table].where(id1: 1).get(:summer_sum).should == 5
+
+    DB[:summed_table].insert(id: 3, summer_id1: 2, summer_id2: 1, summed_count: 4)
+    DB[:summer_table].where(id1: 1).get(:summer_sum).should == 5
+    DB[:summer_table].where(id1: 2).get(:summer_sum).should == 4
+
+    DB[:summed_table].insert(id: 4, summer_id1: 1, summer_id2: 1, summed_count: 5)
+    DB[:summer_table].where(id1: 1).get(:summer_sum).should == 10
+
+    DB[:summed_table].where(id: 4).update(summer_id1: 2).should == 1
+    DB[:summer_table].where(id1: 1).get(:summer_sum).should == 5
+    DB[:summer_table].where(id1: 2).get(:summer_sum).should == 9
+
+    DB[:summed_table].where(summer_id1: 1).delete.should == 2
+    DB[:summer_table].where(id1: 1).get(:summer_sum).should == 0
+  end
+
+  it "should work as expected when any of the columns are set to null or an unknown value" do
+    DB.create_table :summer_table do
+      integer :id1, null: false
+      integer :id2, null: false
+      integer :summed1_sum, null: false, default: 0
+      integer :summed2_sum, null: false, default: 0
+    end
+
+    DB.create_table :summed_table do
+      integer :id, null: false
+      integer :summer_id1
+      integer :summer_id2
+      integer :summed_count, null: false, default: 0
+    end
+
+    DB.run PgTriggers.sum_cache :summer_table, :summed1_sum, :summed_table, :summed_count, {id1: :summer_id1}
+    DB.run PgTriggers.sum_cache :summer_table, :summed2_sum, :summed_table, :summed_count, {id1: :summer_id1, id2: :summer_id2}
+
+    DB[:summer_table].insert(id1: 1, id2: 1)
+    DB[:summed_table].insert(id: 1, summer_id1: 1, summer_id2: 1, summed_count: 1)
+    DB[:summed_table].insert(id: 2, summer_id1: 1, summer_id2: 1, summed_count: 2)
+    DB[:summed_table].insert(id: 3, summer_id1: 1, summer_id2: 1, summed_count: 4)
+    DB[:summed_table].insert(id: 4, summer_id1: 1, summer_id2: 1, summed_count: 8)
+    DB[:summer_table].where(id1: 1, id2: 1).get([:summed1_sum, :summed2_sum]).should == [15, 15]
+
+    DB[:summed_table].where(id: 1).update(summer_id1: nil).should == 1
+    DB[:summer_table].where(id1: 1, id2: 1).get([:summed1_sum, :summed2_sum]).should == [14, 14]
+
+    DB[:summed_table].where(id: 2).update(summer_id2: nil).should == 1
+    DB[:summer_table].where(id1: 1, id2: 1).get([:summed1_sum, :summed2_sum]).should == [14, 12]
+
+    DB[:summed_table].where(id: 3).update(summer_id1: 90000000).should == 1
+    DB[:summer_table].where(id1: 1, id2: 1).get([:summed1_sum, :summed2_sum]).should == [10, 8]
+
+    DB[:summed_table].where(id: 4).update(summer_id2: 90000000).should == 1
+    DB[:summer_table].where(id1: 1, id2: 1).get([:summed1_sum, :summed2_sum]).should == [10, 0]
+
+    DB[:summed_table].insert(id: 5, summer_id1: 1, summer_id2: nil, summed_count: 16)
+    DB[:summer_table].where(id1: 1, id2: 1).get([:summed1_sum, :summed2_sum]).should == [26, 0]
+
+    DB[:summed_table].insert(id: 6, summer_id1: nil, summer_id2: nil, summed_count: 32)
+    DB[:summer_table].where(id1: 1, id2: 1).get([:summed1_sum, :summed2_sum]).should == [26, 0]
+  end
+
+  it "should accept a :where clause to filter the rows that are counted" do
+    DB.create_table :summer_table do
+      integer :id, null: false
+
+      integer :condition_sum,       null: false, default: 0
+      integer :value_sum,           null: false, default: 0
+      integer :condition_value_sum, null: false, default: 0
+    end
+
+    DB.create_table :summed_table do
+      integer :id, null: false
+      integer :summer_id, null: false
+      integer :summed_count, null: false, default: 0
+
+      boolean :condition
+      integer :value
+    end
+
+    DB.run PgTriggers.sum_cache :summer_table, :condition_sum,       :summed_table, :summed_count, {id: :summer_id}, where: "ROW.condition"
+    DB.run PgTriggers.sum_cache :summer_table, :value_sum,           :summed_table, :summed_count, {id: :summer_id}, where: "ROW.value > 5"
+    DB.run PgTriggers.sum_cache :summer_table, :condition_value_sum, :summed_table, :summed_count, {id: :summer_id}, where: "ROW.condition AND ROW.value > 5"
+
+    def values
+      DB[:summer_table].where(id: 1).get([:condition_sum, :value_sum, :condition_value_sum])
+    end
+
+    DB[:summer_table].insert(id: 1)
+
+    values.should == [0, 0, 0]
+    DB[:summed_table].insert(id: 1, summer_id: 1, condition: true,  value: 4, summed_count: 1)
+    values.should == [1, 0, 0]
+    DB[:summed_table].insert(id: 2, summer_id: 1, condition: false, value: 4, summed_count: 2)
+    values.should == [1, 0, 0]
+    DB[:summed_table].insert(id: 3, summer_id: 1, condition: true,  value: 6, summed_count: 4)
+    values.should == [5, 4, 4]
+    DB[:summed_table].insert(id: 4, summer_id: 1, condition: false, value: 6, summed_count: 8)
+    values.should == [5, 12, 4]
+    DB[:summed_table].insert(id: 5, summer_id: 1, condition: nil,   value: 4, summed_count: 16)
+    values.should == [5, 12, 4]
+    DB[:summed_table].insert(id: 6, summer_id: 1, condition: false, value: nil, summed_count: 32)
+    values.should == [5, 12, 4]
+    DB[:summed_table].insert(id: 7, summer_id: 1, condition: true,  value: nil, summed_count: 64)
+    values.should == [69, 12, 4]
+    DB[:summed_table].insert(id: 8, summer_id: 1, condition: nil,   value: 6, summed_count: 128)
+    values.should == [69, 140, 4]
+
+    DB[:summed_table].where(id: 3).update(summer_id: 2).should == 1
+    values.should == [65, 136, 0]
+    DB[:summed_table].where(id: [4, 7]).delete.should == 2
+    values.should == [1, 128, 0]
+    DB[:summed_table].where(id: 3).update(summer_id: 1).should == 1
+    values.should == [5, 132, 4]
+    DB[:summed_table].where(id: 1).update(value: 6).should == 1
+    values.should == [5, 133, 5]
+  end
+
+  it "should silently replace another counter cache trigger on the same set of columns" do
+    DB.create_table :summer_table do
+      integer :id, null: false
+      integer :condition_sum, null: false, default: 0
+    end
+
+    DB.create_table :summed_table do
+      integer :id, null: false
+      integer :summer_id, null: false
+      integer :summed_count, null: false, default: 0
+      boolean :condition
+    end
+
+    def value
+      DB[:summer_table].where(id: 1).get(:condition_sum)
+    end
+
+    DB.run PgTriggers.sum_cache :summer_table, :condition_sum, :summed_table, :summed_count, {id: :summer_id}
+
+    DB[:summer_table].insert(id: 1)
+
+    DB[:summed_table].insert(id: 1, summer_id: 1, summed_count: 1, condition: true)
+    value.should == 1
+    DB[:summed_table].insert(id: 2, summer_id: 1, summed_count: 2, condition: false)
+    value.should == 3
+    DB[:summed_table].insert(id: 3, summer_id: 1, summed_count: 4, condition: true)
+    value.should == 7
+    DB[:summed_table].insert(id: 4, summer_id: 1, summed_count: 8, condition: false)
+    value.should == 15
+
+    DB.run PgTriggers.sum_cache :summer_table, :condition_sum, :summed_table, :summed_count, {id: :summer_id}, where: "ROW.condition"
+
+    DB[:summed_table].insert(id: 5, summer_id: 1, summed_count: 16, condition: nil)
+    value.should == 15
+    DB[:summed_table].insert(id: 6, summer_id: 1, summed_count: 32, condition: false)
+    value.should == 15
+    DB[:summed_table].insert(id: 7, summer_id: 1, summed_count: 64, condition: true)
+    value.should == 79
+    DB[:summed_table].insert(id: 8, summer_id: 1, summed_count: 128, condition: nil)
+    value.should == 79
+  end
+
+  it "should support a custom multiplier to apply to the sum" do
+    DB.create_table :summer_table do
+      integer :id, null: false
+      integer :summer_sum, null: false, default: 0
+    end
+
+    DB.create_table :summed_table do
+      integer :id, null: false
+      integer :summer_id, null: false
+      integer :summed_count, null: false, default: 0
+    end
+
+    DB.run PgTriggers.sum_cache :summer_table, :summer_sum, :summed_table, :summed_count, {id: :summer_id}, multiplier: 4
+
+    DB[:summer_table].insert(id: 1)
+    DB[:summer_table].insert(id: 2)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 0
+
+    DB[:summed_table].insert(id: 1, summer_id: 1)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 0
+
+    DB[:summed_table].where(id: 1).update(:summed_count => 3).should == 1
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 12
+
+    DB[:summed_table].insert(id: 2, summer_id: 1)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 12
+
+    DB[:summed_table].where(id: 2).update(:summed_count => 4).should == 1
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 28
+
+    DB[:summed_table].where(id: 1).delete.should == 1
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 16
+
+    DB[:summed_table].insert(id: 3, summer_id: 1, summed_count: 5)
+    DB[:summer_table].where(id: 1).get(:summer_sum).should == 36
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_triggers
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-31 00:00:00.000000000 Z
+date: 2014-11-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,7 @@ files:
 - spec/audit_table_spec.rb
 - spec/counter_cache_spec.rb
 - spec/spec_helper.rb
+- spec/sum_cache_spec.rb
 - spec/updated_at_spec.rb
 homepage: ''
 licenses:
@@ -142,4 +143,5 @@ test_files:
 - spec/audit_table_spec.rb
 - spec/counter_cache_spec.rb
 - spec/spec_helper.rb
+- spec/sum_cache_spec.rb
 - spec/updated_at_spec.rb