sequel_postgresql_triggers 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b5d81f0071528eb70130d8ebe3093a365c0d024e250583d8ea7e35d5b7af263
-  data.tar.gz: 18bb2a79d2642636f34fce1f0f4be315e90592c3be8c8a8d5f587d753061d360
+  metadata.gz: 2a985c677d8d3b87630378feee9b80dda40ef2ba95147ec525f2df8feff18b38
+  data.tar.gz: 8c6b9526bbedb13a72fd3edc44c2da56041fc985c0e41187613914bae9163230
 SHA512:
-  metadata.gz: 615949150a244df98c696da8472ebeb40ae5c09812457f5ecca61197a10754e489c431a68d2a44df91eb5f17e229e6e39b4d3b4f4cf6ca28be520b2145345e3c
-  data.tar.gz: ca67361ebd569731121ad3f482e47d0320d0658144fd4d7bd21734fcf3542ae84d3fb592483813980fbb4f7e8b52866575c4f0c7efb8566d34760d884f66207c
+  metadata.gz: 39bd5f9c742aeed9331e59b521d571e5631c1b3dcd0804dd959e010a2a6c2bcd110ad8752eac92b1f9d0a768d0a9925f67cf59cdc5a34b718bc4e15e07ba996e
+  data.tar.gz: e5304e315766b8059adc6d29e48b6eb60af4ead1662a70d0eb5d7a87daa541a3b5068385a0b3a302bddaf23fd35f88637c6c3cf762b8308d5f2b5c27f9db682e

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
@@ -126,7 +126,7 @@ sum cache that sums the length of a string column.
 
 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
+main_table_id_column :: column in main table matching summed_table_id_column in summed_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
@@ -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,74 @@ 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+.
+
+== Caveats
+
+If you have defined counter or sum cache triggers using this library
+before version 1.6.0, you should drop them and regenerate them if
+you want the triggers to work correctly with queries that use
+<tt>INSERT ... ON CONFLICT DO NOTHING</tt>.
+
+When restoring a data-only migration with +pg_dump+, you may need to
+use <tt>--disable-triggers</tt> for it to restore correctly, and you
+will need to manually enforce data integrity if you are doing
+partial restores and not full restores.
+
 == License
 
 This library is released under the MIT License.  See the MIT-LICENSE

data/lib/sequel/extensions/pg_triggers.rb

@@ -6,15 +6,15 @@ 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)
         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)
+        pgt_trigger(counted_table, trigger_name, function_name, [:insert, :update, :delete], <<-SQL, :after=>true)
         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;
@@ -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)
@@ -79,7 +122,7 @@ module Sequel
         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)
+        pgt_trigger(summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL, :after=>true)
         BEGIN
           IF (TG_OP = 'UPDATE' AND NEW.#{id_column} = OLD.#{id_column}) THEN
             UPDATE #{table} SET #{sum_column} = #{sum_column} + #{new_table_summed_column} - #{old_table_summed_column} WHERE #{main_column} = NEW.#{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
@@ -133,7 +176,7 @@ module Sequel
         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)
+        pgt_trigger(orig_summed_table, trigger_name, function_name, [:insert, :delete, :update], <<-SQL, :after=>true)
         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_table_summed_column} - #{old_table_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});
@@ -152,7 +195,7 @@ module Sequel
         END;
         SQL
 
-        pgt_trigger(orig_join_table, join_trigger_name, join_function_name, [:insert, :delete, :update], <<-SQL)
+        pgt_trigger(orig_join_table, join_trigger_name, join_function_name, [:insert, :delete, :update], <<-SQL, :after=>true)
         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
@@ -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