sequel_postgresql_triggers 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b5d81f0071528eb70130d8ebe3093a365c0d024e250583d8ea7e35d5b7af263
-  data.tar.gz: 18bb2a79d2642636f34fce1f0f4be315e90592c3be8c8a8d5f587d753061d360
+  metadata.gz: d0c46791ed8af6edc2e71f5e7964625fe66811eb76d7a99c085b5157336f2d43
+  data.tar.gz: 0d3cae20446b2f4d334746077959d8415cb815c9afcb4212a57c35ff2bc8ab88
 SHA512:
-  metadata.gz: 615949150a244df98c696da8472ebeb40ae5c09812457f5ecca61197a10754e489c431a68d2a44df91eb5f17e229e6e39b4d3b4f4cf6ca28be520b2145345e3c
-  data.tar.gz: ca67361ebd569731121ad3f482e47d0320d0658144fd4d7bd21734fcf3542ae84d3fb592483813980fbb4f7e8b52866575c4f0c7efb8566d34760d884f66207c
+  metadata.gz: 19e85c00deff747bd3d89bad0d3dfd5d64105cd9191d4a336e004f5a862b097734fa5fe81793ac5bb8f32c8b849f5d28e1c9ef0975f038679f66357689702408
+  data.tar.gz: 1a59b39455c23b6e41af7825de4e6a9c53ba0c394ddb48296e4636f31b5a34bb86f13524562edb104050791d47fa4ac39a7ec665234dcb110ced6bf5c862798f

data/MIT-LICENSE

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

@@ -95,7 +95,7 @@ opts :: options hash
 
 === Counter Cache - pgt_counter_cache
 
-This takes quite a few arguments (see the RDoc) and sets up a
+This takes many arguments 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.  The counter
@@ -167,7 +167,7 @@ table :: name of table
 
 === Touch Propagation - pgt_touch
 
-This takes several arguments (again, see the RDoc) and sets up a
+This takes several arguments and sets up a
 trigger that watches one table for changes, and touches timestamps
 of related rows in a separate table.
 
@@ -198,6 +198,62 @@ Options:
 :referenced_function_name :: function name for trigger function on referenced table
 :referenced_trigger_name :: trigger name for referenced table
 
+=== Force Defaults - pgt_force_defaults
+
+This takes 2 arguments, a table and a hash of column default values, and sets
+up an insert trigger that will override user submitted or database
+default values and use the values given when setting up the trigger.
+This is mostly useful in situations where multiple database accounts
+are used where one account has insert permissions but not update
+permissions, and you want to ensure that inserted rows have specific
+column values to enforce security requirements.
+
+Arguments:
+table :: The name of the table
+defaults :: A hash of default values to enforce, where keys are column names
+            and values are the default values to enforce
+
+=== JSON Audit Logging - pgt_json_audit_log_setup and pg_json_audit_log
+
+These methods setup an auditing function where updates and deletes log
+the previous values to a central auditing table in JSON format.
+
+==== pgt_json_audit_log_setup
+
+This creates an audit table and a trigger function that will log
+previous values to the audit table. This returns the name of the
+trigger function created, which should be passed to
++pgt_json_audit_log+.
+
+Arguments:
+table :: The name of the table storing the audit logs.
+
+Options:
+function_opts :: Options to pass to +create_function+ when creating
+                 the trigger function.
+
+The audit log table will store the following columns:
+
+txid :: The 64-bit transaction ID for the transaction that made the modification (txid_current())
+at :: The timestamp of the transaction that made the modification (CURRENT_TIMESTAMP)
+user :: The database user name that made the modification (CURRENT_USER)
+schema :: The schema containing the table that was modified (TG_TABLE_SCHEMA)
+table :: The table that was modified (TG_TABLE_NAME)
+action :: The type of modification, either DELETE or UPDATE (TG_OP)
+prior :: A jsonb column with the contents of the row before the modification (to_jsonb(OLD))
+
+==== pgt_json_audit_log
+
+This adds a trigger to the table that will log previous values to the
+audting table for updates and deletes.
+
+Arguments:
+table :: The name of the table to audit
+function :: The name of the trigger function to call to log changes
+
+Note that it is probably a bad idea to use the same table argument
+to both +pgt_json_audit_log_setup+ and +pgt_json_audit_log+.
+
 == License
 
 This library is released under the MIT License.  See the MIT-LICENSE

data/lib/sequel/extensions/pg_triggers.rb

@@ -6,8 +6,8 @@ module Sequel
   module Postgres
     PGT_DEFINE = proc do
       def pgt_counter_cache(main_table, main_table_id_column, counter_column, counted_table, counted_table_id_column, opts={})
-        trigger_name = opts[:trigger_name] || "pgt_cc_#{main_table}__#{main_table_id_column}__#{counter_column}__#{counted_table_id_column}"
-        function_name = opts[:function_name] || "pgt_cc_#{main_table}__#{main_table_id_column}__#{counter_column}__#{counted_table}__#{counted_table_id_column}"
+        trigger_name = opts[:trigger_name] || "pgt_cc_#{pgt_mangled_table_name(main_table)}__#{main_table_id_column}__#{counter_column}__#{counted_table_id_column}"
+        function_name = opts[:function_name] || "pgt_cc_#{pgt_mangled_table_name(main_table)}__#{main_table_id_column}__#{counter_column}__#{pgt_mangled_table_name(counted_table)}__#{counted_table_id_column}"
 
         table = quote_schema_table(main_table)
         id_column = quote_identifier(counted_table_id_column)
@@ -37,7 +37,7 @@ module Sequel
 
       def pgt_created_at(table, column, opts={})
         trigger_name = opts[:trigger_name] || "pgt_ca_#{column}"
-        function_name = opts[:function_name] || "pgt_ca_#{table}__#{column}"
+        function_name = opts[:function_name] || "pgt_ca_#{pgt_mangled_table_name(table)}__#{column}"
         col = quote_identifier(column)
         pgt_trigger(table, trigger_name, function_name, [:insert, :update], <<-SQL)
         BEGIN
@@ -51,6 +51,21 @@ module Sequel
         SQL
       end
 
+      def pgt_force_defaults(table, defaults, opts={})
+        cols = defaults.keys.sort.join('_')
+        trigger_name = opts[:trigger_name] || "pgt_fd_#{cols}"
+        function_name = opts[:function_name] || "pgt_fd_#{pgt_mangled_table_name(table)}__#{cols}"
+        lines = defaults.map do |column, v|
+          "NEW.#{quote_identifier(column)} = #{literal(v)};"
+        end
+        pgt_trigger(table, trigger_name, function_name, [:insert], <<-SQL)
+        BEGIN
+          #{lines.join("\n")}
+          RETURN NEW;
+        END;
+        SQL
+      end
+
       def pgt_immutable(table, *columns)
         opts = columns.last.is_a?(Hash) ? columns.pop : {}
         trigger_name = opts[:trigger_name] || "pgt_im_#{columns.join('__')}"
@@ -67,9 +82,37 @@ module Sequel
         pgt_trigger(table, trigger_name, function_name, :update, "BEGIN #{ifs} RETURN NEW; END;")
       end
 
+      def pgt_json_audit_log_setup(table, opts={})
+        function_name = opts[:function_name] || "pgt_jal_#{pgt_mangled_table_name(table)}"
+        create_table(table) do
+          Bignum :txid, :null=>false, :index=>true
+          DateTime :at, :default=>Sequel::CURRENT_TIMESTAMP, :null=>false
+          String :user, :null=>false
+          String :schema, :null=>false
+          String :table, :null=>false
+          String :action, :null=>false
+          jsonb :prior, :null=>false
+        end
+        create_function(function_name, (<<-SQL), {:language=>:plpgsql, :returns=>:trigger, :replace=>true}.merge(opts[:function_opts]||{}))
+        BEGIN
+          INSERT INTO #{quote_schema_table(table)} (txid, at, "user", "schema", "table", action, prior) VALUES
+          (txid_current(), CURRENT_TIMESTAMP, CURRENT_USER, TG_TABLE_SCHEMA, TG_TABLE_NAME, TG_OP, to_jsonb(OLD));
+          IF (TG_OP = 'DELETE') THEN
+            RETURN OLD;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+        function_name
+      end
+
+      def pgt_json_audit_log(table, function, opts={})
+        create_trigger(table, (opts[:trigger_name] || "pgt_jal_#{pgt_mangled_table_name(table)}"), function, :events=>[:update, :delete], :each_row=>true, :after=>true)
+      end
+
       def pgt_sum_cache(main_table, main_table_id_column, sum_column, summed_table, summed_table_id_column, summed_column, opts={})
-        trigger_name = opts[:trigger_name] || "pgt_sc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}"
-        function_name = opts[:function_name] || "pgt_sc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}__#{summed_column}"
+        trigger_name = opts[:trigger_name] || "pgt_sc_#{pgt_mangled_table_name(main_table)}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}"
+        function_name = opts[:function_name] || "pgt_sc_#{pgt_mangled_table_name(main_table)}__#{main_table_id_column}__#{sum_column}__#{pgt_mangled_table_name(summed_table)}__#{summed_table_id_column}__#{summed_column}"
 
         table = quote_schema_table(main_table)
         id_column = quote_identifier(summed_table_id_column)
@@ -111,10 +154,10 @@ module Sequel
         summed_table_fk_column = opts.fetch(: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}"
+        trigger_name = opts[:trigger_name] || "pgt_stmc_#{pgt_mangled_table_name(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_#{pgt_mangled_table_name(main_table)}__#{main_table_id_column}__#{sum_column}__#{pgt_mangled_table_name(summed_table)}__#{summed_table_id_column}#{summed_column_slug}__#{pgt_mangled_table_name(join_table)}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        join_trigger_name = opts[:join_trigger_name] || "pgt_stmc_join_#{pgt_mangled_table_name(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_#{pgt_mangled_table_name(main_table)}__#{main_table_id_column}__#{sum_column}__#{pgt_mangled_table_name(summed_table)}__#{summed_table_id_column}#{summed_column_slug}__#{pgt_mangled_table_name(join_table)}__#{main_table_fk_column}__#{summed_table_fk_column}"
 
         orig_summed_table = summed_table
         orig_join_table = join_table
@@ -171,8 +214,8 @@ module Sequel
       end
 
       def pgt_touch(main_table, touch_table, column, expr, opts={})
-        trigger_name = opts[:trigger_name] || "pgt_t_#{main_table}__#{touch_table}"
-        function_name = opts[:function_name] || "pgt_t_#{main_table}__#{touch_table}"
+        trigger_name = opts[:trigger_name] || "pgt_t_#{pgt_mangled_table_name(main_table)}__#{pgt_mangled_table_name(touch_table)}"
+        function_name = opts[:function_name] || "pgt_t_#{pgt_mangled_table_name(main_table)}__#{pgt_mangled_table_name(touch_table)}"
         cond = lambda{|source| expr.map{|k,v| "#{quote_identifier(k)} = #{source}.#{quote_identifier(v)}"}.join(" AND ")}
         same_id = expr.map{|k,v| "NEW.#{quote_identifier(v)} = OLD.#{quote_identifier(v)}"}.join(" AND ")
 
@@ -204,7 +247,7 @@ module Sequel
 
       def pgt_updated_at(table, column, opts={})
         trigger_name = opts[:trigger_name] || "pgt_ua_#{column}"
-        function_name = opts[:function_name] || "pgt_ua_#{table}__#{column}"
+        function_name = opts[:function_name] || "pgt_ua_#{pgt_mangled_table_name(table)}__#{column}"
         pgt_trigger(table, trigger_name, function_name, [:insert, :update], <<-SQL)
         BEGIN
           NEW.#{quote_identifier(column)} := CURRENT_TIMESTAMP;
@@ -216,9 +259,9 @@ module Sequel
       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}"
+        function_name = opts[:function_name] || "pgt_fka_#{pgt_mangled_table_name(table)}__#{column}"
         rtrigger_name = opts[:referenced_trigger_name] || "pgt_rfka_#{column}"
-        rfunction_name = opts[:referenced_function_name] || "pgt_rfka_#{table}__#{column}"
+        rfunction_name = opts[:referenced_function_name] || "pgt_rfka_#{pgt_mangled_table_name(table)}__#{column}"
         col = quote_identifier(column)
         tab = quote_identifier(table)
         rcol = quote_identifier(rcolumn)
@@ -281,6 +324,11 @@ module Sequel
         create_function(function_name, definition, :language=>:plpgsql, :returns=>:trigger, :replace=>true)
         create_trigger(table, trigger_name, function_name, :events=>events, :each_row=>true, :after=>opts[:after])
       end
+
+      # Mangle the schema name so it can be used in an unquoted_identifier
+      def pgt_mangled_table_name(table)
+        quote_schema_table(table).gsub('"', '').gsub(/[^A-Za-z0-9]/, '_').gsub(/_+/, '_')
+      end
     end
 
     module PGTMethods

data/spec/sequel_postgresql_triggers_spec.rb

@@ -1,7 +1,9 @@
 #!/usr/bin/env ruby
 require 'rubygems'
 require 'sequel'
-require 'minitest/spec'
+
+ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
+gem 'minitest'
 require 'minitest/autorun'
 
 DB = Sequel.connect(ENV['PGT_SPEC_DB']||'postgres:///spgt_test?user=postgres')
@@ -16,578 +18,632 @@ else
 end
 DB.extension :pg_array
 
-describe "PostgreSQL Triggers" 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}
+    DB.pgt_counter_cache(:accounts, :id, :num_entries, :entries, :account_id, :function_name=>:spgt_counter_cache)
+    DB[:accounts].insert(:id=>1)
+    DB[:accounts].insert(: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
+    DB[:accounts].order(:id).select_map(:num_entries).must_equal [0, 0]
+
+    DB[:entries].insert(:id=>1, :account_id=>1)
+    DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 0]
+
+    DB[:entries].insert(:id=>2, :account_id=>1)
+    DB[:accounts].order(:id).select_map(:num_entries).must_equal [2, 0]
+    
+    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)
+    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).must_equal [1, 2]
+    
+    DB[:entries].where(:id=>2).update(:account_id=>nil)
+    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).must_equal [1, 1]
+    
+    DB[:entries].where(:id=>4).update(:account_id=>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).must_equal [1, 1]
+    
+    DB[:entries].filter(:id=>4).delete
+    DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 1]
+    
+    DB[:entries].delete
+    DB[:accounts].order(:id).select_map(:num_entries).must_equal [0, 0]
+  end
+end
+
+describe "PostgreSQL Created At Trigger" do
+  before do
+    DB.create_table(:accounts){integer :id; timestamp :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
+    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].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)
+    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
+
+describe "PostgreSQL Immutable Trigger" do
+  before do
+    DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
+    DB.pgt_immutable(:accounts, :balance, :function_name=>:spgt_immutable)
+    DB[:accounts].insert(: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
+    DB[:accounts].update(:id=>2)
+  end
+
+  it "should allow updating a column to its existing value" do
+    DB[:accounts].update(:balance=>0)
+    DB[:accounts].update(:balance=>Sequel.*(:balance, :balance))
+  end
+
+  it "should not allow modifying a column's value" do
+    proc{DB[:accounts].update(:balance=>1)}.must_raise(Sequel::DatabaseError)
+  end
+
+  it "should handle NULL values correctly" do
+    proc{DB[:accounts].update(:balance=>nil)}.must_raise(Sequel::DatabaseError)
+    DB[:accounts].delete
+    DB[:accounts].insert(:id=>1, :balance=>nil)
+    DB[:accounts].update(:balance=>nil)
+    proc{DB[:accounts].update(:balance=>0)}.must_raise(Sequel::DatabaseError)
+  end
+end
+
+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}
+    DB.pgt_sum_cache(:accounts, :id, :balance, :entries, :account_id, :amount, :function_name=>:spgt_sum_cache)
+    DB[:accounts].insert(:id=>1)
+    DB[:accounts].insert(: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(:balance).must_equal [0, 0]
+
+    DB[:entries].insert(:id=>1, :account_id=>1, :amount=>100)
+    DB[:accounts].order(:id).select_map(:balance).must_equal [100, 0]
+
+    DB[:entries].insert(:id=>2, :account_id=>1, :amount=>200)
+    DB[:accounts].order(:id).select_map(:balance).must_equal [300, 0]
+    
+    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)
+    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).must_equal [400, 1000]
+    
+    DB[:entries].where(:id=>2).update(:account_id=>2)
+    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).must_equal [200, 1000]
+    
+    DB[:entries].where(:id=>2).update(:id=>4)
+    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).must_equal [200, 1200]
+    
+    DB[:entries].where(:id=>4).update(:account_id=>nil)
+    DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
+    
+    DB[:entries].filter(:id=>4).delete
+    DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
+    
+    DB[:entries].delete
+    DB[:accounts].order(:id).select_map(:balance).must_equal [0, 0]
+  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].insert(:id=>1)
+    DB[:accounts].insert(: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].insert(:id=>1, :account_id=>1, :amount=>100)
+    DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 0]
+
+    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].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)
+    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}
+    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,
+      :function_name=>:spgt_stm_cache,
+      :join_function_name=>:spgt_stm_cache_join
+    )
+    DB[:parents].insert(:id=>1)
+    DB[:parents].insert(: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(:balance).must_equal [0, 0]
+
+    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].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].insert(:id=>3, :amount=>500)
+    DB[:parents].order(:id).select_map(:balance).must_equal [300, 0]
+    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].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]
+
+    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].insert(: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].insert(: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 Sum Through Many Cache Trigger with arbitrary expression" do
   before do
-    DB.create_language(:plpgsql) if DB.server_version < 90000
+    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].insert(:id=>1)
+    DB[:parents].insert(:id=>2)
   end
+
   after do
-    DB.drop_language(:plpgsql, :cascade=>true) if DB.server_version < 90000
-  end
-
-  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}
-      DB.pgt_counter_cache(:accounts, :id, :num_entries, :entries, :account_id, :function_name=>:spgt_counter_cache)
-      DB[:accounts].insert(:id=>1)
-      DB[:accounts].insert(: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
-      DB[:accounts].order(:id).select_map(:num_entries).must_equal [0, 0]
-
-      DB[:entries].insert(:id=>1, :account_id=>1)
-      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 0]
-
-      DB[:entries].insert(:id=>2, :account_id=>1)
-      DB[:accounts].order(:id).select_map(:num_entries).must_equal [2, 0]
-      
-      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)
-      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).must_equal [1, 2]
-      
-      DB[:entries].where(:id=>2).update(:account_id=>nil)
-      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).must_equal [1, 1]
-      
-      DB[:entries].where(:id=>4).update(:account_id=>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).must_equal [1, 1]
-      
-      DB[:entries].filter(:id=>4).delete
-      DB[:accounts].order(:id).select_map(:num_entries).must_equal [1, 1]
-      
-      DB[:entries].delete
-      DB[:accounts].order(:id).select_map(:num_entries).must_equal [0, 0]
-    end
-  end
-
-  describe "PostgreSQL Created At Trigger" do
-    before do
-      DB.create_table(:accounts){integer :id; timestamp :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
-      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].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)
-      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
-
-  describe "PostgreSQL Immutable Trigger" do
-    before do
-      DB.create_table(:accounts){integer :id; integer :balance, :default=>0}
-      DB.pgt_immutable(:accounts, :balance, :function_name=>:spgt_immutable)
-      DB[:accounts].insert(: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
-      DB[:accounts].update(:id=>2)
-    end
-
-    it "Should allow updating a column to its existing value" do
-      DB[:accounts].update(:balance=>0)
-      DB[:accounts].update(:balance=>Sequel.*(:balance, :balance))
-    end
-
-    it "Should not allow modifying a column's value" do
-      proc{DB[:accounts].update(:balance=>1)}.must_raise(Sequel::DatabaseError)
-    end
-
-    it "Should handle NULL values correctly" do
-      proc{DB[:accounts].update(:balance=>nil)}.must_raise(Sequel::DatabaseError)
-      DB[:accounts].delete
-      DB[:accounts].insert(:id=>1, :balance=>nil)
-      DB[:accounts].update(:balance=>nil)
-      proc{DB[:accounts].update(:balance=>0)}.must_raise(Sequel::DatabaseError)
-    end
-  end
-
-  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}
-      DB.pgt_sum_cache(:accounts, :id, :balance, :entries, :account_id, :amount, :function_name=>:spgt_sum_cache)
-      DB[:accounts].insert(:id=>1)
-      DB[:accounts].insert(: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(:balance).must_equal [0, 0]
-
-      DB[:entries].insert(:id=>1, :account_id=>1, :amount=>100)
-      DB[:accounts].order(:id).select_map(:balance).must_equal [100, 0]
-
-      DB[:entries].insert(:id=>2, :account_id=>1, :amount=>200)
-      DB[:accounts].order(:id).select_map(:balance).must_equal [300, 0]
-      
-      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)
-      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).must_equal [400, 1000]
-      
-      DB[:entries].where(:id=>2).update(:account_id=>2)
-      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).must_equal [200, 1000]
-      
-      DB[:entries].where(:id=>2).update(:id=>4)
-      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).must_equal [200, 1200]
-      
-      DB[:entries].where(:id=>4).update(:account_id=>nil)
-      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
-      
-      DB[:entries].filter(:id=>4).delete
-      DB[:accounts].order(:id).select_map(:balance).must_equal [200, 1000]
-      
-      DB[:entries].delete
-      DB[:accounts].order(:id).select_map(:balance).must_equal [0, 0]
-    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].insert(:id=>1)
-      DB[:accounts].insert(: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].insert(:id=>1, :account_id=>1, :amount=>100)
-      DB[:accounts].order(:id).select_map(:nonzero_entries_count).must_equal [1, 0]
-
-      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].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)
-      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}
-      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,
-        :function_name=>:spgt_stm_cache,
-        :join_function_name=>:spgt_stm_cache_join
-      )
-      DB[:parents].insert(:id=>1)
-      DB[:parents].insert(: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(:balance).must_equal [0, 0]
-
-      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].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].insert(:id=>3, :amount=>500)
-      DB[:parents].order(:id).select_map(:balance).must_equal [300, 0]
-      DB[:links].insert(:parent_id=>2, :child_id=>3)
-      DB[:parents].order(:id).select_map(:balance).must_equal [300, 500]
+    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[: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].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]
+    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[: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].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].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
-      DB[:parents].order(:id).select_map(:balance).must_equal [400, 1000]
+    DB[:children].insert(:id=>3, :amount=>500)
+    DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
+    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=>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=>3).update(:parent_id=>1)
+    DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [3, 0]
 
-      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[: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]
 
-      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].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[:links].insert(:parent_id=>2, :child_id=>4)
-      DB[:parents].order(:id).select_map(:balance).must_equal [1200, 1800]
+    DB[:children].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
+    DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
 
-      DB[:children].filter(:id=>4).delete
-      DB[:parents].order(:id).select_map(:balance).must_equal [1200, 1000]
+    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].filter(:parent_id=>1, :child_id=>1).delete
-      DB[:parents].order(:id).select_map(:balance).must_equal [1000, 1000]
+    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[:children].insert(:id=>4, :amount=>400)
-      DB[:parents].order(:id).select_map(:balance).must_equal [1000, 1400]
+    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[:children].delete
-      DB[:parents].order(:id).select_map(:balance).must_equal [0, 0]
+    DB[:links].insert(:parent_id=>2, :child_id=>4)
+    DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 2]
 
-      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[:children].filter(:id=>4).delete
+    DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
 
-      DB[:links].where(:child_id=>3).update(:child_id=>2)
-      DB[:parents].order(:id).select_map(:balance).must_equal [200, 600]
+    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].update(:amount=>10)
-      DB[:parents].order(:id).select_map(:balance).must_equal [10, 20]
+    DB[:children].insert(:id=>4, :amount=>400)
+    DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [1, 2]
 
-      DB[:links].delete
-      DB[:parents].order(:id).select_map(:balance).must_equal [0, 0]
-    end
+    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 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].insert(:id=>1)
-      DB[:parents].insert(:id=>2)
-    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, :function_name=>:spgt_updated_at)
+  end
 
-    after do
-      DB.drop_table(:links, :parents, :children)
-      DB.drop_function(:spgt_stm_cache)
-      DB.drop_function(:spgt_stm_cache_join)
-    end
+  after do
+    DB.drop_table(:accounts)
+    DB.drop_function(:spgt_updated_at)
+  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]
+  it "should set the column always to the current timestamp" do
+    DB[:accounts].insert(:id=>1)
+    t = DB[:accounts].get(:changed_on)
+    t.strftime('%F').must_equal Date.today.strftime('%F')
+    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)
+    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
 
-      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]
+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}
+  end
 
-      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]
+  after do
+    DB.drop_table(:children, :parents)
+    DB.drop_function(:spgt_touch)
+    DB.drop_function(:spgt_touch2) if @spgt_touch2
+  end
 
-      DB[:children].insert(:id=>3, :amount=>500)
-      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 0]
-      DB[:links].insert(:parent_id=>2, :child_id=>3)
-      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+  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}, :function_name=>:spgt_touch)
+    d = Date.today
+    d30 = Date.today - 30
+    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)
+    DB[:children].update(:id=>2)
+    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')}.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')}.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')}.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')}.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')}.must_equal [d30.strftime('%F'), d.strftime('%F')]
+
+    DB[:parents].update(:changed_on=>d30)
+    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')]
+  end
 
-      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]
+  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].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)
+    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').must_equal Date.today.strftime('%F')
+  end
+
+  it "should update timestamps correctly when two tables touch each other" 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].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)
+    DB[:parents].update(:id2=>4)
+    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).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).must_be :>,  time
+  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}, :function_name=>:spgt_touch)
+    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
 
-      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]
+  after do
+    DB.drop_table(:entries, :accounts)
+    DB.drop_function(:spgt_foreign_key_array)
+    DB.drop_function(:spgt_referenced_foreign_key_array)
+  end
 
-      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]
+  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
 
-      DB[:children].exclude(:id=>2).update(:amount=>Sequel.*(:amount, 2))
-      DB[:parents].order(:id).select_map(:nonzero_entries_count).must_equal [2, 1]
+describe "PostgreSQL Force Defaults Trigger" do
+  before do
+    DB.create_table(:accounts){integer :id; integer :a, :default=>0; String :b; integer :c; integer :d, :default=>4}
+    DB.pgt_force_defaults(:accounts, {:a=>1, :b=>"'\\a", :c=>nil}, :function_name=>:spgt_force_defaults)
+    @ds = DB[:accounts]
+  end
 
-      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]
+  after do
+    DB.drop_table(:accounts)
+    DB.drop_function(:spgt_force_defaults)
+  end
 
-      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]
+  it "should override default values when inserting" do
+    @ds.insert
+    DB[:accounts].first.must_equal(:id=>nil, :a=>1, :b=>"'\\a", :c=>nil, :d=>4)
 
-      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].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
-      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].insert(: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, :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
-      DB[:accounts].insert(:id=>1)
-      t = DB[:accounts].get(:changed_on)
-      t.strftime('%F').must_equal Date.today.strftime('%F')
-      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)
-      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
-
-  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}
-    end
-
-    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}, :function_name=>:spgt_touch)
-      d = Date.today
-      d30 = Date.today - 30
-      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)
-      DB[:children].update(:id=>2)
-      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')}.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')}.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')}.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')}.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')}.must_equal [d30.strftime('%F'), d.strftime('%F')]
-
-      DB[:parents].update(:changed_on=>d30)
-      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')]
-    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}, :function_name=>:spgt_touch)
-      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)
-      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').must_equal Date.today.strftime('%F')
-    end
-
-    it "Should update timestamps correctly when two tables touch each other" 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].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)
-      DB[:parents].update(:id2=>4)
-      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).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).must_be :>,  time
-    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}, :function_name=>:spgt_touch)
-      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
+    @ds.delete
+    @ds.insert(:id=>10, :a=>11, :b=>12, :c=>13, :d=>14)
+    DB[:accounts].first.must_equal(:id=>10, :a=>1, :b=>"'\\a", :c=>nil, :d=>14)
   end
 end
+
+
+describe "PostgreSQL JSON Audit Logging" do
+  before do
+    DB.extension :pg_json
+    DB.create_table(:accounts){integer :id; integer :a}
+    DB.pgt_json_audit_log_setup(:table_audit_logs, :function_name=>:spgt_audit_log)
+    DB.pgt_json_audit_log(:accounts, :spgt_audit_log)
+    @ds = DB[:accounts]
+    @ds.insert(:id=>1)
+    @logs = DB[:table_audit_logs].reverse(:at)
+  end
+
+  after do
+    DB.drop_table(:accounts, :table_audit_logs)
+    DB.drop_function(:spgt_audit_log)
+  end
+
+  it "should previous values in JSON format for inserts and updates" do
+    @logs.first.must_be_nil
+
+    @ds.update(:id=>2, :a=>3)
+    @ds.all.must_equal [{:id=>2, :a=>3}]
+    h = @logs.first
+    h.delete(:at).to_i.must_be_within_delta(10, DB.get(Sequel::CURRENT_TIMESTAMP).to_i)
+    h.delete(:user).must_be_kind_of(String)
+    txid1 = h.delete(:txid)
+    txid1.must_be_kind_of(Integer)
+    h.must_equal(:schema=>"public", :table=>"accounts", :action=>"UPDATE", :prior=>{"a"=>nil, "id"=>1})
+
+    @ds.delete
+    @ds.all.must_equal []
+    h = @logs.first
+    h.delete(:at).to_i.must_be_within_delta(10, DB.get(Sequel::CURRENT_TIMESTAMP).to_i)
+    h.delete(:user).must_be_kind_of(String)
+    txid2 = h.delete(:txid)
+    txid2.must_be_kind_of(Integer)
+    txid2.must_be :>, txid1
+    h.must_equal(:schema=>"public", :table=>"accounts", :action=>"DELETE", :prior=>{"a"=>3, "id"=>2})
+  end
+end if DB.server_version >= 90400