sequel 4.18.0 → 4.19.0

data/lib/sequel/plugins/pg_array_associations.rb

@@ -94,7 +94,7 @@ module Sequel
         # many_to_pg_array associations can have associated objects as long as they have
         # a primary key.
         def can_have_associated_objects?(obj)
-          obj.send(self[:primary_key])
+          obj.get_column_value(self[:primary_key])
         end
 
         # Assume that the key in the associated table uses a version of the current
@@ -195,7 +195,7 @@ module Sequel
         # pg_array_to_many associations can only have associated objects if
         # the array field is not nil or empty.
         def can_have_associated_objects?(obj)
-          v = obj.send(self[:key])
+          v = obj.get_column_value(self[:key])
           v && !v.empty?
         end
 
@@ -307,13 +307,13 @@ module Sequel
           key_column = opts[:key_column] ||= opts[:key]
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
           opts[:dataset] ||= lambda do
-            opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains(Sequel.pg_array([send(pk)], opts.array_type)))
+            opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains(Sequel.pg_array([get_column_value(pk)], opts.array_type)))
           end
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
 
             eager_load_results(opts, eo.merge(:loader=>false)) do |assoc_record|
-              if pks ||= assoc_record.send(key)
+              if pks ||= assoc_record.get_column_value(key)
                 pks.each do |pkv|
                   next unless objects = id_map[pkv]
                   objects.each do |object| 
@@ -358,23 +358,23 @@ module Sequel
           save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
 
           opts[:adder] ||= proc do |o|
-            if array = o.send(key)
-              array << send(pk)
+            if array = o.get_column_value(key)
+              array << get_column_value(pk)
             else
-              o.send("#{key}=", Sequel.pg_array([send(pk)], opts.array_type))
+              o.set_column_value("#{key}=", Sequel.pg_array([get_column_value(pk)], opts.array_type))
             end
             o.save(save_opts)
           end
   
           opts[:remover] ||= proc do |o|
-            if (array = o.send(key)) && !array.empty?
-              array.delete(send(pk))
+            if (array = o.get_column_value(key)) && !array.empty?
+              array.delete(get_column_value(pk))
               o.save(save_opts)
             end
           end
 
           opts[:clearer] ||= proc do
-            opts.associated_dataset.where(Sequel.pg_array_op(key).contains([send(pk)])).update(key=>Sequel.function(:array_remove, key, send(pk)))
+            opts.associated_dataset.where(Sequel.pg_array_op(key).contains([get_column_value(pk)])).update(key=>Sequel.function(:array_remove, key, get_column_value(pk)))
           end
         end
 
@@ -387,7 +387,7 @@ module Sequel
           opts[:eager_loader_key] = nil
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
           opts[:dataset] ||= lambda do
-            opts.associated_dataset.where(opts.predicate_key=>send(key).to_a)
+            opts.associated_dataset.where(opts.predicate_key=>get_column_value(key).to_a)
           end
           opts[:eager_loader] ||= proc do |eo|
             rows = eo[:rows]
@@ -395,7 +395,7 @@ module Sequel
             pkm = opts.primary_key_method
 
             rows.each do |object|
-              if associated_pks = object.send(key)
+              if associated_pks = object.get_column_value(key)
                 associated_pks.each do |apk|
                   (id_map[apk] ||= []) << object
                 end
@@ -403,7 +403,7 @@ module Sequel
             end
 
             eager_load_results(opts, eo.merge(:id_map=>id_map)) do |assoc_record|
-              if objects = id_map[assoc_record.send(pkm)]
+              if objects = id_map[assoc_record.get_column_value(pkm)]
                 objects.each do |object| 
                   object.associations[name].push(assoc_record)
                 end
@@ -451,26 +451,26 @@ module Sequel
           end
 
           opts[:adder] ||= proc do |o|
-            opk = o.send(opts.primary_key) 
-            if array = send(key)
+            opk = o.get_column_value(opts.primary_key) 
+            if array = get_column_value(key)
               modified!(key)
               array << opk
             else
-              send("#{key}=", Sequel.pg_array([opk], opts.array_type))
+              set_column_value("#{key}=", Sequel.pg_array([opk], opts.array_type))
             end
             save_after_modify.call(self) if save_after_modify
           end
   
           opts[:remover] ||= proc do |o|
-            if (array = send(key)) && !array.empty?
+            if (array = get_column_value(key)) && !array.empty?
               modified!(key)
-              array.delete(o.send(opts.primary_key))
+              array.delete(o.get_column_value(opts.primary_key))
               save_after_modify.call(self) if save_after_modify
             end
           end
 
           opts[:clearer] ||= proc do
-            if (array = send(key)) && !array.empty?
+            if (array = get_column_value(key)) && !array.empty?
               modified!(key)
               array.clear
               save_after_modify.call(self) if save_after_modify
@@ -488,11 +488,11 @@ module Sequel
           key = ref[:key]
           expr = case obj
           when Sequel::Model
-            if (assoc_pks = obj.send(key)) && !assoc_pks.empty?
+            if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
               Sequel.expr(pk=>assoc_pks.to_a)
             end
           when Array
-            if (assoc_pks = obj.map{|o| o.send(key)}.flatten.compact.uniq) && !assoc_pks.empty?
+            if (assoc_pks = obj.map{|o| o.get_column_value(key)}.flatten.compact.uniq) && !assoc_pks.empty?
               Sequel.expr(pk=>assoc_pks)
             end
           when Sequel::Dataset
@@ -508,11 +508,11 @@ module Sequel
           key = ref.qualify(model.table_name, ref[:key_column])
           expr = case obj
           when Sequel::Model
-            if pkv = obj.send(ref.primary_key_method)
+            if pkv = obj.get_column_value(ref.primary_key_method)
               Sequel.pg_array_op(key).contains(Sequel.pg_array([pkv], ref.array_type))
             end
           when Array
-            if (pkvs = obj.map{|o| o.send(ref.primary_key_method)}.compact) && !pkvs.empty?
+            if (pkvs = obj.map{|o| o.get_column_value(ref.primary_key_method)}.compact) && !pkvs.empty?
               Sequel.pg_array(key).overlaps(Sequel.pg_array(pkvs, ref.array_type))
             end
           when Sequel::Dataset

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -28,7 +28,7 @@ module Sequel
         # Return a bound variable hash that maps the keys in +ks+ (qualified by the +table+)
         # to the values of the results of sending the methods in +vs+.
         def association_bound_variable_hash(table, ks, vs)
-          Hash[*ks.zip(vs).map{|k, v| [:"#{table}.#{k}", send(v)]}.flatten]
+          Hash[*ks.zip(vs).map{|k, v| [:"#{table}.#{k}", get_column_value(v)]}.flatten]
         end
 
         # Given an association reflection, return a bound variable hash for the given

data/lib/sequel/plugins/rcte_tree.rb

@@ -148,7 +148,7 @@ module Sequel
         a[:read_only] = true unless a.has_key?(:read_only)
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
-          base_ds = model.filter(prkey_array.zip(key_array.map{|k| send(k)}))
+          base_ds = model.filter(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, key_array.zip(prkey_array))
           if c = a[:conditions]
             (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
@@ -243,7 +243,7 @@ module Sequel
         d[:read_only] = true unless d.has_key?(:read_only)
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
-          base_ds = model.filter(key_array.zip(prkey_array.map{|k| send(k)}))
+          base_ds = model.filter(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, prkey_array.zip(key_array))
           if c = d[:conditions]
             (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|

data/lib/sequel/plugins/serialization.rb

@@ -163,7 +163,7 @@ module Sequel
                 end
               end
               define_method("#{column}=") do |v| 
-                if !changed_columns.include?(column) && (new? || send(column) != v)
+                if !changed_columns.include?(column) && (new? || get_column_value(column) != v)
                   changed_columns << column
                 end
 

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -220,7 +220,7 @@ module Sequel
         # Set the sti_key column based on the sti_key_map.
         def _before_validation
           if new? && !self[model.sti_key]
-            send("#{model.sti_key}=", model.sti_key_chooser.call(self))
+            set_column_value("#{model.sti_key}=", model.sti_key_chooser.call(self))
           end
           super
         end

data/lib/sequel/plugins/timestamps.rb

@@ -79,7 +79,7 @@ module Sequel
         def set_create_timestamp(time=nil)
           field = model.create_timestamp_field
           meth = :"#{field}="
-          self.send(meth, time||=model.dataset.current_datetime) if respond_to?(field) && respond_to?(meth) && (model.create_timestamp_overwrite? || send(field).nil?)
+          set_column_value(meth, time||=model.dataset.current_datetime) if respond_to?(field) && respond_to?(meth) && (model.create_timestamp_overwrite? || get_column_value(field).nil?)
           set_update_timestamp(time) if model.set_update_timestamp_on_create?
         end
         
@@ -87,7 +87,7 @@ module Sequel
         # object has a setter method for the update timestamp field.
         def set_update_timestamp(time=nil)
           meth = :"#{model.update_timestamp_field}="
-          self.send(meth, time||model.dataset.current_datetime) if respond_to?(meth)
+          set_column_value(meth, time||model.dataset.current_datetime) if respond_to?(meth)
         end
       end
     end

data/lib/sequel/plugins/typecast_on_load.rb

@@ -51,7 +51,7 @@ module Sequel
         def load_typecast
           model.typecast_on_load_columns.each do |c|
             if v = values[c]
-              send("#{c}=", v)
+              set_column_value("#{c}=", v)
             end
           end
           changed_columns.clear

data/lib/sequel/plugins/validation_class_methods.rb

@@ -103,9 +103,9 @@ module Sequel
           validations.each do |att, procs|
             v = case att
             when Array
-              att.collect{|a| o.send(a)}
+              att.collect{|a| o.get_column_value(a)}
             else
-              o.send(att)
+              o.get_column_value(att)
             end
             procs.each {|tag, p| p.call(o, att, v)}
           end
@@ -150,7 +150,7 @@ module Sequel
           reflect_validation(:confirmation, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) unless v == o.send(:"#{a}_confirmation")
+            o.errors.add(a, opts[:message]) unless v == o.get_column_value(:"#{a}_confirmation")
           end
         end
     
@@ -418,7 +418,7 @@ module Sequel
         def validation_if_proc(o, i)
           case i
           when Symbol
-            o.send(i)
+            o.get_column_value(i)
           when Proc
             o.instance_eval(&i)
           else

data/lib/sequel/plugins/validation_helpers.rb

@@ -236,7 +236,7 @@ module Sequel
             ds = if where
               where.call(ds, self, arr)
             else
-              vals = arr.map{|x| send(x)}
+              vals = arr.map{|x| get_column_value(x)}
               next if vals.any?{|v| v.nil?}
               ds.where(arr.zip(vals))
             end
@@ -267,7 +267,7 @@ module Sequel
           am, an, ab, m = opts.values_at(:allow_missing, :allow_nil, :allow_blank, :message)
           Array(atts).each do |a|
             next if am && !values.has_key?(a)
-            v = send(a)
+            v = get_column_value(a)
             next if an && v.nil?
             next if ab && v.respond_to?(:blank?) && v.blank?
             if message = yield(a, v, m)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 18
+  MINOR = 19
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/core/dataset_spec.rb

@@ -2619,6 +2619,13 @@ describe "Dataset compound operations" do
       "SELECT * FROM (SELECT * FROM (SELECT * FROM test ORDER BY a LIMIT 2) AS t1 UNION SELECT * FROM (SELECT * FROM test ORDER BY b LIMIT 3) AS t1) AS t1 ORDER BY c LIMIT 4"
   end
 
+  specify "should handle raw SQL datasets properly when using UNION, INTERSECT, or EXCEPT" do
+    @dataset = Sequel.mock['SELECT 1']
+    @dataset.union(@dataset).sql.should == "SELECT * FROM (SELECT * FROM (SELECT 1) AS t1 UNION SELECT * FROM (SELECT 1) AS t1) AS t1"
+    @dataset.intersect(@dataset).sql.should == "SELECT * FROM (SELECT * FROM (SELECT 1) AS t1 INTERSECT SELECT * FROM (SELECT 1) AS t1) AS t1"
+    @dataset.except(@dataset).sql.should == "SELECT * FROM (SELECT * FROM (SELECT 1) AS t1 EXCEPT SELECT * FROM (SELECT 1) AS t1) AS t1"
+  end
+
   specify "should hoist WITH clauses in given dataset if dataset doesn't support WITH in subselect" do
     ds = Sequel.mock.dataset
     meta_def(ds, :supports_cte?){true}

data/spec/extensions/accessed_columns_spec.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "accessed_columns plugin" do
+  before do
+    @db = Sequel.mock(:fetch=>{:name=>'a', :b=>'c'}, :numrows=>1)
+    @c = Class.new(Sequel::Model(@db[:test]))
+    @c.columns :name, :b
+    @c.plugin :accessed_columns
+    @o = @c.new
+  end
+
+  it "should record columns accessed" do
+    @o.accessed_columns.should == []
+    @o.name
+    @o.accessed_columns.should == [:name]
+    @o.name
+    @o.accessed_columns.should == [:name]
+    @o.b
+    @o.accessed_columns.sort_by{|s| s.to_s}.should == [:b, :name]
+  end
+
+  it "should clear accessed columns when refreshing" do
+    @o.name
+    @o.refresh
+    @o.accessed_columns.should == []
+  end
+
+  it "should clear accessed columns when saving" do
+    @o.name
+    @o.save
+    @o.accessed_columns.should == []
+  end
+
+  it "should work when duping and cloning instances" do
+    @o.name
+    o = @o.dup
+    @o.accessed_columns.should == [:name]
+    @o.b
+    @o.accessed_columns.sort_by{|s| s.to_s}.should == [:b, :name]
+    o.accessed_columns.should == [:name]
+    o2 = o.clone
+    o2.refresh
+    o.accessed_columns.should == [:name]
+    o2.accessed_columns.should == []
+  end
+
+  it "should not raise exceptions when object is frozen" do
+    @o.freeze
+    proc{@o.name}.should_not raise_error
+  end
+end

data/spec/extensions/column_conflicts_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "column_conflicts plugin" do
+  before do
+    @db = Sequel.mock
+    @c = Class.new(Sequel::Model(@db[:test]))
+    @c.columns :model, :use_transactions, :foo
+    @c.plugin :column_conflicts
+    @o = @c.load(:model=>1, :use_transactions=>2, :foo=>4)
+  end
+
+  it "should have mass assignment work correctly" do
+    @o.set_fields({:use_transactions=>3}, [:use_transactions])
+    @o.get_column_value(:use_transactions).should == 3
+  end
+
+  it "should handle both symbols and strings" do
+    @o.get_column_value(:model).should == 1
+    @o.get_column_value("model").should == 1
+    @o.set_column_value(:use_transactions=, 3)
+    @o.get_column_value(:use_transactions).should == 3
+    @o.set_column_value(:use_transactions=, 4)
+    @o.get_column_value(:use_transactions).should == 4
+  end
+
+  it "should allow manual setting of conflicted columns" do
+    @c.send(:define_method, :foo){raise}
+    @c.get_column_conflict!(:foo)
+    @o.get_column_value(:foo).should == 4
+
+    @c.send(:define_method, :model=){raise}
+    @c.set_column_conflict!(:model)
+    @o.set_column_value(:model=, 2).should == 2
+    @o.get_column_value(:model).should == 2
+  end
+
+  it "should work correctly in subclasses" do
+    @o = Class.new(@c).load(:model=>1, :use_transactions=>2)
+    @o.get_column_value(:model).should == 1
+    @o.get_column_value("model").should == 1
+    @o.set_column_value(:use_transactions=, 3)
+    @o.get_column_value(:use_transactions).should == 3
+    @o.set_column_value(:use_transactions=, 4)
+    @o.get_column_value(:use_transactions).should == 4
+  end
+
+  it "should work correctly for dataset changes" do
+    ds = @db[:test]
+    def ds.columns; [:object_id] end
+    @c.dataset = ds
+    o = @c.load(:object_id=>3)
+    o.get_column_value(:object_id).should == 3
+    o.object_id.should_not == 3
+  end
+end

data/spec/extensions/hook_class_methods_spec.rb

@@ -184,7 +184,13 @@ describe "Model#before_create && Model#after_create" do
 
   specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
     @c.before_create{false}
-    proc{@c.create(:x => 2)}.should raise_error(Sequel::BeforeHookFailed)
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
+    DB.sqls.should == []
+  end
+
+  specify ".create should cancel the save and raise an error if before_create calls cancel_action and raise_on_save_failure is true" do
+    @c.before_create{cancel_action}
+    proc{@c.create(:x => 2)}.should raise_error(Sequel::HookFailed)
     DB.sqls.should == []
   end
 
@@ -194,6 +200,13 @@ describe "Model#before_create && Model#after_create" do
     @c.create(:x => 2).should == nil
     DB.sqls.should == []
   end
+
+  specify ".create should cancel the save and return nil if before_create calls cancel_action and raise_on_save_failure is false" do
+    @c.before_create{cancel_action}
+    @c.raise_on_save_failure = false
+    @c.create(:x => 2).should == nil
+    DB.sqls.should == []
+  end
 end
 
 describe "Model#before_update && Model#after_update" do
@@ -214,7 +227,7 @@ describe "Model#before_update && Model#after_update" do
 
   specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
     @c.before_update{false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
     DB.sqls.should == []
   end
 
@@ -252,7 +265,7 @@ describe "Model#before_save && Model#after_save" do
 
   specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
     @c.before_save{false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
     DB.sqls.should == []
   end
 
@@ -282,7 +295,7 @@ describe "Model#before_destroy && Model#after_destroy" do
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
     @c.before_destroy{false}
-    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::BeforeHookFailed)
+    proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::HookFailed)
     DB.sqls.should == []
   end
 
@@ -336,7 +349,7 @@ describe "Model#before_validation && Model#after_validation" do
 
   specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
     @c.before_validation{false}
-    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
+    proc{@c.load(:id => 2233).save}.should raise_error(Sequel::HookFailed)
     DB.sqls.should == []
   end