sequel 5.32.0 → 5.37.0

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(?: unsigned)?|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/
+      when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\))(?: unsigned)?\z/
         {:type=>Float}
       when 'boolean', 'bit', 'bool'
         {:type=>TrueClass}
@@ -57,7 +57,7 @@ module Sequel
         {:type=>String, :size=>($1.to_i if $1)}
       when /\A(?:small)?money\z/
         {:type=>BigDecimal, :size=>[19,2]}
-      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?\z/
+      when /\A(?:decimal|numeric|number)(?:\((\d+)(?:,\s*(\d+))?\))?(?: unsigned)?\z/
         s = [($1.to_i if $1), ($2.to_i if $2)].compact
         {:type=>BigDecimal, :size=>(s.empty? ? nil : s)}
       when /\A(?:bytea|(?:tiny|medium|long)?blob|(?:var)?binary)(?:\((\d+)\))?\z/
@@ -218,7 +218,7 @@ END_MIG
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)
-          if [Integer, :Bignum, Float].include?(type) && schema[:db_type] =~ / unsigned\z/io
+          if [Integer, :Bignum, Float, BigDecimal].include?(type) && schema[:db_type] =~ / unsigned\z/io
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
         end

data/lib/sequel/extensions/symbol_aref_refinement.rb

@@ -25,7 +25,9 @@
 #
 # Related module: Sequel::SymbolAref
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::SymbolAref
   refine Symbol do

data/lib/sequel/extensions/symbol_as_refinement.rb

@@ -23,7 +23,9 @@
 #
 # Related module: Sequel::SymbolAs
 
+# :nocov:
 raise(Sequel::Error, "Refinements require ruby 2.0.0 or greater") unless RUBY_VERSION >= '2.0.0'
+# :nocov:
 
 module Sequel::SymbolAs
   refine Symbol do

data/lib/sequel/extensions/to_dot.rb

@@ -53,7 +53,13 @@ module Sequel
     # is given, it is used directly as the node or transition.  Otherwise
     # a node is created for the current object.
     def dot(label, j=nil)
-      @dot << "#{j||@i} [label=#{label.to_s.inspect}];"
+      label = case label
+      when nil
+        "<nil>"
+      else
+        label.to_s
+      end
+      @dot << "#{j||@i} [label=#{label.inspect}];"
     end
 
     # Recursive method that parses all of Sequel's internal datastructures,
@@ -61,7 +67,7 @@ module Sequel
     # structure.
     def v(e, l)
       @i += 1
-      dot(l, "#{@stack.last} -> #{@i}") if l
+      dot(l, "#{@stack.last} -> #{@i}")
       @stack.push(@i)
       case e
       when LiteralString
@@ -144,7 +150,7 @@ module Sequel
         dot "Dataset"
         TO_DOT_OPTIONS.each do |k|
           if val = e.opts[k]
-            v(val, k.to_s) 
+            v(val, k) 
           end
         end
       else

data/lib/sequel/model.rb

@@ -69,7 +69,9 @@ module Sequel
     require_relative "model/base"
     require_relative "model/exceptions"
     require_relative "model/errors"
+    # :nocov:
     if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
+    # :nocov:
       require_relative 'model/associations'
       plugin Model::Associations
     end
@@ -77,7 +79,7 @@ module Sequel
     def_Model(::Sequel)
 
     # The setter methods (methods ending with =) that are never allowed
-    # to be called automatically via +set+/+update+/+new+/etc..
+    # to be called automatically via +set+/+update+/+new+/etc.
     RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).select{|l| l.end_with?('=')}.freeze
   end
 end

data/lib/sequel/model/associations.rb

@@ -164,11 +164,11 @@ module Sequel
         # range to return the object(s) at the correct offset/limit.
         def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset())
           name = self[:name]
+          return unless range = slice_range(limit_and_offset)
           if returns_array?
-            range = slice_range(limit_and_offset)
             rows.each{|o| o.associations[name] = o.associations[name][range] || []}
-          elsif sr = slice_range(limit_and_offset)
-            offset = sr.begin
+          else
+            offset = range.begin
             rows.each{|o| o.associations[name] = o.associations[name][offset]}
           end
         end
@@ -356,7 +356,7 @@ module Sequel
         def finalize
           return unless cache = self[:cache]
 
-          finalize_settings.each do |meth, key|
+          finalizer = proc do |meth, key|
             next if has_key?(key)
 
             # Allow calling private methods to make sure caching is done appropriately
@@ -364,6 +364,13 @@ module Sequel
             self[key] = cache.delete(key) if cache.has_key?(key)
           end
 
+          finalize_settings.each(&finalizer)
+
+          unless self[:instance_specific]
+            finalizer.call(:associated_eager_dataset, :associated_eager_dataset)
+            finalizer.call(:filter_by_associations_conditions_dataset, :filter_by_associations_conditions_dataset)
+          end
+
           nil
         end
 
@@ -371,9 +378,7 @@ module Sequel
         FINALIZE_SETTINGS = {
           :associated_class=>:class,
           :associated_dataset=>:_dataset,
-          :associated_eager_dataset=>:associated_eager_dataset,
           :eager_limit_strategy=>:_eager_limit_strategy,
-          :filter_by_associations_conditions_dataset=>:filter_by_associations_conditions_dataset,
           :placeholder_loader=>:placeholder_loader,
           :predicate_key=>:predicate_key,
           :predicate_keys=>:predicate_keys,
@@ -432,7 +437,11 @@ module Sequel
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
               Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-                ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
+                ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
+                if self[:block]
+                  ds = self[:block].call(ds)
+                end
+                ds
               end
             end
           end
@@ -796,7 +805,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          !self[:instance_specific] && !self[:eager_graph]
+          self[:use_placeholder_loader]
         end
       end
     
@@ -1244,7 +1253,9 @@ module Sequel
             else
               assoc_record.values.delete(left_key_alias)
             end
-            next unless objects = h[hash_key]
+
+            objects = h[hash_key]
+
             if assign_singular
               objects.each do |object| 
                 object.associations[name] ||= assoc_record
@@ -1791,11 +1802,12 @@ module Sequel
           opts.merge!(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
 
           opts[:block] = block if block
-          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block] || orig_opts[:dataset])
+          opts[:instance_specific] = true if orig_opts[:dataset]
+          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block])
             # It's possible the association is instance specific, in that it depends on
             # values other than the foreign key value.  This needs to be checked for
             # in certain places to disable optimizations.
-            opts[:instance_specific] = true
+            opts[:instance_specific] = _association_instance_specific_default(name)
           end
           opts = assoc_class.new.merge!(opts)
 
@@ -1803,6 +1815,7 @@ module Sequel
             raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})")
           end
 
+          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph]
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
@@ -1899,6 +1912,12 @@ module Sequel
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private
+
+        # The default value for the instance_specific option, if the association
+        # could be instance specific and the :instance_specific option is not specified.
+        def _association_instance_specific_default(_)
+          true
+        end
       
         # The module to use for the association's methods.  Defaults to
         # the overridable_methods_module.
@@ -1948,10 +1967,8 @@ module Sequel
           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
+          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])
           def_association_method(opts)
 
           return if opts[:read_only]
@@ -2122,9 +2139,7 @@ module Sequel
 
             eager_load_results(opts, eo) do |assoc_record|
               hash_key = uses_cks ? pk_meths.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(opts.primary_key_method)
-              if objects = h[hash_key]
-                objects.each{|object| object.associations[name] = assoc_record}
-              end
+              h[hash_key].each{|object| object.associations[name] = assoc_record}
             end
           end
       
@@ -2171,7 +2186,7 @@ module Sequel
             eager_load_results(opts, eo) do |assoc_record|
               assoc_record.values.delete(delete_rn) if delete_rn
               hash_key = uses_cks ? km.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(km)
-              next unless objects = h[hash_key]
+              objects = h[hash_key]
               if assign_singular
                 objects.each do |object| 
                   unless object.associations[name]
@@ -2966,8 +2981,8 @@ module Sequel
         # dataset.  If that association also has dependent associations, instead of a callable object,
         # use a hash with the callable object being the key, and the dependent association(s) as the value.
         # 
-        # You can specify an alias by providing a Sequel::SQL::AliasedExpression object instead of
-        # an a Symbol for the assocation name.
+        # You can specify an custom alias and/or join type on a per-association basis by providing an
+        # Sequel::SQL::AliasedExpression object instead of an a Symbol for the association name.
         #
         # Examples:
         #
@@ -2983,6 +2998,14 @@ module Sequel
         #   # FROM albums
         #   # LEFT OUTER JOIN artists AS a ON (a.id = albums.artist_id)
         #
+        #   # For each album, eager_graph load the artist, using a specified alias
+        #   # and custom join type
+        #
+        #   Album.eager_graph(Sequel[:artist].as(:a, join_type: :inner)).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # INNER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
         #   # For each album, eager_graph load the artist and genre
         #   Album.eager_graph(:artist, :genre).all
         #   Album.eager_graph(:artist).eager_graph(:genre).all
@@ -3056,6 +3079,8 @@ module Sequel
         #                    significantly slower in some cases (perhaps even the majority of cases), so you should
         #                    only use this if you have benchmarked that it is faster for your use cases.
         def eager_graph_with_options(associations, opts=OPTS)
+          return self if associations.empty?
+
           opts = opts.dup unless opts.frozen?
           associations = [associations] unless associations.is_a?(Array)
           ds = if eg = @opts[:eager_graph]
@@ -3125,11 +3150,16 @@ module Sequel
         # ta :: table_alias used for the parent association
         # requirements :: an array, used as a stack for requirements
         # r :: association reflection for the current association, or an SQL::AliasedExpression
-        #      with the reflection as the expression and the alias base as the aliaz.
+        #      with the reflection as the expression, the alias base as the alias (or nil to
+        #      use the default alias), and an optional hash with a :join_type entry as the columns
+        #      to use a custom join type.
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
           if r.is_a?(SQL::AliasedExpression)
             alias_base = r.alias
+            if r.columns.is_a?(Hash)
+              join_type = r.columns[:join_type]
+            end
             r = r.expression
           else
             alias_base = r[:graph_alias_base]
@@ -3152,7 +3182,7 @@ module Sequel
             raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
           end
 
-          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
+          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>join_type || local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
           if r[:order_eager_graph] && (order = r.fetch(:graph_order, r[:order]))
             ds = ds.order_append(*qualified_expression(order, assoc_table_alias))
           end
@@ -3177,7 +3207,6 @@ module Sequel
         # requirements :: an array, used as a stack for requirements
         # *associations :: the associations to add to the graph
         def eager_graph_associations(ds, model, ta, requirements, *associations)
-          return ds if associations.empty?
           associations.flatten.each do |association|
             ds = case association
             when Symbol, SQL::AliasedExpression
@@ -3307,7 +3336,7 @@ module Sequel
               end
             end
 
-            SQL::AliasedExpression.new(check_association(model, expr), association.alias)
+            SQL::AliasedExpression.new(check_association(model, expr), association.alias || expr, association.columns)
           else
             check_association(model, association)
           end

data/lib/sequel/model/base.rb

@@ -491,6 +491,11 @@ module Sequel
       # the module using a the camelized plugin name under Sequel::Plugins.
       def plugin(plugin, *args, &block)
         m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
+
+        if !m.respond_to?(:apply) && !m.respond_to?(:configure) && (!args.empty? || block)
+          Deprecation.deprecate("Plugin #{plugin} accepts no arguments or block, and passing arguments/block to it", "Remove arguments and block when loading the plugin")
+        end
+
         unless @plugins.include?(m)
           @plugins << m
           m.apply(self, *args, &block) if m.respond_to?(:apply)
@@ -500,8 +505,10 @@ module Sequel
             dataset_extend(m::DatasetMethods, :create_class_methods=>false)
           end
         end
+
         m.configure(self, *args, &block) if m.respond_to?(:configure)
       end
+      ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)
 
       # Returns primary key attribute hash.  If using a composite primary key
       # value such be an array with values for each primary key in the correct
@@ -593,7 +600,7 @@ module Sequel
           @columns = superclass.instance_variable_get(:@columns)
           @db_schema = superclass.instance_variable_get(:@db_schema)
         else
-          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse) if @dataset_method_modules
+          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse)
           @db_schema = get_db_schema
         end
 
@@ -632,8 +639,7 @@ module Sequel
   
       # Cache of setter methods to allow by default, in order to speed up mass assignment.
       def setter_methods
-        return @setter_methods if @setter_methods
-        @setter_methods = get_setter_methods
+        @setter_methods || (@setter_methods = get_setter_methods)
       end
 
       # Returns name of primary table for the dataset. If the table for the dataset
@@ -751,6 +757,7 @@ module Sequel
         else
           define_singleton_method(meth){|*args, &block| dataset.public_send(meth, *args, &block)}
         end
+        singleton_class.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -820,7 +827,6 @@ module Sequel
         super
         ivs = subclass.instance_variables
         inherited_instance_variables.each do |iv, dup|
-          next if ivs.include?(iv)
           if (sup_class_value = instance_variable_get(iv)) && dup
             sup_class_value = case dup
             when :dup
@@ -1116,7 +1122,7 @@ module Sequel
         when nil
           return false
         when Array
-          return false if pk.any?(&:nil?)
+          return false if pkv.any?(&:nil?)
         end
 
         (obj.class == model) && (obj.pk == pkv)
@@ -2232,7 +2238,9 @@ module Sequel
     plugin self
 
     singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
+    # :nocov:
     if RUBY_VERSION >= '1.9.3'
+    # :nocov:
       singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
     end
   end

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
 
@@ -149,9 +150,8 @@ module Sequel
       required_args = arity
       arity -= 1 if keyword == :required
 
-      if callable.is_a?(Proc) && !callable.lambda?
-        optional_args -= arity
-      end
+      # callable currently is always a non-lambda Proc
+      optional_args -= arity
 
       [required_args, optional_args, rest, keyword]
     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,9 +71,11 @@ module Sequel
 
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_methods(opts)
+          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){_association_pks_getter(opts)}
+          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"
@@ -84,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
@@ -95,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(*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
-              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select_map(rk)
+              public_send(dataset_method).map(rk)
             end
           end
 
@@ -145,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]
@@ -207,12 +238,22 @@ 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
            # pks_getter_method is private
             send(opts[:pks_getter_method])
@@ -254,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