sequel_postgresql_triggers 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c908ae3d087271626842952b60bc22365793a3d9
-  data.tar.gz: 1cf7c4c70437c36ab0852d566d600756314c90d5
+  metadata.gz: 4d2e84d8e162f972268dc9839f8f744651ff15ca
+  data.tar.gz: 343a12a7c9531e694a92eeb1a037821095401bc2
 SHA512:
-  metadata.gz: 6f10299a3e24a54147217af11e85317484b02b43a0f9faba1120f5f1bfdd402b8f281c4b403f0f785175c94196d6079a9719667965383102e5732f6e0ca1c9b9
-  data.tar.gz: 06f7baa57db107b2fec9d169ebe03f87b737f611adbc302e8af3f0dda2695d0c96d74dd68b50be4b1c7cb0715c4f40b1b17318f41bdf1ed2755defdf94e70ea2
+  metadata.gz: 931984b649f29b90b738e00546c0c388fbea363136afc736cfcd69a0ff69b36d90ec5f429d2f5c3157b41b246eb9d9aaa13798f30c5eb12a205ed6f4bbe27c54
+  data.tar.gz: 7061eb0436fbe68db834aa130b503a834871bc2f554025fd851ce2411edd3bf964697d84a1feb01a979e40f644862b15ffd386d967a02849ca9b6c0ac45af61f

data/README.rdoc

@@ -0,0 +1,175 @@
+= Sequel PostgreSQL Triggers
+
+Sequel PostgreSQL Triggers is a small enhancement to Sequel allowing
+a user to easily handle the following types of columns:
+
+* Timestamp Columns (Created At/Updated At)
+* Counter/Sum Caches
+* Immutable Columns
+* Touch Propogation
+
+It handles these internally to the database via triggers, so even if
+other applications access the database (without using Sequel), things
+will still work (unless the database superuser disables triggers).
+
+To use this, load the +pg_triggers+ extension into the Sequel::Database
+object:
+
+  DB.extension :pg_triggers
+
+Then you can call the pgt_* methods it adds on your Sequel::Database
+object:
+
+  DB.pgt_created_at(:table_name, :created_at)
+
+Most commonly, this is used in migrations, with a structure similar
+to:
+
+  Sequel.migration do
+    up do
+      extension :pg_triggers
+
+      pgt_created_at(:table_name,
+                     :created_at,
+                     :function_name=>:table_name_set_created_at,
+                     :trigger_name=>:set_created_at)
+    end
+
+    down do
+      drop_trigger(:table_name, :set_created_at)
+      drop_function(:table_name_set_created_at)
+    end
+  end
+
+Note that you only need to load this extension when defining the
+triggers, you don't need to load this extension when your
+application is running.
+
+To use any of these methods before PostgreSQL 9.0, you have to add
+the plpgsql procedural language to PostgreSQL, which you can do with:
+
+  DB.create_language(:plpgsql)
+
+If you want to load this extension globally for all PostgreSQL
+databases, you can do:
+
+  require 'sequel_postgresql_triggers'
+
+However, global modification is discouraged and only remains for
+backwards compatibility.
+
+== Triggers
+
+All of the public methods this extension adds take the following options
+in their opts hash:
+
+:function_name :: The name of the function to use.  This is important
+                  to specify if you want an easy way to drop the function.
+:trigger_name :: The name of the trigger to use.  This is important
+                 to specify if you want an easy way to drop the trigger.
+
+=== Created At Columns - pgt_created_at
+
+pgt_created_at takes the table and column given and makes it so that
+upon insertion, the column is set to the CURRENT_TIMESTAMP, and that
+upon update, the column's value is always set to the previous value.
+This is sort of like an immutable column, but it doesn't bring up an
+error if you try to change it, it just ignores it.
+
+Arguments:
+table :: name of table
+column :: column in table that should be a created at timestamp column
+opts :: option hash
+
+=== Updated At Columns - pgt_updated_at
+
+Similar to pgt_created_at, takes a table and column and makes it so
+that upon insertion, the column is set to CURRENT_TIMESTAMP. It
+differs that upon update, the column is also set to CURRENT_TIMESTAMP.
+
+Arguments:
+table :: name of table
+column :: column in table that should be a updated at timestamp column
+opts :: options hash
+
+=== Counter Cache - pgt_counter_cache
+
+This takes quite a few arguments (see the RDoc) and sets up a
+counter cache so that when the counted table is inserted to
+or deleted from, records in the main table are updated with the
+count of the corresponding records in the counted table.  The counter
+cache column must have a default of 0 for this to work correctly.
+
+Arguments:
+main_table :: name of table holding counter cache column
+main_table_id_column :: column in main table matching counted_table_id_column in counted_table
+counter_column :: column in main table containing the counter cache
+counted_table :: name of table being counted
+counted_table_id_column :: column in counted_table matching main_table_id_column in main_table
+opts :: options hash
+
+=== Sum Cache - pgt_sum_cache
+
+Similar to pgt_counter_cache, except instead of storing a count
+of records in the main table, it stores the sum on one of the
+columns in summed table. The sum cache column must have a default
+of 0 for this to work correctly.
+
+Arguments:
+main_table :: name of table holding counter cache column
+main_table_id_column :: column in main table matching counted_table_id_column in counted_table
+sum_column :: column in main table containing the sum cache
+summed_table :: name of table being summed
+summed_table_id_column :: column in summed_table matching main_table_id_column in main_table
+summed_column :: column in summed_table being summed
+opts :: options hash
+
+=== Sum Through Many Cache - pgt_sum_through_many_cache
+
+Similar to pgt_sum_cache, except instead of a one-to-many relationship,
+it supports a many-to-many relationship with a single join table. The
+sum cache column must have a default of 0 for this to work correctly.
+
+This takes a single options hash argument, supporting the following options
+in addition to the standard options:
+:main_table :: name of table holding sum cache column
+:main_table_id_column :: primary key column in main table referenced by main_table_fk_column (default: :id)
+:sum_column :: column in main table containing the sum cache, must be NOT NULL and default to 0
+:summed_table :: name of table being summed
+:summed_table_id_column :: primary key column in summed_table referenced by summed_table_fk_column (default: :id)
+:summed_column :: column in summed_table being summed, must be NOT NULL
+:join_table :: name of table which joins main_table with summed_table
+:main_table_fk_column :: column in join_table referencing main_table_id_column, must be NOT NULL
+:summed_table_fk_column :: column in join_table referencing summed_table_id_column, must be NOT NULL
+
+=== Immutable Columns - pgt_immutable
+
+This takes a table name and one or more column names, and adds
+an update trigger that raises an exception if you try to modify
+the value of any of the columns.
+
+Arguments:
+table :: name of table
+*columns :: All columns in the table that should be immutable.  Can end with options hash.
+
+=== Touch Propagation - pgt_touch
+
+This takes several arguments (again, see the RDoc) and sets up a
+trigger that watches one table for changes, and touches timestamps
+of related rows in a separate table.
+
+Arguments:
+main_table :: name of table that is being watched for changes
+touch_table :: name of table that needs to be touched
+column :: name of timestamp column to be touched
+expr :: hash or array that represents the columns that define the relationship
+opts :: options hash
+
+== License
+
+This library is released under the MIT License.  See the MIT-LICENSE
+file for details.
+
+== Author
+
+Jeremy Evans <code@jeremyevans.net>

data/lib/sequel/extensions/pg_triggers.rb

@@ -0,0 +1,225 @@
+# The pg_triggers extension adds support to the Database instance for easily
+# creating triggers and trigger returning functions for common needs.
+
+#
+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}"
+
+        table = quote_schema_table(main_table)
+        id_column = quote_identifier(counted_table_id_column)
+        main_column = quote_identifier(main_table_id_column)
+        count_column = quote_identifier(counter_column)
+
+        pgt_trigger(counted_table, trigger_name, function_name, [:insert, :update, :delete], <<-SQL)
+        BEGIN
+          IF (TG_OP = 'UPDATE' AND (NEW.#{id_column} = OLD.#{id_column} OR (OLD.#{id_column} IS NULL AND NEW.#{id_column} IS NULL))) THEN
+            RETURN NEW;
+          ELSE
+            IF ((TG_OP = 'INSERT' OR TG_OP = 'UPDATE') AND NEW.#{id_column} IS NOT NULL) THEN
+              UPDATE #{table} SET #{count_column} = #{count_column} + 1 WHERE #{main_column} = NEW.#{id_column};
+            END IF;
+            IF ((TG_OP = 'DELETE' OR TG_OP = 'UPDATE') AND OLD.#{id_column} IS NOT NULL) THEN
+              UPDATE #{table} SET #{count_column} = #{count_column} - 1 WHERE #{main_column} = OLD.#{id_column};
+            END IF;
+          END IF;
+
+          IF (TG_OP = 'DELETE') THEN
+            RETURN OLD;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+      end
+
+      def pgt_created_at(table, column, opts={})
+        trigger_name = opts[:trigger_name] || "pgt_ca_#{column}"
+        function_name = opts[:function_name] || "pgt_ca_#{table}__#{column}"
+        col = quote_identifier(column)
+        pgt_trigger(table, trigger_name, function_name, [:insert, :update], <<-SQL)
+        BEGIN
+          IF (TG_OP = 'UPDATE') THEN
+            NEW.#{col} := OLD.#{col};
+          ELSIF (TG_OP = 'INSERT') THEN
+            NEW.#{col} := CURRENT_TIMESTAMP;
+          END IF;
+          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('__')}"
+        function_name = opts[:function_name] || "pgt_im_#{columns.join('__')}"
+        ifs = columns.map do |c|
+          old = "OLD.#{quote_identifier(c)}"
+          new = "NEW.#{quote_identifier(c)}"
+          <<-END
+            IF #{new} IS DISTINCT FROM #{old} THEN
+                RAISE EXCEPTION 'Attempted #{c} update: Old: %, New: %', #{old}, #{new};
+            END IF;
+          END
+        end.join("\n")
+        pgt_trigger(table, trigger_name, function_name, :update, "BEGIN #{ifs} RETURN NEW; END;")
+      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}"
+
+        table = quote_schema_table(main_table)
+        id_column = quote_identifier(summed_table_id_column)
+        summed_column = quote_identifier(summed_column)
+        main_column = quote_identifier(main_table_id_column)
+        sum_column = quote_identifier(sum_column)
+
+        pgt_trigger(summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL)
+        BEGIN
+          IF (TG_OP = 'UPDATE' AND NEW.#{id_column} = OLD.#{id_column}) THEN
+            UPDATE #{table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} - OLD.#{summed_column} WHERE #{main_column} = NEW.#{id_column};
+          ELSE
+            IF ((TG_OP = 'INSERT' OR TG_OP = 'UPDATE') AND NEW.#{id_column} IS NOT NULL) THEN
+              UPDATE #{table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} WHERE #{main_column} = NEW.#{id_column};
+            END IF;
+            IF ((TG_OP = 'DELETE' OR TG_OP = 'UPDATE') AND OLD.#{id_column} IS NOT NULL) THEN
+              UPDATE #{table} SET #{sum_column} = #{sum_column} - OLD.#{summed_column} WHERE #{main_column} = OLD.#{id_column};
+            END IF;
+          END IF;
+          IF (TG_OP = 'DELETE') THEN
+            RETURN OLD;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+      end
+
+      def pgt_sum_through_many_cache(opts={})
+        main_table = opts.fetch(:main_table)
+        main_table_id_column = opts.fetch(:main_table_id_column, :id)
+        sum_column = opts.fetch(:sum_column)
+        summed_table = opts.fetch(:summed_table)
+        summed_table_id_column = opts.fetch(:summed_table_id_column, :id)
+        summed_column = opts.fetch(:summed_column)
+        join_table = opts.fetch(:join_table)
+        main_table_fk_column = opts.fetch(:main_table_fk_column)
+        summed_table_fk_column = opts.fetch(:summed_table_fk_column)
+
+        trigger_name = opts[:trigger_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}__#{summed_column}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        function_name = opts[:function_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}__#{summed_column}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        join_trigger_name = opts[:join_trigger_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}__#{summed_column}__#{main_table_fk_column}__#{summed_table_fk_column}"
+        join_function_name = opts[:join_function_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}__#{summed_column}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
+
+        orig_summed_table = summed_table
+        orig_join_table = join_table
+
+        main_table = quote_schema_table(main_table)
+        main_table_id_column = quote_schema_table(main_table_id_column)
+        sum_column = quote_schema_table(sum_column)
+        summed_table = quote_schema_table(summed_table)
+        summed_table_id_column = quote_schema_table(summed_table_id_column)
+        summed_column = quote_schema_table(summed_column)
+        join_table = quote_schema_table(join_table)
+        main_table_fk_column = quote_schema_table(main_table_fk_column)
+        summed_table_fk_column = quote_schema_table(summed_table_fk_column)
+
+        pgt_trigger(orig_summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL)
+        BEGIN
+          IF (TG_OP = 'UPDATE' AND NEW.#{summed_table_id_column} = OLD.#{summed_table_id_column}) THEN
+            UPDATE #{main_table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} - OLD.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
+          ELSE
+            IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
+            END IF;
+            IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - OLD.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = OLD.#{summed_table_id_column});
+            END IF;
+          END IF;
+          IF (TG_OP = 'DELETE') THEN
+            RETURN OLD;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+
+        pgt_trigger(orig_join_table, join_trigger_name, join_function_name, [:insert, :delete, :update], <<-SQL)
+        BEGIN
+          IF (NOT (TG_OP = 'UPDATE' AND NEW.#{main_table_fk_column} = OLD.#{main_table_fk_column} AND NEW.#{summed_table_fk_column} = OLD.#{summed_table_fk_column})) THEN
+            IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + (SELECT #{summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = NEW.#{summed_table_fk_column}) WHERE #{main_table_id_column} = NEW.#{main_table_fk_column};
+            END IF;
+            IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
+              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - (SELECT #{summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = OLD.#{summed_table_fk_column}) WHERE #{main_table_id_column} = OLD.#{main_table_fk_column};
+            END IF;
+          END IF;
+          IF (TG_OP = 'DELETE') THEN
+            RETURN OLD;
+          END IF;
+          RETURN NEW;
+        END;
+        SQL
+      end
+
+      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}"
+        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 ")
+
+        table = quote_schema_table(touch_table)
+        col = quote_identifier(column)
+        update = lambda{|source| " UPDATE #{table} SET #{col} = CURRENT_TIMESTAMP WHERE #{cond[source]} AND ((#{col} <> CURRENT_TIMESTAMP) OR (#{col} IS NULL));"}
+
+        sql = <<-SQL
+          BEGIN
+            IF (TG_OP = 'UPDATE' AND (#{same_id})) THEN
+              #{update['NEW']}
+            ELSE
+              IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
+                #{update['NEW']}
+              END IF;
+              IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
+                #{update['OLD']}
+              END IF;
+            END IF;
+
+            IF (TG_OP = 'DELETE') THEN
+              RETURN OLD;
+            END IF;
+            RETURN NEW;
+          END;
+        SQL
+        pgt_trigger(main_table, trigger_name, function_name, [:insert, :delete, :update], sql, :after=>true)
+      end
+
+      def pgt_updated_at(table, column, opts={})
+        trigger_name = opts[:trigger_name] || "pgt_ua_#{column}"
+        function_name = opts[:function_name] || "pgt_ua_#{table}__#{column}"
+        pgt_trigger(table, trigger_name, function_name, [:insert, :update], <<-SQL)
+        BEGIN
+          NEW.#{quote_identifier(column)} := CURRENT_TIMESTAMP;
+          RETURN NEW;
+        END;
+        SQL
+      end
+
+      private
+
+      # Add or replace a function that returns trigger to handle the action,
+      # and add a trigger that calls the function.
+      def pgt_trigger(table, trigger_name, function_name, events, definition, opts={})
+        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
+    end
+
+    module PGTMethods
+      class_eval(&PGT_DEFINE)
+    end
+  end
+
+  Database.register_extension(:pg_triggers, Postgres::PGTMethods)
+end

data/lib/sequel_postgresql_triggers.rb

@@ -1,290 +1,9 @@
+require 'sequel/extensions/pg_triggers'
+
 module Sequel
   module Postgres
-    # Add the pgt_* methods so that any Sequel database connecting to PostgreSQL
-    # can use them.  All of these methods require the plpgsql procedural language
-    # be added to the PostgreSQL database before they can be used. On PostgreSQL
-    # 9.0 and later versions, it is installed by default.  For older versions,
-    # you can install it with:
-    #
-    #   DB.create_language(:plpgsql)
-    #
-    # All of the public methods take the following options in their opts hash:
-    #
-    # * :function_name: The name of the function to use.  This is important
-    #   to specify if you want an easy way to drop the function.
-    # * :trigger_name: The name of the trigger to use.  This is important
-    #   to specify if you want an easy way to drop the trigger.
     module DatabaseMethods
-      # Turns a column in the main table into a counter cache.  A counter cache is a
-      # column in the main table with the number of rows in the counted table
-      # for the matching id. Arguments:
-      # * main_table : name of table holding counter cache column
-      # * main_table_id_column : column in main table matching counted_table_id_column in counted_table
-      # * counter_column : column in main table containing the counter cache
-      # * counted_table : name of table being counted
-      # * counted_table_id_column : column in counted_table matching main_table_id_column in main_table
-      # * opts : option hash, see module documentation
-      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}"
-
-        table = quote_schema_table(main_table)
-        id_column = quote_identifier(counted_table_id_column)
-        main_column = quote_identifier(main_table_id_column)
-        count_column = quote_identifier(counter_column)
-
-        pgt_trigger(counted_table, trigger_name, function_name, [:insert, :update, :delete], <<-SQL)
-        BEGIN
-          IF (TG_OP = 'UPDATE' AND (NEW.#{id_column} = OLD.#{id_column} OR (OLD.#{id_column} IS NULL AND NEW.#{id_column} IS NULL))) THEN
-            RETURN NEW;
-          ELSE
-            IF ((TG_OP = 'INSERT' OR TG_OP = 'UPDATE') AND NEW.#{id_column} IS NOT NULL) THEN
-              UPDATE #{table} SET #{count_column} = #{count_column} + 1 WHERE #{main_column} = NEW.#{id_column};
-            END IF;
-            IF ((TG_OP = 'DELETE' OR TG_OP = 'UPDATE') AND OLD.#{id_column} IS NOT NULL) THEN
-              UPDATE #{table} SET #{count_column} = #{count_column} - 1 WHERE #{main_column} = OLD.#{id_column};
-            END IF;
-          END IF;
-
-          IF (TG_OP = 'DELETE') THEN
-            RETURN OLD;
-          END IF;
-          RETURN NEW;
-        END;
-        SQL
-      end
-
-      # Turns a column in the table into a created at timestamp column, which
-      # always contains the timestamp the record was inserted into the database.
-      # Arguments:
-      # * table : name of table
-      # * column : column in table that should be a created at timestamp column
-      # * opts : option hash, see module documentation
-      def pgt_created_at(table, column, opts={})
-        trigger_name = opts[:trigger_name] || "pgt_ca_#{column}"
-        function_name = opts[:function_name] || "pgt_ca_#{table}__#{column}"
-        col = quote_identifier(column)
-        pgt_trigger(table, trigger_name, function_name, [:insert, :update], <<-SQL)
-        BEGIN
-          IF (TG_OP = 'UPDATE') THEN
-            NEW.#{col} := OLD.#{col};
-          ELSIF (TG_OP = 'INSERT') THEN
-            NEW.#{col} := CURRENT_TIMESTAMP;
-          END IF;
-          RETURN NEW;
-        END;
-        SQL
-      end
-
-      # Makes all given columns in the given table immutable, so an exception
-      # is raised if there is an attempt to modify the value when updating the
-      # record. Arguments:
-      # * table : name of table
-      # * columns : All columns in the table that should be immutable.  Can end with a hash of options, see module documentation.
-      def pgt_immutable(table, *columns)
-        opts = columns.last.is_a?(Hash) ? columns.pop : {}
-        trigger_name = opts[:trigger_name] || "pgt_im_#{columns.join('__')}"
-        function_name = opts[:function_name] || "pgt_im_#{columns.join('__')}"
-        ifs = columns.map do |c|
-          old = "OLD.#{quote_identifier(c)}"
-          new = "NEW.#{quote_identifier(c)}"
-          <<-END
-            IF #{new} IS DISTINCT FROM #{old} THEN
-                RAISE EXCEPTION 'Attempted #{c} update: Old: %, New: %', #{old}, #{new};
-            END IF;
-          END
-        end.join("\n")
-        pgt_trigger(table, trigger_name, function_name, :update, "BEGIN #{ifs} RETURN NEW; END;")
-      end
-
-      # Turns a column in the main table into a sum cache.  A sum cache is a
-      # column in the main table with the sum of a column in the summed table
-      # for the matching id. Arguments:
-      # * main_table : name of table holding counter cache column
-      # * main_table_id_column : column in main table matching counted_table_id_column in counted_table
-      # * sum_column : column in main table containing the sum cache
-      # * summed_table : name of table being summed
-      # * summed_table_id_column : column in summed_table matching main_table_id_column in main_table
-      # * summed_column : column in summed_table being summed
-      # * opts : option hash, see module documentation
-      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}"
-
-        table = quote_schema_table(main_table)
-        id_column = quote_identifier(summed_table_id_column)
-        summed_column = quote_identifier(summed_column)
-        main_column = quote_identifier(main_table_id_column)
-        sum_column = quote_identifier(sum_column)
-
-        pgt_trigger(summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL)
-        BEGIN
-          IF (TG_OP = 'UPDATE' AND NEW.#{id_column} = OLD.#{id_column}) THEN
-            UPDATE #{table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} - OLD.#{summed_column} WHERE #{main_column} = NEW.#{id_column};
-          ELSE
-            IF ((TG_OP = 'INSERT' OR TG_OP = 'UPDATE') AND NEW.#{id_column} IS NOT NULL) THEN
-              UPDATE #{table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} WHERE #{main_column} = NEW.#{id_column};
-            END IF;
-            IF ((TG_OP = 'DELETE' OR TG_OP = 'UPDATE') AND OLD.#{id_column} IS NOT NULL) THEN
-              UPDATE #{table} SET #{sum_column} = #{sum_column} - OLD.#{summed_column} WHERE #{main_column} = OLD.#{id_column};
-            END IF;
-          END IF;
-          IF (TG_OP = 'DELETE') THEN
-            RETURN OLD;
-          END IF;
-          RETURN NEW;
-        END;
-        SQL
-      end
-
-      # Turns a column in the main table into a sum cache through a join table.
-      # A sum cache is a column in the main table with the sum of a column in the
-      # summed table for the matching id. The join table must have NOT NULL constraints
-      # on the foreign keys to the main table and summed table and a
-      # composite unique constraint on both foreign keys.
-      # 
-      # Arguments:
-      # * opts : option hash, see module documentation, and below.
-      # * :main_table: name of table holding sum cache column
-      # * :main_table_id_column: primary key column in main table referenced by main_table_fk_column (default: :id)
-      # * :sum_column: column in main table containing the sum cache, must be NOT NULL and default to 0
-      # * :summed_table: name of table being summed
-      # * :summed_table_id_column: primary key column in summed_table referenced by summed_table_fk_column (default: ;id)
-      # * :summed_column: column in summed_table being summed, must be NOT NULL
-      # * :join_table: name of table which joins main_table with summed_table
-      # * :main_table_fk_column: column in join_table referencing main_table_id_column, must be NOT NULL
-      # * :summed_table_fk_column: column in join_table referencing summed_table_id_column, must be NOT NULL
-      def pgt_sum_through_many_cache(opts={})
-        main_table = opts.fetch(:main_table)
-        main_table_id_column = opts.fetch(:main_table_id_column, :id)
-        sum_column = opts.fetch(:sum_column)
-        summed_table = opts.fetch(:summed_table)
-        summed_table_id_column = opts.fetch(:summed_table_id_column, :id)
-        summed_column = opts.fetch(:summed_column)
-        join_table = opts.fetch(:join_table)
-        main_table_fk_column = opts.fetch(:main_table_fk_column)
-        summed_table_fk_column = opts.fetch(:summed_table_fk_column)
-
-        trigger_name = opts[:trigger_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}__#{summed_column}__#{main_table_fk_column}__#{summed_table_fk_column}"
-        function_name = opts[:function_name] || "pgt_stmc_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}__#{summed_column}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
-        join_trigger_name = opts[:join_trigger_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table_id_column}__#{summed_column}__#{main_table_fk_column}__#{summed_table_fk_column}"
-        join_function_name = opts[:join_function_name] || "pgt_stmc_join_#{main_table}__#{main_table_id_column}__#{sum_column}__#{summed_table}__#{summed_table_id_column}__#{summed_column}__#{join_table}__#{main_table_fk_column}__#{summed_table_fk_column}"
-
-        orig_summed_table = summed_table
-        orig_join_table = join_table
-
-        main_table = quote_schema_table(main_table)
-        main_table_id_column = quote_schema_table(main_table_id_column)
-        sum_column = quote_schema_table(sum_column)
-        summed_table = quote_schema_table(summed_table)
-        summed_table_id_column = quote_schema_table(summed_table_id_column)
-        summed_column = quote_schema_table(summed_column)
-        join_table = quote_schema_table(join_table)
-        main_table_fk_column = quote_schema_table(main_table_fk_column)
-        summed_table_fk_column = quote_schema_table(summed_table_fk_column)
-
-        pgt_trigger(orig_summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL)
-        BEGIN
-          IF (TG_OP = 'UPDATE' AND NEW.#{summed_table_id_column} = OLD.#{summed_table_id_column}) THEN
-            UPDATE #{main_table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} - OLD.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
-          ELSE
-            IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + NEW.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = NEW.#{summed_table_id_column});
-            END IF;
-            IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - OLD.#{summed_column} WHERE #{main_table_id_column} IN (SELECT #{main_table_fk_column} FROM #{join_table} WHERE #{summed_table_fk_column} = OLD.#{summed_table_id_column});
-            END IF;
-          END IF;
-          IF (TG_OP = 'DELETE') THEN
-            RETURN OLD;
-          END IF;
-          RETURN NEW;
-        END;
-        SQL
-
-        pgt_trigger(orig_join_table, join_trigger_name, join_function_name, [:insert, :delete, :update], <<-SQL)
-        BEGIN
-          IF (NOT (TG_OP = 'UPDATE' AND NEW.#{main_table_fk_column} = OLD.#{main_table_fk_column} AND NEW.#{summed_table_fk_column} = OLD.#{summed_table_fk_column})) THEN
-            IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} + (SELECT #{summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = NEW.#{summed_table_fk_column}) WHERE #{main_table_id_column} = NEW.#{main_table_fk_column};
-            END IF;
-            IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
-              UPDATE #{main_table} SET #{sum_column} = #{sum_column} - (SELECT #{summed_column} FROM #{summed_table} WHERE #{summed_table_id_column} = OLD.#{summed_table_fk_column}) WHERE #{main_table_id_column} = OLD.#{main_table_fk_column};
-            END IF;
-          END IF;
-          IF (TG_OP = 'DELETE') THEN
-            RETURN OLD;
-          END IF;
-          RETURN NEW;
-        END;
-        SQL
-      end
-
-      # When rows in a table are updated, touches a timestamp of related rows
-      # in another table.
-      # Arguments:
-      # * main_table : name of table that is being watched for changes
-      # * touch_table : name of table that needs to be touched
-      # * column : name of timestamp column to be touched
-      # * expr : hash or array that represents the columns that define the relationship
-      # * opts : option hash, see module documentation
-      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}"
-        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 ")
-
-        table = quote_schema_table(touch_table)
-        col = quote_identifier(column)
-        update = lambda{|source| " UPDATE #{table} SET #{col} = CURRENT_TIMESTAMP WHERE #{cond[source]} AND ((#{col} <> CURRENT_TIMESTAMP) OR (#{col} IS NULL));"}
-
-        sql = <<-SQL
-          BEGIN
-            IF (TG_OP = 'UPDATE' AND (#{same_id})) THEN
-              #{update['NEW']}
-            ELSE
-              IF (TG_OP = 'INSERT' OR TG_OP = 'UPDATE') THEN
-                #{update['NEW']}
-              END IF;
-              IF (TG_OP = 'DELETE' OR TG_OP = 'UPDATE') THEN
-                #{update['OLD']}
-              END IF;
-            END IF;
-
-            IF (TG_OP = 'DELETE') THEN
-              RETURN OLD;
-            END IF;
-            RETURN NEW;
-          END;
-        SQL
-        pgt_trigger(main_table, trigger_name, function_name, [:insert, :delete, :update], sql, :after=>true)
-      end
-
-      # Turns a column in the table into a updated at timestamp column, which
-      # always contains the timestamp the record was inserted or last updated.
-      # Arguments:
-      # * table : name of table
-      # * column : column in table that should be a updated at timestamp column
-      # * opts : option hash, see module documentation
-      def pgt_updated_at(table, column, opts={})
-        trigger_name = opts[:trigger_name] || "pgt_ua_#{column}"
-        function_name = opts[:function_name] || "pgt_ua_#{table}__#{column}"
-        pgt_trigger(table, trigger_name, function_name, [:insert, :update], <<-SQL)
-        BEGIN
-          NEW.#{quote_identifier(column)} := CURRENT_TIMESTAMP;
-          RETURN NEW;
-        END;
-        SQL
-      end
-
-      private
-
-      # Add or replace a function that returns trigger to handle the action,
-      # and add a trigger that calls the function.
-      def pgt_trigger(table, trigger_name, function_name, events, definition, opts={})
-        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
+      class_eval(&PGT_DEFINE)
     end
   end
 end

data/spec/sequel_postgresql_triggers_spec.rb

@@ -7,17 +7,12 @@ require 'minitest/autorun'
 DB = Sequel.connect(ENV['PGT_SPEC_DB']||'postgres:///spgt_test?user=postgres')
 
 $:.unshift(File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'lib'))
-require 'sequel_postgresql_triggers'
-
-if defined?(RSpec)
-  require 'rspec/version'
-  if RSpec::Version::STRING >= '2.11.0'
-    RSpec.configure do |config|
-      config.expect_with :rspec do |c|
-        c.syntax = :should
-      end
-    end
-  end
+if ENV['PGT_GLOBAL'] == '1'
+  puts "Running specs with global modification"
+  require 'sequel_postgresql_triggers'
+else
+  puts "Running specs with extension"
+  DB.extension :pg_triggers 
 end
 
 describe "PostgreSQL Triggers" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_postgresql_triggers
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-12 00:00:00.000000000 Z
+date: 2016-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -31,7 +31,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
-- README
+- README.rdoc
+- lib/sequel/extensions/pg_triggers.rb
 - lib/sequel_postgresql_triggers.rb
 - spec/sequel_postgresql_triggers_spec.rb
 homepage: https://github.com/jeremyevans/sequel_postgresql_triggers
@@ -45,7 +46,7 @@ rdoc_options:
 - "--title"
 - 'Sequel PostgreSQL Triggers: Database enforced timestamps, immutable columns, and
   counter/sum caches'
-- README
+- README.rdoc
 - MIT-LICENSE
 - lib
 require_paths:
@@ -65,5 +66,6 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Database enforced timestamps, immutable columns, and counter/sum caches
+summary: Database enforced timestamps, immutable columns, counter/sum caches, and
+  touch propogation
 test_files: []

data/README

@@ -1,75 +0,0 @@
-= Sequel PostgreSQL Triggers
-
-Sequel PostgreSQL Triggers is a small enhancement to Sequel allowing
-a user to easily handle the following types of columns:
-
-* Timestamp Columns (Created At/Updated At)
-* Counter/Sum Caches
-* Immutable Columns
-
-It handles these internally to the database via triggers, so even if
-other applications access the database (without using Sequel), things
-will still work (unless the database superuser disables triggers).
-
-To use any of these methods before PostgreSQL 9.0, you have to add
-the plpgsql procedural language to PostgreSQL, which you can do with:
-
-  DB.create_language(:plpgsql)
-
-== Triggers
-
-=== Created At Columns - pgt_created_at
-
-pgt_created_at takes the table and column given and makes it so that
-upon insertion, the column is set to the CURRENT_TIMESTAMP, and that
-upon update, the column's value is always set to the previous value.
-This is sort of like an immutable column, but it doesn't bring up an
-error if you try to change it, it just ignores it.
-
-=== Updated At Columns - pgt_updated_at
-
-Similar to pgt_created_at, takes a table and column and makes it so
-that upon insertion, the column is set to CURRENT_TIMESTAMP. It
-differs that upon update, the column is also set to CURRENT_TIMESTAMP.
-
-=== Counter Cache - pgt_counter_cache
-
-This takes quite a few arguments (see the RDoc) and sets up a
-counter cache so that when the counted table is inserted to
-or deleted from, records in the main table are updated with the
-count of the corresponding records in the counted table.  The counter
-cache column must have a default of 0 for this to work correctly.
-
-=== Sum Cache - pgt_sum_cache
-
-Similar to pgt_counter_cache, except instead of storing a count
-of records in the main table, it stores the sum on one of the
-columns in summed table. The sum cache column must have a default
-of 0 for this to work correctly.
-
-=== Sum Through Many Cache - pgt_sum_through_many_cache
-
-Similar to pgt_sum_cache, except instead of a one-to-many relationship,
-it supports a many-to-many relationship with a single join table. The
-sum cache column must have a default of 0 for this to work correctly.
-
-=== Immutable Columns - pgt_immutable
-
-This takes a table name and one or more column names, and adds
-an update trigger that raises an exception if you try to modify
-the value of any of the columns.
-
-=== Touch Propagation - pgt_touch
-
-This takes several arguments (again, see the RDoc) and sets up a
-trigger that watches one table for changes, and touches timestamps
-of related rows in a separate table.
-
-== License
-
-This library is released under the MIT License.  See the MIT-LICENSE
-file for details.
-
-== Author
-
-Jeremy Evans <code@jeremyevans.net>