sequel 4.18.0 → 4.19.0

data/lib/sequel/model/base.rb

@@ -1143,6 +1143,20 @@ module Sequel
       attr_reader :values
       alias to_hash values
 
+      # Get the value of the column.  Takes a single symbol or string argument.
+      # By default it calls send with the argument to get the value.  This can
+      # be overridden if you have columns that conflict with existing
+      # method names.
+      alias get_column_value send
+
+      # Set the value of the column.  Takes two argument.  The first is a
+      # symbol or string argument for the column name, suffixed with =.  The
+      # second is the value to set for the column.  By default it calls send
+      # with the argument to set the value.  This can be overridden if you have
+      # columns that conflict with existing method names (unlikely for setter
+      # methods, but possible).
+      alias set_column_value send
+
       # Creates new instance and passes the given values to set.
       # If a block is given, yield the instance to the block.
       #
@@ -1219,6 +1233,14 @@ module Sequel
       def autoincrementing_primary_key
         primary_key
       end
+
+      # Cancel the current action.  Should be called in before hooks to halt
+      # the processing of the action.  If a +msg+ argument is given and
+      # the model instance is configured to raise exceptions on failure,
+      # sets the message to use for the raised HookFailed exception.
+      def cancel_action(msg=nil)
+        raise_hook_failure(msg)
+      end
   
       # The columns that have been updated.  This isn't completely accurate,
       # as it could contain columns whose values have not changed.
@@ -1597,23 +1619,23 @@ module Sequel
         when :skip
           fields.each do |f|
             if hash.has_key?(f) 
-              send("#{f}=", hash[f])
+              set_column_value("#{f}=", hash[f])
             elsif f.is_a?(Symbol) && hash.has_key?(sf = f.to_s)
-              send("#{sf}=", hash[sf])
+              set_column_value("#{sf}=", hash[sf])
             end
           end
         when :raise
           fields.each do |f|
             if hash.has_key?(f)
-              send("#{f}=", hash[f])
+              set_column_value("#{f}=", hash[f])
             elsif f.is_a?(Symbol) && hash.has_key?(sf = f.to_s)
-              send("#{sf}=", hash[sf])
+              set_column_value("#{sf}=", hash[sf])
             else
               raise(Sequel::Error, "missing field in hash: #{f.inspect} not in #{hash.inspect}")
             end
           end
         else
-          fields.each{|f| send("#{f}=", hash[f])}
+          fields.each{|f| set_column_value("#{f}=", hash[f])}
         end
         self
       end
@@ -2073,8 +2095,17 @@ module Sequel
 
       # Raise an error appropriate to the hook type. May be swallowed by
       # checked_save_failure depending on the raise_on_failure? setting.
-      def raise_hook_failure(type)
-        raise HookFailed.new("the #{type} hook failed", self)
+      def raise_hook_failure(type=nil)
+        msg = case type
+        when String
+          type
+        when Symbol
+          "the #{type} hook failed"
+        else
+          "a hook failed"
+        end
+
+        raise HookFailed.new(msg, self)
       end
   
       # Get the ruby class or classes related to the given column's type.
@@ -2093,7 +2124,7 @@ module Sequel
         hash.each do |k,v|
           m = "#{k}="
           if meths.include?(m)
-            send(m, v)
+            set_column_value(m, v)
           elsif strict
             # Avoid using respond_to? or creating symbols from user input
             if public_methods.map{|s| s.to_s}.include?(m)

data/lib/sequel/plugins/accessed_columns.rb

@@ -0,0 +1,61 @@
+module Sequel
+  module Plugins
+    # The accessed_columns plugin records which columns have been
+    # accessed for a model instance.  This is useful if you are
+    # looking to remove other columns from being SELECTed by the
+    # dataset that retrieved the instance, which can significantly
+    # improve performance:
+    #
+    #   a = Album[1]
+    #   a.accessed_columns # []
+    #   a.name
+    #   a.accessed_columns # [:name]
+    #   a.artist_id
+    #   a.accessed_columns # [:name, :artist_id]
+    #
+    # Note that this plugin should probably not be used in production,
+    # as it causes a performance hit.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances record accessed columns (called before loading subclasses)
+    #   Sequel::Model.plugin :accessed_columns
+    #
+    #   # Make the Album instances record accessed columns
+    #   Album.plugin :accessed_columns
+    module AccessedColumns
+      module InstanceMethods
+        # Record the column access before retrieving the value.
+        def [](c)
+          (@accessed_columns ||= {})[c] = true unless frozen?
+          super
+        end
+
+        # Clear the accessed columns when saving.
+        def after_save
+          super
+          @accessed_columns = nil
+        end
+
+        # The columns that have been accessed.
+        def accessed_columns
+          @accessed_columns ? @accessed_columns.keys : []
+        end
+
+        # Copy the accessed columns when duping and cloning.
+        def initialize_copy(other)
+          other.instance_variable_set(:@accessed_columns, @accessed_columns.dup) if @accessed_columns
+          super
+        end
+
+        private
+
+        # Clear the accessed columns when refreshing.
+        def _refresh(_)
+          @accessed_columns = nil
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/association_pks.rb

@@ -61,12 +61,12 @@ module Sequel
           if clpk
             def_association_pks_getter(opts) do
               h = {}
-              lk.zip(lpk).each{|k, pk| h[k] = send(pk)}
+              lk.zip(lpk).each{|k, pk| h[k] = get_column_value(pk)}
               _join_table_dataset(opts).filter(h).select_map(rk)
             end
           else
             def_association_pks_getter(opts) do
-              _join_table_dataset(opts).filter(lk=>send(lpk)).select_map(rk)
+              _join_table_dataset(opts).filter(lk=>get_column_value(lpk)).select_map(rk)
             end
           end
 
@@ -74,10 +74,10 @@ module Sequel
             pks = send(crk ? :convert_cpk_array : :convert_pk_array, opts, pks)
             checked_transaction do
               if clpk
-                lpkv = lpk.map{|k| send(k)}
+                lpkv = lpk.map{|k| get_column_value(k)}
                 cond = lk.zip(lpkv)
               else
-                lpkv = send(lpk)
+                lpkv = get_column_value(lpk)
                 cond = {lk=>lpkv}
               end
               ds = _join_table_dataset(opts).filter(cond)

data/lib/sequel/plugins/boolean_readers.rb

@@ -40,7 +40,7 @@ module Sequel
         # Add a attribute? method for the column to a module included in the class.
         def create_boolean_reader(column)
           overridable_methods_module.module_eval do
-            define_method("#{column}?"){model.db.typecast_value(:boolean, send(column))}
+            define_method("#{column}?"){model.db.typecast_value(:boolean, get_column_value(column))}
           end
         end
 

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -255,7 +255,7 @@ module Sequel
         # Set the cti_key column to the name of the model.
         def _before_validation
           if new? && model.cti_key && !model.cti_model_map
-            send("#{model.cti_key}=", model.name.to_s)
+            set_column_value("#{model.cti_key}=", model.name.to_s)
           end
           super
         end

data/lib/sequel/plugins/column_conflicts.rb

@@ -0,0 +1,93 @@
+module Sequel
+  module Plugins
+    # The column_conflicts plugin overrides Model#get_column_value and #set_column_value
+    # to automatically handle column names that conflict with Ruby/Sequel method names.
+    #
+    # By default, Model#get_column_value and #set_column_value just call send, this
+    # plugin overrides the methods and gets/sets the value directly in the values
+    # hash if the column name conflicts with an existing Sequel::Model instance
+    # method name.
+    #
+    # Checking for column conflicts causes a performance hit, which is why Sequel
+    # does not enable such checks by default.
+    #
+    # When using this plugin, you can manually update the columns used.  This may be useful if
+    # the columns conflict with one of your custom methods, instead of a method defined in
+    # Sequel::Model:
+    #
+    #   Album.plugin :column_conflicts
+    #   Album.get_column_conflict!(:column)
+    #   Album.set_column_conflict!(:other_column)
+    #
+    # Usage:
+    #
+    #   # Make all model's handle column conflicts automatically (called before loading subclasses)
+    #   Sequel::Model.plugin :column_conflicts
+    #
+    #   # Make the Album class handle column conflicts automatically
+    #   Album.plugin :column_conflicts
+    module ColumnConflicts
+      # Check for column conflicts on the current model if the model has a dataset.
+      def self.configure(model)
+        model.instance_eval do
+          @get_column_conflicts = {}
+          @set_column_conflicts = {}
+          check_column_conflicts if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :check_column_conflicts)
+        Plugins.inherited_instance_variables(self, :@get_column_conflicts=>:dup, :@set_column_conflicts=>:dup)
+
+        # Hash for columns where the getter method already exists. keys are column symbols/strings that
+        # conflict with method names and should be looked up directly instead of calling a method,
+        # values are the column symbol to lookup in the values hash.
+        attr_reader :get_column_conflicts
+
+        # Hash for columns where the setter method already exists. keys are column symbols/strings suffixed
+        # with = that conflict with method names and should be set directly in the values hash,
+        # values are the column symbol to set in the values hash.
+        attr_reader :set_column_conflicts
+
+        # Compare the column names for the model with the methods defined on Sequel::Model, and automatically
+        # setup the column conflicts.
+        def check_column_conflicts
+          mod = Sequel::Model
+          columns.find_all{|c| mod.method_defined?(c)}.each{|c| get_column_conflict!(c)}
+          columns.find_all{|c| mod.method_defined?("#{c}=")}.each{|c| set_column_conflict!(c)}
+        end
+
+        # Set the given column as one with a getter method conflict.
+        def get_column_conflict!(column)
+          @get_column_conflicts[column.to_sym] = @get_column_conflicts[column.to_s] = column.to_sym
+        end
+
+        # Set the given column as one with a setter method conflict.
+        def set_column_conflict!(column)
+          @set_column_conflicts[:"#{column}="] = @set_column_conflicts["#{column}="] = column.to_sym
+        end
+      end
+
+      module InstanceMethods
+        # If the given column has a getter method conflict, lookup the value directly in the values hash.
+        def get_column_value(c)
+          if col = model.get_column_conflicts[c]
+            self[col]
+          else
+            super
+          end
+        end
+
+        # If the given column has a setter method conflict, set the value directly in the values hash.
+        def set_column_value(c, v)
+          if col = model.set_column_conflicts[c]
+            self[col] = v
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/composition.rb

@@ -100,7 +100,7 @@ module Sequel
               klass = opts[:class]
               class_proc = proc{klass || constantize(opts[:class_name])}
               opts[:composer] = proc do
-                if values = keys.map{|k| send(k)} and values.any?{|v| !v.nil?}
+                if values = keys.map{|k| get_column_value(k)} and values.any?{|v| !v.nil?}
                   class_proc.call.new(*values)
                 else
                   nil
@@ -113,9 +113,9 @@ module Sequel
               setters = setter_meths.zip(cov_methods)
               opts[:decomposer] = proc do
                 if (o = compositions[name]).nil?
-                  setter_meths.each{|sm| send(sm, nil)}
+                  setter_meths.each{|sm| get_column_value(sm, nil)}
                 else
-                  setters.each{|sm, cm| send(sm, o.send(cm))}
+                  setters.each{|sm, cm| get_column_value(sm, o.send(cm))}
                 end
               end
             end

data/lib/sequel/plugins/dirty.rb

@@ -60,7 +60,7 @@ module Sequel
         #
         #   column_change(:name) # => ['Initial', 'Current']
         def column_change(column)
-          [initial_value(column), send(column)] if column_changed?(column)
+          [initial_value(column), get_column_value(column)] if column_changed?(column)
         end
 
         # A hash with column symbol keys and pairs of initial and
@@ -70,7 +70,7 @@ module Sequel
         def column_changes
           h = {}
           initial_values.each do |column, value|
-            h[column] = [value, send(column)]
+            h[column] = [value, get_column_value(column)]
           end
           h
         end
@@ -99,7 +99,7 @@ module Sequel
         #
         #   initial_value(:name) # => 'Initial'
         def initial_value(column)
-          initial_values.fetch(column){send(column)}
+          initial_values.fetch(column){get_column_value(column)}
         end
 
         # A hash with column symbol keys and initial values.
@@ -116,7 +116,7 @@ module Sequel
         #   name # => 'Initial'
         def reset_column(column)
           if initial_values.has_key?(column)
-            send(:"#{column}=", initial_values[column])
+            set_column_value(:"#{column}=", initial_values[column])
           end
           if missing_initial_values.include?(column)
             values.delete(column)
@@ -136,7 +136,7 @@ module Sequel
           value = if initial_values.has_key?(column)
             initial_values[column]
           else
-            send(column)
+            get_column_value(column)
           end
 
           initial_values[column] = if value && value != true && value.respond_to?(:clone)
@@ -184,7 +184,7 @@ module Sequel
             end
           else
             check_missing_initial_value(column)
-            iv[column] = send(column)
+            iv[column] = get_column_value(column)
             super
           end
         end

data/lib/sequel/plugins/json_serializer.rb

@@ -270,7 +270,7 @@ module Sequel
 
           h = {}
 
-          cols.each{|c| h[c.to_s] = send(c)}
+          cols.each{|c| h[c.to_s] = get_column_value(c)}
           if inc = opts[:include]
             if inc.is_a?(Hash)
               inc.each do |k, v|

data/lib/sequel/plugins/list.rb

@@ -63,7 +63,7 @@ module Sequel
           proc{|obj| obj.model.filter(scope=>obj.send(scope))}
         when Array
           model.dataset = model.dataset.order_prepend(*scope)
-          proc{|obj| obj.model.filter(scope.map{|s| [s, obj.send(s)]})}
+          proc{|obj| obj.model.filter(scope.map{|s| [s, obj.get_column_value(s)]})}
         else
           scope
         end
@@ -90,8 +90,8 @@ module Sequel
         # Set the value of the position_field to the maximum value plus 1 unless the
         # position field already has a value.
         def before_create
-          unless send(position_field)
-            send("#{position_field}=", list_dataset.max(position_field).to_i+1)
+          unless get_column_value(position_field)
+            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
           end
           super
         end
@@ -168,7 +168,7 @@ module Sequel
 
         # The value of the model's position field for this instance.
         def position_value
-          send(position_field)
+          get_column_value(position_field)
         end
 
         # The model instance the given number of places below this model instance

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -57,7 +57,7 @@ module Sequel
         # Add the lock column instance filter to the object.
         def lock_column_instance_filter
           lc = model.lock_column
-          instance_filter(lc=>Sequel.blob(send(lc)))
+          instance_filter(lc=>Sequel.blob(get_column_value(lc)))
         end
 
         # Clear the instance filters when refreshing, so that attempting to

data/lib/sequel/plugins/nested_attributes.rb

@@ -152,9 +152,9 @@ module Sequel
         # not use an ensure block, so callers should be careful.
         def nested_attributes_check_key_modifications(meta, obj)
           reflection = meta[:reflection]
-          keys = reflection.associated_object_keys.map{|x| obj.send(x)}
+          keys = reflection.associated_object_keys.map{|x| obj.get_column_value(x)}
           yield
-          unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+          unless keys == reflection.associated_object_keys.map{|x| obj.get_column_value(x)}
             raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed")
           end
         end

data/lib/sequel/plugins/optimistic_locking.rb

@@ -57,7 +57,7 @@ module Sequel
         # Add the lock column instance filter to the object.
         def lock_column_instance_filter
           lc = model.lock_column
-          instance_filter(lc=>send(lc))
+          instance_filter(lc=>get_column_value(lc))
         end
 
         # Clear the instance filters when refreshing, so that attempting to
@@ -72,10 +72,10 @@ module Sequel
         # lock version.
         def _update_columns(columns)
           lc = model.lock_column
-          lcv = send(lc)
+          lcv = get_column_value(lc)
           columns[lc] = lcv + 1
           super
-          send("#{lc}=", lcv + 1)
+          set_column_value("#{lc}=", lcv + 1)
         end
       end
     end