sequel 5.8.0 → 5.38.0

data/lib/sequel/model/plugins.rb

@@ -31,6 +31,7 @@ module Sequel
     def self.def_dataset_methods(mod, meths)
       Array(meths).each do |meth|
         mod.class_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+        mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
       end
     end
 
@@ -40,6 +41,7 @@ module Sequel
       mod.send(:define_method, :inherited_instance_variables) do ||
         super().merge!(hash)
       end
+      mod.send(:private, :inherited_instance_variables)
     end
 
     # Add method to +mod+ that overrides set_dataset to call the method afterward.
@@ -51,5 +53,108 @@ 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
+
+      # callable currently is always a non-lambda Proc
+      optional_args -= arity
+
+      [required_args, optional_args, rest, keyword]
+    end
+    private_class_method :_define_sequel_method_arg_numbers
   end
 end

data/lib/sequel/plugins/after_initialize.rb

@@ -15,7 +15,7 @@ module Sequel
     module AfterInitialize
       module ClassMethods
         # Call after_initialize for model objects loaded from the database.
-        def call(h={})
+        def call(_)
           v = super
           v.after_initialize
           v

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_lazy_eager_option.rb

@@ -0,0 +1,66 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_lazy_eager_option plugin supports passing
+    # an +:eager+ option to an association method.  If the related
+    # association is already cached, the cached version will be
+    # returned.  If the association is not already cached, it will
+    # be loaded, and the value of the +:eager+ option will be used
+    # to perform an eager load of the given associations.
+    # the plural versions.
+    #
+    # With Sequel's default behavior, you can already perform an
+    # eager load when lazy loading using a block:
+    #
+    #   obj.association{|ds| ds.eager(:nested_association)}
+    #
+    # However, this will ignore any cached version.  In more
+    # complex software, the association may already be cached
+    # and have the nested association cached inside of it, and
+    # using this callback approach then requires 2 unnecessary
+    # queries. This plugin will not perform any queries if the
+    # association is already cached, preventing duplicate work.
+    # However, you should make sure that an already loaded
+    # association has the nested association already eagerly
+    # loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support the :eager association
+    #   # method option (called before loading subclasses)
+    #   Sequel::Model.plugin :association_lazy_eager_option
+    #
+    #   # Make the Album class support the :eager association
+    #   # method option
+    #   Album.plugin :association_lazy_eager_option
+    module AssociationLazyEagerOption
+      module InstanceMethods
+        private
+
+        # Return a dataset for the association after applying any dynamic callback.
+        def _associated_dataset(opts, dynamic_opts)
+          ds = super
+
+          if eager = dynamic_opts[:eager]
+            ds = ds.eager(eager)
+          end
+
+          ds
+        end
+        
+        # A placeholder literalizer that can be used to load the association, or nil to not use one.
+        def _associated_object_loader(opts, dynamic_opts)
+          return if dynamic_opts[:eager]
+          super
+        end
+
+        # Whether to use a simple primary key lookup on the associated class when loading.
+        def load_with_primary_key_lookup?(opts, dynamic_opts)
+          return false if dynamic_opts[:eager]
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/association_multi_add_remove.rb

@@ -0,0 +1,85 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_multi_add_remove plugin allows adding, removing and setting
+    # multiple associated objects in a single method call.
+    # By default Sequel::Model defines singular <tt>add_*</tt> and <tt>remove_*</tt>
+    # methods that operate on a single associated object, this adds plural forms
+    # that operate on multiple associated objects. Example:
+    #
+    #   artist.albums # => [album1]
+    #   artist.add_albums([album2, album3])
+    #   artist.albums # => [album1, album2, album3]
+    #   artist.remove_albums([album3, album1])
+    #   artist.albums # => [album2]
+    #   artist.albums = [album2, album3]
+    #   artist.albums # => [album2, album3]
+    #
+    # It can handle all situations that the normal singular methods handle, but there is
+    # no attempt to optimize behavior, so using these methods will not improve performance.
+    #
+    # The add/remove/set methods defined by this plugin use a transaction,
+    # so if one add/remove/set fails and raises an exception, all adds/removes/set
+    # will be rolled back. If you are using database sharding and want to save
+    # to a specific shard, call Model#set_server to set the server for this instance,
+    # as the transaction will be opened on that server.
+    #
+    # You can customize the method names used for adding/removing multiple associated
+    # objects using the :multi_add_method and :multi_remove_method association options.
+    #
+    # Usage:
+    #
+    #   # Allow adding/removing/setting multiple associated objects in a single call
+    #   # for all model subclass instances (called before loading subclasses):
+    #   Sequel::Model.plugin :association_multi_add_remove
+    #
+    #   # Allow adding/removing/setting multiple associated objects in a single call
+    #   # for Album instances (called before defining associations in the class):
+    #   Album.plugin :association_multi_add_remove
+    module AssociationMultiAddRemove
+      module ClassMethods
+        private
+
+        # Define the methods use to add/remove/set multiple associated objects
+        # in a single method call.
+        def def_association_instance_methods(opts)
+          super
+
+          if opts[:adder]
+            add_method = opts[:add_method]
+            multi_add_method = opts[:multi_add_method] || :"add_#{opts[:name]}"
+            multi_add_method = nil if add_method == multi_add_method
+            if multi_add_method
+              association_module_def(multi_add_method, opts) do |objs, *args|
+                db.transaction(:server=>@server){objs.map{|obj| send(add_method, obj, *args)}.compact}
+              end
+            end
+          end
+
+          if opts[:remover]
+            remove_method = opts[:remove_method]
+            multi_remove_method = opts[:multi_remove_method] || :"remove_#{opts[:name]}"
+            multi_remove_method = nil if remove_method == multi_remove_method
+            if multi_remove_method
+              association_module_def(multi_remove_method, opts) do |objs, *args|
+                db.transaction(:server=>@server){objs.map{|obj| send(remove_method, obj, *args)}.compact}
+              end
+            end
+          end
+
+          if multi_add_method && multi_remove_method
+            association_module_def(:"#{opts[:name]}=", opts) do |objs, *args|
+              db.transaction(:server=>@server) do
+                existing_objs = send(opts.association_method)
+                send(multi_remove_method, (existing_objs - objs), *args)
+                send(multi_add_method, (objs - existing_objs), *args)
+                nil
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/association_pks.rb

@@ -2,13 +2,17 @@
 
 module Sequel
   module Plugins
-    # The association_pks plugin adds association_pks and association_pks=
-    # instance methods to the model class for each association added.  These
-    # methods allow for easily returning the primary keys of the associated
-    # objects, and easily modifying which objects are associated:
+    # The association_pks plugin adds association_pks, association_pks=, and
+    # association_pks_dataset instance methods to the model class for each
+    # one_to_many and many_to_many association added.  These methods allow for
+    # easily returning the primary keys of the associated objects, and easily
+    # modifying which objects are associated:
     #
     #   Artist.one_to_many :albums
     #   artist = Artist[1]
+    #   artist.album_pks_dataset
+    #   # SELECT id FROM albums WHERE (albums.artist_id = 1)
+    #
     #   artist.album_pks # [1, 2, 3]
     #   artist.album_pks = [2, 4]
     #   artist.album_pks # [2, 4]
@@ -22,11 +26,18 @@ module Sequel
     # This plugin makes modifications directly to the underlying tables,
     # it does not create or return any model objects, and therefore does
     # not call any callbacks.  If you have any association callbacks,
-    # you probably should not use the setter methods.
+    # you probably should not use the setter methods this plugin adds.
     #
     # By default, changes to the association will not happen until the object
-    # is saved.  However, using the delay_pks: false option, you can have the
-    # changes made immediately when the association_pks setter method is called.
+    # is saved.  However, using the delay_pks: false association option, you can have
+    # the changes made immediately when the association_pks setter method is called.
+    #
+    # By default, repeated calls to the association_pks getter method will not be
+    # cached, unless the setter method has been used and the delay_pks: false
+    # association option is not used.  You can set caching of repeated calls to the
+    # association_pks getter method using the :cache_pks association option.  You can
+    # pass the :refresh option when calling the getter method to ignore any existing
+    # cached values, similar to how the :refresh option works with associations.
     #
     # By default, if you pass a nil value to the setter, an exception will be raised.
     # You can change this behavior by using the :association_pks_nil association option.
@@ -60,8 +71,17 @@ module Sequel
 
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_methods(opts)
-          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]
+          association_module_def(opts[:pks_dataset_method], &opts[:pks_dataset])
+
+          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){|dynamic_opts=OPTS| _association_pks_getter(opts, dynamic_opts)}
+
+          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
@@ -77,7 +97,9 @@ module Sequel
           clpk = lpk.is_a?(Array)
           crk = rk.is_a?(Array)
 
-          opts[:pks_getter] = if join_associated_table = opts[:association_pks_use_associated_table]
+          dataset_method = opts[:pks_dataset_method] = :"#{singularize(opts[:name])}_pks_dataset"
+
+          opts[:pks_dataset] = if join_associated_table = opts[:association_pks_use_associated_table]
             tname = opts[:join_table]
             lambda do
               cond = if clpk
@@ -88,16 +110,26 @@ module Sequel
               rpk = opts.associated_class.primary_key
               opts.associated_dataset.
                 naked.where(cond).
-                select_map(Sequel.public_send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
+                select(*Sequel.public_send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
             end
           elsif clpk
             lambda do
               cond = lk.zip(lpk).map{|k, pk| [k, get_column_value(pk)]}
-              _join_table_dataset(opts).where(cond).select_map(rk)
+              _join_table_dataset(opts).where(cond).select(*rk)
             end
           else
             lambda do
-              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select_map(rk)
+              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select(*rk)
+            end
+          end
+
+          opts[:pks_getter] = if join_associated_table = opts[:association_pks_use_associated_table]
+            lambda do
+              public_send(dataset_method).map(opts.associated_class.primary_key)
+            end
+          else
+            lambda do
+              public_send(dataset_method).map(rk)
             end
           end
 
@@ -138,8 +170,14 @@ module Sequel
 
           key = opts[:key]
 
+          dataset_method = opts[:pks_dataset_method] = :"#{singularize(opts[:name])}_pks_dataset"
+
+          opts[:pks_dataset] = lambda do
+            public_send(opts[:dataset_method]).select(*opts.associated_class.primary_key)
+          end
+
           opts[:pks_getter] = lambda do
-            public_send(opts[:dataset_method]).select_map(opts.associated_class.primary_key)
+            public_send(dataset_method).map(opts.associated_class.primary_key)
           end
 
           unless opts[:read_only]
@@ -181,7 +219,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
@@ -199,14 +238,25 @@ module Sequel
         # Return the primary keys of the associated objects.
         # If the receiver is a new object, return any saved
         # pks, or an empty array if no pks have been saved.
-        def _association_pks_getter(opts)
+        def _association_pks_getter(opts, dynamic_opts=OPTS)
+          do_cache = opts[:cache_pks]
           delay = opts.fetch(:delay_pks, true)
-          if new? && delay
+          cache_or_delay = do_cache || delay
+
+          if dynamic_opts[:refresh] && @_association_pks
+            @_association_pks.delete(opts[:name])
+          end
+
+          if new? && cache_or_delay
             (@_association_pks ||= {})[opts[:name]] ||= []
-          elsif delay && @_association_pks && (objs = @_association_pks[opts[:name]])
+          elsif cache_or_delay && @_association_pks && (objs = @_association_pks[opts[:name]])
             objs
+          elsif do_cache
+           # pks_getter_method is private
+            (@_association_pks ||= {})[opts[:name]] = send(opts[:pks_getter_method])
           else
-            instance_exec(&opts[:pks_getter])
+           # pks_getter_method is private
+            send(opts[:pks_getter_method])
           end
         end
 
@@ -231,7 +281,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
 
@@ -244,9 +295,10 @@ module Sequel
 
           if primary_key.is_a?(Array)
             if (cols = sch.values_at(*klass.primary_key)).all? && (convs = cols.map{|c| c[:type] == :integer}).all?
+              db = model.db
               pks.map do |cpk|
-                cpk.zip(convs).map do |pk, conv|
-                  conv ? model.db.typecast_value(:integer, pk) : pk
+                cpk.map do |pk|
+                  db.typecast_value(:integer, pk)
                 end
               end
             else