pg_triggers 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 337b518fc8202e64427560ad223fa770f00539e9
-  data.tar.gz: 6c461d6c36aa8de5bf4b851a85559513eb61d7e8
+  metadata.gz: 19f1fcd14466ad95643f91d2dc62934b7b6eef63
+  data.tar.gz: eaaea66c3afaa575234c0fb2be06c3b3f265df0c
 SHA512:
-  metadata.gz: 23b8997a7baf9f1c270e26da58ba81a7aaf32e6618fa7fc8f88ea6b7fcf92fc2ee50e6434b223b3735f3b9a7ca51e311db48b13fee1f06f0b64cea7e2aa9dc00
-  data.tar.gz: 3a75252387d8ff676e0b2c1b18b2ab7ad6128149cfe8ffd5f12ce4cf38f03624eda793d555ca4744fc95fc3e545e5fe824ea37a728392e612560e9e8b4040103
+  metadata.gz: f25370dae7dfffba8e21b20c7072b979942c7542b12857166d8473b5307bbc108e897b5726560c22166962182e2d0720503467a86694f8e3c16be0df42ede480
+  data.tar.gz: 73b51af990c1a93f284ff1f1402378f5299e995ad39ae1452b7bbe22468b5cd772ac58f9fa4abe8fea9c6a232643ea4daaa7aa656fe85f6f09ae8c4d9e84ed74

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.1.0 (2014-08-25)
+
+*   Add audit_table trigger to track changes to a table.
+
 ### 0.0.2 (2014-08-21)
 
 *   Fix counter cache bug with UPDATEs and :where conditions.

data/lib/pg_triggers.rb

@@ -50,5 +50,62 @@ module PgTriggers
         FOR EACH ROW EXECUTE PROCEDURE pg_triggers_counter_#{main_table}_#{counter_column}();
       SQL
     end
+
+    def create_audit_table
+      <<-SQL
+        CREATE TABLE audit_table(
+          id bigserial PRIMARY KEY,
+          table_name text NOT NULL,
+          changed_at timestamptz NOT NULL DEFAULT now(),
+          changes json NOT NULL
+        );
+      SQL
+    end
+
+    def audit_table(table_name, options = {})
+      incl = options[:include].map{|a| "'#{a}'"}.join(', ') if options[:include]
+      ignore = options[:ignore].map{|a| "'#{a}'"}.join(', ') if options[:ignore]
+
+      <<-SQL
+        CREATE OR REPLACE FUNCTION pg_triggers_audit_#{table_name}() RETURNS TRIGGER
+        AS $body$
+          DECLARE
+            changed_keys text[];
+            changes json;
+          BEGIN
+            IF (TG_OP = 'UPDATE') THEN
+              SELECT array_agg(o.key) INTO changed_keys
+              FROM json_each(row_to_json(OLD)) o
+              JOIN json_each(row_to_json(NEW)) n ON o.key = n.key
+              WHERE o.value::text <> n.value::text;
+
+              IF NOT (ARRAY[#{ignore}]::text[] @> changed_keys) THEN
+                SELECT ('{' || string_agg('"' || key || '":' || value, ',') || '}')::json INTO changes
+                FROM json_each(row_to_json(OLD))
+                WHERE (
+                  key = ANY(changed_keys)
+                  #{"AND key NOT IN (#{ignore})" if ignore}
+                )
+                #{"OR key IN (#{incl})" if incl};
+
+                INSERT INTO audit_table(table_name, changes) VALUES (TG_TABLE_NAME::TEXT, changes);
+              END IF;
+
+              RETURN OLD;
+            ELSIF (TG_OP = 'DELETE') THEN
+              INSERT INTO audit_table(table_name, changes) VALUES (TG_TABLE_NAME::TEXT, row_to_json(OLD));
+              RETURN OLD;
+            END IF;
+          END
+        $body$
+        LANGUAGE plpgsql;
+
+        DROP TRIGGER IF EXISTS pg_triggers_audit_#{table_name} ON #{table_name};
+
+        CREATE TRIGGER pg_triggers_audit_#{table_name}
+        AFTER UPDATE OR DELETE ON #{table_name}
+        FOR EACH ROW EXECUTE PROCEDURE pg_triggers_audit_#{table_name}();
+      SQL
+    end
   end
 end

data/lib/pg_triggers/version.rb

@@ -1,3 +1,3 @@
 module PgTriggers
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/pg_triggers.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "sequel"
   spec.add_development_dependency "pg"
+  spec.add_development_dependency "pry"
 end

data/spec/audit_table_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+require 'json'
+
+describe PgTriggers, 'auditing' do
+  before do
+    DB.drop_table?(:audit_table)
+  end
+
+  describe "create_audit_table" do
+    it "should create a table to hold auditing information" do
+      DB.run PgTriggers.create_audit_table
+      DB.table_exists?(:audit_table).should be true
+    end
+  end
+
+  describe "audit_table" do
+    before do
+      DB.run PgTriggers.create_audit_table
+      DB.drop_table?(:audited_table)
+      DB.create_table :audited_table do
+        primary_key :id
+        text :description
+        integer :item_count, null: false, default: 0
+      end
+    end
+
+    it "should record old versions of rows when they are updated" do
+      DB.run PgTriggers.audit_table(:audited_table)
+
+      id = DB[:audited_table].insert
+      DB[:audited_table].where(id: id).update item_count: 1
+      DB[:audited_table].where(id: id).update description: 'blah'
+      DB[:audited_table].where(id: id).update description: nil
+      DB[:audited_table].where(id: id).update item_count: 2
+
+      DB[:audit_table].count.should == 4
+      r1, r2, r3, r4 = DB[:audit_table].order(:id).all
+
+      r1[:id].should == 1
+      r1[:table_name].should == 'audited_table'
+      r1[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r1[:changes]).should == {'item_count' => 0}
+
+      r2[:id].should == 2
+      r2[:table_name].should == 'audited_table'
+      r2[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r2[:changes]).should == {'description' => nil}
+
+      r3[:id].should == 3
+      r3[:table_name].should == 'audited_table'
+      r3[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r3[:changes]).should == {'description' => 'blah'}
+
+      r4[:id].should == 4
+      r4[:table_name].should == 'audited_table'
+      r4[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r4[:changes]).should == {'item_count' => 1}
+    end
+
+    it "should always record the values of columns in the :always set" do
+      DB.run PgTriggers.audit_table(:audited_table, include: [:id, :item_count])
+
+      id = DB[:audited_table].insert
+      DB[:audited_table].where(id: id).update item_count: 1
+      DB[:audited_table].where(id: id).update description: 'blah'
+
+      DB[:audit_table].count.should == 2
+      r1, r2 = DB[:audit_table].order(:id).all
+
+      r1[:id].should == 1
+      r1[:table_name].should == 'audited_table'
+      r1[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r1[:changes]).should == {'id' => 1, 'item_count' => 0}
+
+      r2[:id].should == 2
+      r2[:table_name].should == 'audited_table'
+      r2[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r2[:changes]).should == {'id' => 1, 'item_count' => 1, 'description' => nil}
+    end
+
+    it "should not record UPDATEs when the only changed columns fall within the :ignore set" do
+      DB.run PgTriggers.audit_table(:audited_table, ignore: [:item_count])
+
+      id = DB[:audited_table].insert
+      DB[:audited_table].where(id: id).update item_count: 1
+      DB[:audited_table].where(id: id).update description: 'blah'
+      DB[:audited_table].where(id: id).update description: nil
+      DB[:audited_table].where(id: id).update item_count: 2
+
+      DB[:audit_table].count.should == 2
+      r1, r2 = DB[:audit_table].order(:id).all
+
+      r1[:id].should == 1
+      r1[:table_name].should == 'audited_table'
+      r1[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r1[:changes]).should == {'description' => nil}
+
+      r2[:id].should == 2
+      r2[:table_name].should == 'audited_table'
+      r2[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r2[:changes]).should == {'description' => 'blah'}
+    end
+
+    it "should handle columns being in both the :include and :ignore sets properly" do
+      DB.run PgTriggers.audit_table(:audited_table, include: [:item_count], ignore: [:item_count])
+
+      id = DB[:audited_table].insert
+      DB[:audited_table].where(id: id).update item_count: 1
+      DB[:audited_table].where(id: id).update description: 'blah'
+      DB[:audited_table].where(id: id).update description: nil
+      DB[:audited_table].where(id: id).update item_count: 2
+
+      DB[:audit_table].count.should == 2
+      r1, r2 = DB[:audit_table].order(:id).all
+
+      r1[:id].should == 1
+      r1[:table_name].should == 'audited_table'
+      r1[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r1[:changes]).should == {'description' => nil, 'item_count' => 1}
+
+      r2[:id].should == 2
+      r2[:table_name].should == 'audited_table'
+      r2[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r2[:changes]).should == {'description' => 'blah', 'item_count' => 1}
+    end
+
+    it "should ignore records that are not changed at all" do
+      DB.run PgTriggers.audit_table(:audited_table)
+
+      id = DB[:audited_table].insert
+      DB[:audited_table].where(id: id).update item_count: 0
+      DB[:audit_table].count.should == 0
+    end
+
+    it "should not include changed columns if they are ignored" do
+      DB.run PgTriggers.audit_table(:audited_table, ignore: [:item_count])
+
+      id = DB[:audited_table].insert
+      DB[:audited_table].where(id: id).update description: 'blah', item_count: 1
+      DB[:audited_table].where(id: id).update description: 'blah', item_count: 2
+      DB[:audited_table].where(id: id).update description: nil, item_count: 3
+
+      DB[:audit_table].count.should == 2
+      r1, r2 = DB[:audit_table].order(:id).all
+
+      r1[:id].should == 1
+      r1[:table_name].should == 'audited_table'
+      r1[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r1[:changes]).should == {'description' => nil}
+
+      r2[:id].should == 2
+      r2[:table_name].should == 'audited_table'
+      r2[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r2[:changes]).should == {'description' => 'blah'}
+    end
+
+    it "should record the entirety of the row when it is deleted" do
+      DB.run PgTriggers.audit_table(:audited_table)
+
+      id = DB[:audited_table].insert description: 'Go home and get your shinebox!', item_count: 5
+      DB[:audited_table].where(id: id).delete.should == 1
+
+      DB[:audit_table].count.should == 1
+      record = DB[:audit_table].first
+      record[:id].should == 1
+      record[:table_name].should == 'audited_table'
+      record[:changed_at].should be_within(3).of Time.now
+      JSON.parse(record[:changes]).should == {'id' => 1, 'description' => 'Go home and get your shinebox!', 'item_count' => 5}
+    end
+
+    it "should seamlessly replace an existing audit trigger on the same table" do
+      id = DB[:audited_table].insert description: 'Go home and get your shinebox!', item_count: 5
+
+      DB.run PgTriggers.audit_table(:audited_table)
+      DB[:audited_table].where(id: id).update(item_count: 6)
+      DB[:audit_table].count.should == 1
+
+      DB.run PgTriggers.audit_table(:audited_table, ignore: [:item_count])
+      DB[:audited_table].where(id: id).update(item_count: 7)
+      DB[:audit_table].count.should == 1
+      DB[:audited_table].where(id: id).update(description: 'blah')
+      DB[:audit_table].count.should == 2
+    end
+
+    it "should properly handle rows of type JSON" do
+      DB.alter_table :audited_table do
+        add_column :data, :json, null: false, default: '{}'
+      end
+
+      id = DB[:audited_table].insert data: '{}'
+
+      DB.run PgTriggers.audit_table(:audited_table)
+      DB[:audited_table].where(id: id).update(data: '{"a":1}')
+      DB[:audited_table].where(id: id).update(data: '{"a":1,"b":2}')
+      DB[:audited_table].where(id: id).update(data: '{"a":1,"b":2}')
+      DB[:audited_table].where(id: id).update(data: '{"a":2,"b":2}')
+
+      DB.run PgTriggers.audit_table(:audited_table, ignore: [:data])
+      DB[:audited_table].where(id: id).update(data: '{"a":8}')
+
+      DB[:audit_table].count.should == 3
+      r1, r2, r3 = DB[:audit_table].all
+
+      r1[:id].should == 1
+      r1[:table_name].should == 'audited_table'
+      r1[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r1[:changes]).should == {'data' => {}}
+
+      r2[:id].should == 2
+      r2[:table_name].should == 'audited_table'
+      r2[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r2[:changes]).should == {'data' => {'a' => 1}}
+
+      r3[:id].should == 3
+      r3[:table_name].should == 'audited_table'
+      r3[:changed_at].should be_within(3).of Time.now
+      JSON.parse(r3[:changes]).should == {'data' => {'a' => 1, 'b' => 2}}
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'sequel'
 require 'pg_triggers'
+require 'pry'
 
 url = ENV['PG_TRIGGERS_URL'] || 'postgres:///pg_triggers'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_triggers
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-21 00:00:00.000000000 Z
+date: 2014-08-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Handy helpers to create PostgreSQL Triggers
 email:
 - christopher.m.hanks@gmail.com
@@ -96,6 +110,7 @@ files:
 - lib/pg_triggers.rb
 - lib/pg_triggers/version.rb
 - pg_triggers.gemspec
+- spec/audit_table_spec.rb
 - spec/counter_cache_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -123,5 +138,6 @@ signing_key:
 specification_version: 4
 summary: Helpers for Postgres Triggers
 test_files:
+- spec/audit_table_spec.rb
 - spec/counter_cache_spec.rb
 - spec/spec_helper.rb