sequel 5.19.0 → 5.24.0

data/lib/sequel/extensions/pg_range.rb

@@ -453,13 +453,14 @@ module Sequel
       end
 
       ENDLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.6'
+      STARTLESS_RANGE_NOT_SUPPORTED = RUBY_VERSION < '2.7'
 
       # Return a ruby Range object for this instance, if one can be created.
       def to_range
         return @range if @range
         raise(Error, "cannot create ruby range for an empty PostgreSQL range") if empty?
         raise(Error, "cannot create ruby range when PostgreSQL range excludes beginning element") if exclude_begin?
-        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") unless self.begin
+        raise(Error, "cannot create ruby range when PostgreSQL range has unbounded beginning") if STARTLESS_RANGE_NOT_SUPPORTED && !self.begin
         raise(Error, "cannot create ruby range when PostgreSQL range has unbounded ending") if ENDLESS_RANGE_NOT_SUPPORTED && !self.end
         @range = Range.new(self.begin, self.end, exclude_end?)
       end
@@ -468,7 +469,7 @@ module Sequel
       # it must have a beginning and an ending (no unbounded ranges), and it cannot exclude
       # the beginning element.
       def valid_ruby_range?
-        !(empty? || exclude_begin? || !self.begin || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
+        !(empty? || exclude_begin? || (STARTLESS_RANGE_NOT_SUPPORTED && !self.begin) || (ENDLESS_RANGE_NOT_SUPPORTED && !self.end))
       end
 
       # Whether the beginning of the range is unbounded.

data/lib/sequel/extensions/pg_row.rb

@@ -7,7 +7,7 @@
 # that when composite fields are retrieved, they are parsed and returned
 # as instances of Sequel::Postgres::PGRow::(HashRow|ArrayRow), or
 # optionally a custom type.  HashRow and ArrayRow are DelegateClasses of
-# of Hash and Array, so they mostly act like a hash or array, but not
+# Hash and Array, so they mostly act like a hash or array, but not
 # completely (is_a?(Hash) and is_a?(Array) are false).  If you want the
 # actual hash for a HashRow, call HashRow#to_hash, and if you want the
 # actual array for an ArrayRow, call ArrayRow#to_a.  This is done so
@@ -228,7 +228,9 @@ module Sequel
           if skip(/\)/)
             values << nil
           else
+            # :nocov:
             until eos?
+            # :nocov:
               if skip(/"/)
                 values << scan(/(\\.|""|[^"])*/).gsub(/\\(.)|"(")/, '\1\2')
                 skip(/"[,)]/)

data/lib/sequel/extensions/schema_dumper.rb

@@ -37,7 +37,7 @@ module Sequel
         {:type =>schema[:type] == :boolean ? TrueClass : Integer}
       when /\Abigint(?:\((?:\d+)\))?(?: unsigned)?\z/
         {:type=>:Bignum}
-      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/
+      when /\A(?:real|float(?: unsigned)?|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/
         {:type=>Float}
       when 'boolean', 'bit', 'bool'
         {:type=>TrueClass}

data/lib/sequel/extensions/server_block.rb

@@ -52,6 +52,12 @@
 #     DB[:a].server(:read_only).delete # Uses shard2
 #   end
 #
+# If you use an invalid server when calling with_server, it will be
+# treated the same way as if you called Dataset#server with an invalid
+# server.  By default, the default server will be used in such cases.
+# If you would like a different server to be used, or an exception to
+# be raised, then use the :servers_hash Database option.
+#
 # Related modules: Sequel::ServerBlock, Sequel::UnthreadedServerBlock,
 # Sequel::ThreadedServerBlock
 
@@ -110,9 +116,9 @@ module Sequel
       else
         case server
         when :default, nil
-          @default_servers[-1][0]
+          @servers[@default_servers[-1][0]]
         when :read_only
-          @default_servers[-1][1]
+          @servers[@default_servers[-1][1]]
         else
           super
         end
@@ -155,11 +161,16 @@ module Sequel
       if !a || a.empty?
         super
       else
+        # Hash handling required to work when loaded after arbitrary servers plugin.
         case server
         when :default, nil
-          a[-1][0]
+          v = a[-1][0]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
         when :read_only
-          a[-1][1]
+          v = a[-1][1]
+          v = @servers[v] unless v.is_a?(Hash)
+          v
         else
           super
         end

data/lib/sequel/model/associations.rb

@@ -1617,9 +1617,10 @@ module Sequel
         #                is hash or array of two element arrays.  Consider also specifying the :graph_block
         #                option if the value for this option is not a hash or array of two element arrays
         #                and you plan to use this association in eager_graph or association_join.
-        # :dataset :: A proc that is instance_execed to get the base dataset to use (before the other
+        # :dataset :: A proc that is used to define the method to get the base dataset to use (before the other
         #             options are applied).  If the proc accepts an argument, it is passed the related
-        #             association reflection.
+        #             association reflection.  It is a best practice to always have the dataset accept an argument
+        #             and use the argument to return the appropriate dataset.
         # :distinct :: Use the DISTINCT clause when selecting associating object, both when
         #              lazy loading and eager loading via .eager (but not when using .eager_graph).
         # :eager :: The associations to eagerly load via +eager+ when loading the associated object(s).
@@ -1909,7 +1910,7 @@ module Sequel
         # can be easily overridden in the class itself while allowing for
         # super to be called.
         def association_module_def(name, opts=OPTS, &block)
-          association_module(opts).module_eval{define_method(name, &block)}
+          association_module(opts).send(:define_method, name, &block)
         end
       
         # Add a private method to the module included in the class.
@@ -1944,6 +1945,13 @@ module Sequel
           end
 
           association_module_def(opts.dataset_method, opts){_dataset(opts)}
+          if opts[:block]
+            opts[:block_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_block", 1, &opts[:block])
+          end
+          if opts[:dataset]
+            opts[:dataset_opt_arity] = opts[:dataset].arity == 0 ? 0 : 1
+            opts[:dataset_opt_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_dataset_opt", opts[:dataset_opt_arity], &opts[:dataset])
+          end
           def_association_method(opts)
 
           return if opts[:read_only]
@@ -2204,12 +2212,28 @@ module Sequel
           if one_to_one
             opts[:setter] ||= proc do |o|
               up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)})))
+
+              if (froms = up_ds.opts[:from]) && (from = froms[0]) && (from.is_a?(Sequel::Dataset) || (from.is_a?(Sequel::SQL::AliasedExpression) && from.expression.is_a?(Sequel::Dataset)))
+                if old = up_ds.first
+                  cks.each{|k| old.set_column_value(:"#{k}=", nil)}
+                end
+                save_old = true
+              end
+
               if o
-                up_ds = up_ds.exclude(o.pk_hash) unless o.new?
+                if !o.new? && !save_old
+                  up_ds = up_ds.exclude(o.pk_hash)
+                end
                 cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
               end
+
               checked_transaction do
-                up_ds.skip_limit_check.update(ck_nil_hash)
+                if save_old
+                  old.save(save_opts) || raise(Sequel::Error, "invalid previously associated object, cannot save") if old
+                else
+                  up_ds.skip_limit_check.update(ck_nil_hash)
+                end
+
                 o.save(save_opts) || raise(Sequel::Error, "invalid associated object, cannot save") if o
               end
             end
@@ -2287,7 +2311,8 @@ module Sequel
           end
           ds = ds.clone(:model_object => self)
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
-          ds = instance_exec(ds, &opts[:block]) if opts[:block]
+          # block method is private
+          ds = send(opts[:block_method], ds) if opts[:block_method]
           ds
         end
 
@@ -2310,10 +2335,11 @@ module Sequel
         # Return an association dataset for the given association reflection
         def _dataset(opts)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          ds = if opts[:dataset].arity == 1
-            instance_exec(opts, &opts[:dataset])
+          ds = if opts[:dataset_opt_arity] == 1
+            # dataset_opt_method is private
+            send(opts[:dataset_opt_method], opts)
           else
-            instance_exec(&opts[:dataset])
+            send(opts[:dataset_opt_method])
           end
           _apply_association_options(opts, ds)
         end

data/lib/sequel/model/plugins.rb

@@ -51,5 +51,109 @@ module Sequel
         r
       end
     end
+
+    method_num = 0
+    method_num_mutex = Mutex.new
+    # Return a unique method name symbol for the given suffix.
+    SEQUEL_METHOD_NAME = lambda do |suffix|
+      :"_sequel_#{suffix}_#{method_num_mutex.synchronize{method_num += 1}}"
+    end
+
+    # Define a private instance method using the block with the provided name and
+    # expected arity.  If the name is given as a Symbol, it is used directly.
+    # If the name is given as a String, a unique name will be generated using
+    # that string.  The expected_arity should be either 0 (no arguments) or
+    # 1 (single argument).
+    #
+    # If a block with an arity that does not match the expected arity is used,
+    # a deprecation warning will be issued. The method defined should still
+    # work, though it will be slower than a method with the expected arity.
+    #
+    # Sequel only checks arity for regular blocks, not lambdas.  Lambdas were
+    # already strict in regards to arity, so there is no need to try to fix
+    # arity to keep backwards compatibility for lambdas.
+    #
+    # Blocks with required keyword arguments are not supported by this method.
+    def self.def_sequel_method(model, meth, expected_arity, &block)
+      if meth.is_a?(String)
+        meth = SEQUEL_METHOD_NAME.call(meth)
+      end
+      call_meth = meth
+
+      unless block.lambda?
+        required_args, optional_args, rest, keyword = _define_sequel_method_arg_numbers(block)
+
+        if keyword == :required
+          raise Error, "cannot use block with required keyword arguments when calling define_sequel_method with expected arity #{expected_arity}"
+        end
+
+        case expected_arity
+        when 0
+          unless required_args == 0
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 0, but arguments required for #{block.inspect}. Support for this will be removed in Sequel 6.")
+            b = block
+            block = lambda{instance_exec(&b)} # Fallback
+          end
+        when 1
+          if required_args == 0 && optional_args == 0 && !rest
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 1, but no arguments accepted for #{block.inspect}.  Support for this will be removed in Sequel 6.")
+            temp_method = SEQUEL_METHOD_NAME.call("temp")
+            model.class_eval("def #{temp_method}(_) #{meth =~ /\A\w+\z/ ? "#{meth}_arity" : "send(:\"#{meth}_arity\")"} end", __FILE__, __LINE__)
+            model.send(:alias_method, meth, temp_method)
+            model.send(:undef_method, temp_method)
+            model.send(:private, meth)
+            meth = :"#{meth}_arity"
+          elsif required_args > 1
+            # SEQUEL6: remove
+            Sequel::Deprecation.deprecate("Arity mismatch in block passed to define_sequel_method. Expected Arity 1, but more arguments required for #{block.inspect}.  Support for this will be removed in Sequel 6.")
+            b = block
+            block = lambda{|r| instance_exec(r, &b)} # Fallback
+          end
+        else
+          raise Error, "unexpected arity passed to define_sequel_method: #{expected_arity.inspect}"
+        end
+      end
+
+      model.send(:define_method, meth, &block)
+      model.send(:private, meth)
+      call_meth
+    end
+
+    # Return the number of required argument, optional arguments,
+    # whether the callable accepts any additional arguments,
+    # and whether the callable accepts keyword arguments (true, false
+    # or :required).
+    def self._define_sequel_method_arg_numbers(callable)
+      optional_args = 0
+      rest = false
+      keyword = false
+      callable.parameters.map(&:first).each do |arg_type, _|
+        case arg_type
+        when :opt
+          optional_args += 1
+        when :rest
+          rest = true
+        when :keyreq
+          keyword = :required
+        when :key, :keyrest
+          keyword ||= true
+        end
+      end
+      arity = callable.arity
+      if arity < 0
+        arity = arity.abs - 1
+      end
+      required_args = arity
+      arity -= 1 if keyword == :required
+
+      if callable.is_a?(Proc) && !callable.lambda?
+        optional_args -= arity
+      end
+
+      [required_args, optional_args, rest, keyword]
+    end
+    private_class_method :_define_sequel_method_arg_numbers
   end
 end

data/lib/sequel/plugins/association_dependencies.rb

@@ -60,9 +60,9 @@ module Sequel
             association_dependencies[:"#{time}_#{action}"] << if action == :nullify
               case type
               when :one_to_many , :many_to_many
-                proc{public_send(r[:remove_all_method])}
+                [r[:remove_all_method]]
               when :one_to_one
-                proc{public_send(r[:setter_method], nil)}
+                [r[:setter_method], nil]
               else
                 raise(Error, "Can't nullify many_to_one associated objects: association: #{association}")
               end
@@ -97,7 +97,7 @@ module Sequel
         def before_destroy
           model.association_dependencies[:before_delete].each{|m| public_send(m).delete}
           model.association_dependencies[:before_destroy].each{|m| public_send(m).destroy}
-          model.association_dependencies[:before_nullify].each{|p| instance_exec(&p)}
+          model.association_dependencies[:before_nullify].each{|args| public_send(*args)}
           super
         end
       end

data/lib/sequel/plugins/association_pks.rb

@@ -60,8 +60,15 @@ module Sequel
 
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_methods(opts)
+          opts[:pks_getter_method] = :"#{singularize(opts[:name])}_pks_getter"
+          association_module_def(opts[:pks_getter_method], &opts[:pks_getter])
           association_module_def(:"#{singularize(opts[:name])}_pks", opts){_association_pks_getter(opts)}
-          association_module_def(:"#{singularize(opts[:name])}_pks=", opts){|pks| _association_pks_setter(opts, pks)} if opts[:pks_setter]
+
+          if opts[:pks_setter]
+            opts[:pks_setter_method] = :"#{singularize(opts[:name])}_pks_setter"
+            association_module_def(opts[:pks_setter_method], &opts[:pks_setter])
+            association_module_def(:"#{singularize(opts[:name])}_pks=", opts){|pks| _association_pks_setter(opts, pks)}
+          end
         end
 
         # Add a getter that checks the join table for matching records and
@@ -181,7 +188,8 @@ module Sequel
         def after_save
           if assoc_pks = @_association_pks
             assoc_pks.each do |name, pks|
-              instance_exec(pks, &model.association_reflection(name)[:pks_setter])
+             # pks_setter_method is private
+              send(model.association_reflection(name)[:pks_setter_method], pks)
             end
             @_association_pks = nil
           end
@@ -206,7 +214,8 @@ module Sequel
           elsif delay && @_association_pks && (objs = @_association_pks[opts[:name]])
             objs
           else
-            instance_exec(&opts[:pks_getter])
+           # pks_getter_method is private
+            send(opts[:pks_getter_method])
           end
         end
 
@@ -231,7 +240,8 @@ module Sequel
             modified!
             (@_association_pks ||= {})[opts[:name]] = pks
           else
-            instance_exec(pks, &opts[:pks_setter])
+            # pks_setter_method is private
+            send(opts[:pks_setter_method], pks)
           end
         end
 

data/lib/sequel/plugins/association_proxies.rb

@@ -64,6 +64,8 @@ module Sequel
         array = [].freeze
 
         if RUBY_VERSION < '2.6'
+          # :nocov:
+
           # Default proc used to determine whether to send the method to the dataset.
           # If the array would respond to it, sends it to the array instead of the dataset.
           DEFAULT_PROXY_TO_DATASET = proc do |opts|
@@ -73,10 +75,9 @@ module Sequel
             end
             !array_method
           end
-        else
           # :nocov:
+        else
           DEFAULT_PROXY_TO_DATASET = proc{|opts| !array.respond_to?(opts[:method])}
-          # :nocov:
         end
 
         # Set the association reflection to use, and whether the association should be

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -108,6 +108,16 @@ module Sequel
     #   a = Executive.where{{employees[:id]=>1}}.first # works
     #   a = Executive.where{{executives[:id]=>1}}.first # doesn't work
     #
+    # Note that because subclass datasets select from a subquery, you cannot update,
+    # delete, or insert into them directly.  To delete related rows, you need to go
+    # through the related tables and remove the related rows.  Code that does this would
+    # be similar to:
+    #
+    #   pks = Executive.where{num_staff < 10}.select_map(:id)
+    #   Executive.cti_tables.reverse_each do |table|
+    #     DB.from(table).where(:id=>pks).delete
+    #   end
+    #
     # = Usage
     #
     #   # Use the default of storing the class name in the sti_key
@@ -326,6 +336,7 @@ module Sequel
             cti_tables.reverse_each do |ct|
               db.schema(ct).each{|sk,v| db_schema[sk] = v}
             end
+            setup_auto_validations if respond_to?(:setup_auto_validations, true)
           end
         end
 

data/lib/sequel/plugins/composition.rb

@@ -32,9 +32,10 @@ module Sequel
     #
     # The :mapping option is just a shortcut that works in particular
     # cases.  To handle any case, you can define a custom :composer
-    # and :decomposer procs.  The :composer proc will be instance_execed
-    # the first time the getter is called, and the :decomposer proc
-    # will be instance_execed before saving.  The above example could
+    # and :decomposer procs.  The :composer and :decomposer procs will
+    # be used to define instance methods.  The :composer will be called
+    # the first time the getter is called, and the :decomposer 
+    # will be called before saving.  The above example could
     # also be implemented as:
     #
     #   Album.composition :date,
@@ -74,9 +75,9 @@ module Sequel
         #
         # Options:
         # :class :: if using the :mapping option, the class to use, as a Class, String or Symbol.
-        # :composer :: A proc that is instance_execed when the composition getter method is called
+        # :composer :: A proc used to define the method that the composition getter method will call 
         #              to create the composition.
-        # :decomposer :: A proc that is instance_execed before saving the model object,
+        # :decomposer :: A proc used to define the method called before saving the model object,
         #                if the composition object exists, which sets the columns in the model object
         #                based on the value of the composition object.
         # :mapping :: An array where each element is either a symbol or an array of two symbols.
@@ -129,15 +130,17 @@ module Sequel
         
         # Define getter and setter methods for the composition object.
         def define_composition_accessor(name, opts=OPTS)
-          composer = opts[:composer]
+          composer_meth = opts[:composer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_composer", 0, &opts[:composer])
+          opts[:decomposer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_decomposer", 0, &opts[:decomposer])
           @composition_module.class_eval do
             define_method(name) do 
               if compositions.has_key?(name)
                 compositions[name]
               elsif frozen?
-                instance_exec(&composer)
+                # composer_meth is private
+                send(composer_meth)
               else
-                compositions[name] = instance_exec(&composer)
+                compositions[name] = send(composer_meth)
               end
             end
             define_method("#{name}=") do |v|
@@ -171,7 +174,8 @@ module Sequel
         # For each composition, set the columns in the model class based
         # on the composition object.
         def before_validation
-          @compositions.keys.each{|n| instance_exec(&model.compositions[n][:decomposer])} if @compositions
+          # decomposer_method is private
+          @compositions.keys.each{|n| send(model.compositions[n][:decomposer_method])} if @compositions
           super
         end