hairtrigger 0.2.9 → 0.2.10

data/README.md

@@ -22,6 +22,10 @@ class AccountUser < ActiveRecord::Base
   trigger.after(:insert) do
     "UPDATE accounts SET user_count = user_count + 1 WHERE id = NEW.account_id;"
   end
+
+  trigger.after(:update).of(:name) do
+    "INSERT INTO user_changes(id, name) VALUES(NEW.id, NEW.name);"
+  end
 end
 ```
 
@@ -39,7 +43,15 @@ CREATE TRIGGER account_users_after_insert_row_tr AFTER INSERT ON account_users
 FOR EACH ROW
 BEGIN
     UPDATE accounts SET user_count = user_count + 1 WHERE id = NEW.account_id;
-END
+END;
+
+CREATE TRIGGER account_users_after_update_on_name_row_tr AFTER UPDATE ON account_users
+FOR EACH ROW
+BEGIN
+    IF NEW.name <> OLD.name OR (NEW.name IS NULL) <> (OLD.name IS NULL) THEN
+        INSERT INTO user_changes(id, name) VALUES(NEW.id, NEW.name);
+    END IF;
+END;
 ```
 
 Note that these auto-generated `create_trigger` statements in the migration
@@ -74,6 +86,10 @@ Shorthand for `timing(:after).events(*events)`.
 #### where(conditions)
 Optional, SQL snippet limiting when the trigger will fire. Supports delayed interpolation of variables.
 
+#### of(*columns)
+
+Only fire the update trigger if at least one of the columns is specified in the statement. Platforms that support it use a native `OF` clause, others will have an inferred `IF ...` statement in the trigger body. Note the former will fire even if the column's value hasn't changed; the latter will not.
+
 #### security(user)
 Permissions/role to check when calling trigger. PostgreSQL supports `:invoker` (default) and `:definer`, MySQL supports `:definer` (default) and arbitrary users (syntax: `'user'@'host'`).
 
@@ -84,10 +100,24 @@ Required (but may be satisified by `before`/`after`). Possible values are `:befo
 Required (but may be satisified by `before`/`after`). Possible values are `:insert`/`:update`/`:delete`/`:truncate`. MySQL/SQLite only support one action per trigger, and don't support `:truncate`.
 
 #### nowrap(flag = true)
-PostgreSQL specific option to prevent the trigger action from being wrapped in a `CREATE FUNCTION`. This is useful for executing existing triggers/functions directly, but is not compatible with the `security` setting nor can it be used with pre-9.0 PostgreSQL when supplying a `where` condition.
+PostgreSQL-specific option to prevent the trigger action from being wrapped in a `CREATE FUNCTION`. This is useful for executing existing triggers/functions directly, but is not compatible with the `security` setting nor can it be used with pre-9.0 PostgreSQL when supplying a `where` condition.
 
 Example: `trigger.after(:update).nowrap { "tsvector_update_trigger(...)" }`
 
+#### declare
+PostgreSQL-specific option for declaring variables for use in the
+trigger function. Declarations should be separate by semicolons, e.g.
+
+```ruby
+trigger.after(:insert).declare("user_type text; status text") do
+  <<-SQL
+    IF (NEW.account_id = 1 OR NEW.email LIKE '%company.com') THEN
+      user_type := 'employee';
+    ELSIF ...
+  SQL
+end
+```
+
 #### all
 Noop, useful for trigger groups (see below).
 
@@ -103,10 +133,10 @@ trigger.after(:update) do |t|
   t.all do # every row
     # some sql
   end
-  t.where("OLD.foo != NEW.foo") do
+  t.of("foo") do
     # some more sql
   end
-  t.where("OLD.bar != NEW.bar") do
+  t.where("OLD.bar != NEW.bar AND NEW.bar != 'lol'") do
     # some other sql
   end
 end

data/lib/hair_trigger/builder.rb

@@ -77,6 +77,14 @@ module HairTrigger
       options[:nowrap] = flag
     end
 
+    def of(*columns)
+      options[:of] = columns
+    end
+
+    def declare(declarations)
+      options[:declarations] = declarations
+    end
+
     # noop, just a way you can pass a block within a trigger group
     def all
     end
@@ -150,7 +158,7 @@ module HairTrigger
         METHOD
       end
     end
-    chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all, :nowrap
+    chainable_methods :name, :on, :for_each, :before, :after, :where, :security, :timing, :events, :all, :nowrap, :of, :declare
 
     def create_grouped_trigger?
       adapter_name == :mysql
@@ -158,7 +166,7 @@ module HairTrigger
 
     def prepare!
       @triggers.each(&:prepare!) if @triggers
-      @prepared_where = options[:where] = interpolate(options[:where]) if options[:where]
+      prepare_where!
       if @actions
         @prepared_actions = @actions.is_a?(Hash) ?
           @actions.inject({}){ |hash, (key, value)| hash[key] = interpolate(value).rstrip; hash } :
@@ -167,6 +175,20 @@ module HairTrigger
       all_names # ensure (component) trigger names are all cached
     end
 
+    def prepare_where!
+      parts = []
+      parts << @explicit_where = options[:where] = interpolate(options[:where]) if options[:where]
+      parts << options[:of].map{ |col| change_clause(col) }.join(" OR ") if options[:of] && !supports_of?
+      if parts.present?
+        parts.map!{ |part| "(" + part + ")" } if parts.size > 1
+        @prepared_where = parts.join(" AND ")
+      end
+    end
+
+    def change_clause(column)
+      "NEW.#{column} <> OLD.#{column} OR (NEW.#{column} IS NULL) <> (OLD.#{column} IS NULL)"
+    end
+
     def validate!(direction = :down)
       @errors.each do |(error, *adapters)|
         raise GenerationError, error if adapters.include?(adapter_name)
@@ -259,7 +281,7 @@ module HairTrigger
     end
 
     def components
-      [self.options, self.prepared_actions, self.prepared_where, self.triggers, @compatibility]
+      [@options, @prepared_actions, @explicit_where, @triggers, @compatibility]
     end
 
     def errors
@@ -296,6 +318,7 @@ module HairTrigger
     end
 
     def maybe_execute(&block)
+      raise DeclarationError, "of may only be specified on update triggers" if options[:of] && options[:events] != ["UPDATE"]
       if block.arity > 0 # we're creating a trigger group, so set up some stuff and pass the buck
         @errors << ["trigger group must specify timing and event(s) for mysql", :mysql] unless options[:timing] && options[:events]
         @errors << ["nested trigger groups are not supported for mysql", :mysql] if @trigger_group
@@ -340,12 +363,34 @@ module HairTrigger
       [options[:table],
        options[:timing],
        options[:events],
+       of_clause(false),
        options[:for_each],
-       prepared_where ? 'when_' + prepared_where : nil
+       @explicit_where ? 'when_' + @explicit_where : nil
       ].flatten.compact.
       join("_").downcase.gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_')[0, 60] + "_tr"
     end
 
+    def of_clause(check_support = true)
+      "OF " + options[:of].join(", ") + " " if options[:of] && (!check_support || supports_of?)
+    end
+
+    def declarations
+      return unless declarations = options[:declarations]
+      declarations = declarations.strip.split(/;/).map(&:strip).join(";\n")
+      "\nDECLARE\n" + normalize(declarations.sub(/;?\n?\z/, ';'), 1).rstrip
+    end
+
+    def supports_of?
+      case adapter_name
+      when :sqlite
+        true
+      when :postgresql, :postgis
+        db_version >= 90000
+      else
+        false
+      end
+    end
+
     def generate_drop_trigger
       case adapter_name
         when :sqlite, :mysql
@@ -359,7 +404,7 @@ module HairTrigger
 
     def generate_trigger_sqlite
       <<-SQL
-CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].first} ON #{options[:table]}
+CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].first} #{of_clause}ON #{options[:table]}
 FOR EACH #{options[:for_each]}#{prepared_where ? " WHEN " + prepared_where : ''}
 BEGIN
 #{normalize(raw_actions, 1).rstrip}
@@ -370,8 +415,10 @@ END;
     def generate_trigger_postgresql
       raise GenerationError, "truncate triggers are only supported on postgres 8.4 and greater" if db_version < 80400 && options[:events].include?('TRUNCATE')
       raise GenerationError, "FOR EACH ROW triggers may not be triggered by truncate events" if options[:for_each] == 'ROW' && options[:events].include?('TRUNCATE')
+      raise GenerationError, "declare cannot be used in conjunction with nowrap" if options[:nowrap] && options[:declare]
       raise GenerationError, "security cannot be used in conjunction with nowrap" if options[:nowrap] && options[:security]
       raise GenerationError, "where can only be used in conjunction with nowrap on postgres 9.0 and greater" if options[:nowrap] && prepared_where && db_version < 90000
+      raise GenerationError, "of can only be used in conjunction with nowrap on postgres 9.1 and greater" if options[:nowrap] && options[:of] && db_version < 91000
 
       sql = ''
 
@@ -381,7 +428,7 @@ END;
         security = options[:security] if options[:security] && options[:security] != :invoker
         sql << <<-SQL
 CREATE FUNCTION #{prepared_name}()
-RETURNS TRIGGER AS $$
+RETURNS TRIGGER AS $$#{declarations}
 BEGIN
         SQL
         if prepared_where && db_version < 90000
@@ -410,7 +457,7 @@ $$ LANGUAGE plpgsql#{security ? " SECURITY #{security.to_s.upcase}" : ""};
       end
 
       [sql, <<-SQL]
-CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].join(" OR ")} ON #{options[:table]}
+CREATE TRIGGER #{prepared_name} #{options[:timing]} #{options[:events].join(" OR ")} #{of_clause}ON #{options[:table]}
 FOR EACH #{options[:for_each]}#{prepared_where && db_version >= 90000 ? " WHEN (" + prepared_where + ')': ''} EXECUTE PROCEDURE #{trigger_action};
       SQL
     end

data/lib/hair_trigger/version.rb

@@ -1,5 +1,5 @@
 module HairTrigger
-  VERSION = "0.2.9"
+  VERSION = "0.2.10"
 
   def VERSION.<=>(other)
     split(/\./).map(&:to_i) <=> other.split(/\./).map(&:to_i)

data/spec/builder_spec.rb

@@ -60,6 +60,14 @@ describe "builder" do
     end
   end
 
+  describe "`of' columns" do
+    it "should be disallowed for non-update triggers" do
+      lambda {
+        builder.on(:foos).after(:insert).of(:bar, :baz){ "BAR" }
+      }.should raise_error /of may only be specified on update triggers/
+    end
+  end
+
   describe "groups" do
     it "should allow chained methods" do
       triggers = builder.on(:foos){ |t|
@@ -143,6 +151,16 @@ describe "builder" do
         grep(/DEFINER = 'user'@'host'/).size.should eql(1)
     end
 
+    it "should infer `if' conditionals from `of' columns" do
+      builder.on(:foos).after(:update).of(:bar){ "BAZ" }.generate.join("\n").
+        should include("IF NEW.bar <> OLD.bar OR (NEW.bar IS NULL) <> (OLD.bar IS NULL) THEN")
+    end
+
+    it "should merge `where` and `of` into an `if` conditional" do
+      builder.on(:foos).after(:update).of(:bar).where("lol"){ "BAZ" }.generate.join("\n").
+        should include("IF (lol) AND (NEW.bar <> OLD.bar OR (NEW.bar IS NULL) <> (OLD.bar IS NULL)) THEN")
+    end
+
     it "should reject :invoker security" do
       lambda {
         builder.on(:foos).after(:update).security(:invoker){ "FOO" }.generate
@@ -170,7 +188,7 @@ describe "builder" do
 
   context "postgresql" do
     before(:each) do
-      @adapter = MockAdapter.new("postgresql", :postgresql_version => 90000)
+      @adapter = MockAdapter.new("postgresql", :postgresql_version => 94000)
     end
 
     it "should create multiple triggers for a group" do
@@ -201,6 +219,11 @@ describe "builder" do
       trigger.warnings.first.first.should =~ /trigger group has an explicit name/
     end
 
+    it "should accept `of' columns" do
+      trigger = builder.on(:foos).after(:update).of(:bar, :baz){ "BAR" }
+      trigger.generate.grep(/AFTER UPDATE OF bar, baz/).size.should eql(1)
+    end
+
     it "should accept security" do
       builder.on(:foos).after(:update).security(:invoker){ "FOO" }.generate.
         grep(/SECURITY/).size.should eql(0) # default, so we don't include it
@@ -253,6 +276,11 @@ describe "builder" do
       }.should raise_error
     end
 
+    it "should allow variable declarations" do
+      builder.on(:foos).after(:insert).declare("foo INT"){ "FOO" }.generate.join("\n").
+        should match(/DECLARE\s*foo INT;\s*BEGIN\s*FOO/)
+    end
+
     context "legacy" do
       it "should reject truncate pre-8.4" do
         @adapter = MockAdapter.new("postgresql", :postgresql_version => 80300)
@@ -273,6 +301,12 @@ describe "builder" do
           builder.on(:foos).after(:insert).where("BAR").nowrap{ "FOO" }.generate
         }.should raise_error
       end
+
+      it "should infer `if' conditionals from `of' columns on pre-9.0" do
+        @adapter = MockAdapter.new("postgresql", :postgresql_version => 80400)
+        builder.on(:foos).after(:update).of(:bar){ "BAZ" }.generate.join("\n").
+          should include("IF NEW.bar <> OLD.bar OR (NEW.bar IS NULL) <> (OLD.bar IS NULL) THEN")
+      end
     end
   end
 
@@ -309,6 +343,11 @@ describe "builder" do
       trigger.warnings.first.first.should =~ /trigger group has an explicit name/
     end
 
+    it "should accept `of' columns" do
+      trigger = builder.on(:foos).after(:update).of(:bar, :baz){ "BAR" }
+      trigger.generate.grep(/AFTER UPDATE OF bar, baz/).size.should eql(1)
+    end
+
     it "should reject security" do
       lambda {
         builder.on(:foos).after(:update).security(:definer){ "FOO" }.generate

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hairtrigger
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.10
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-21 00:00:00.000000000 Z
+date: 2014-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord