sequel 4.9.0 → 4.10.0

data/lib/sequel/model/base.rb

@@ -399,28 +399,59 @@ module Sequel
         end
 
         type = opts.fetch(:type, :first)
-        raise Error, ":type option to Model.finder must be :first, :all, :each, or :get" unless FINDER_TYPES.include?(type)
+        unless prepare = opts[:prepare]
+          raise Error, ":type option to Model.finder must be :first, :all, :each, or :get" unless FINDER_TYPES.include?(type)
+        end
         limit1 = type == :first || type == :get
         meth_name ||= opts[:name] || :"#{type}_#{meth}"
 
-        loader_proc = proc do |model|
-          unless block
-            argn = opts[:arity]
-            block =  lambda do |pl, model2|
-              method = model2.method(meth)
-              argn ||= (method.arity < 0 ? method.arity.abs - 1 : method.arity)
-              args = (0...argn).map{pl.arg}
-              ds = method.call(*args)
+        argn = lambda do |model|
+          if arity = opts[:arity]
+            arity
+          else
+            method = block || model.method(meth)
+            (method.arity < 0 ? method.arity.abs - 1 : method.arity)
+          end
+        end
+
+        loader_proc = if prepare
+          proc do |model|
+            args = prepare_method_args('$a', argn.call(model))
+            ds = if block
+              model.instance_exec(*args, &block)
+            else
+              model.send(meth, *args)
+            end
+            ds = ds.limit(1) if limit1
+            model_name = model.name
+            if model_name.to_s.empty?
+              model_name = model.object_id
+            else
+              model_name = model_name.gsub(/\W/, '_')
+            end
+            ds.prepare(type, :"#{model_name}_#{meth_name}")
+          end
+        else
+          proc do |model|
+            n = argn.call(model)
+            block ||= lambda do |pl, model2|
+              args = (0...n).map{pl.arg}
+              ds = model2.send(meth, *args)
               ds = ds.limit(1) if limit1
               ds
             end
-          end
 
-          Sequel::Dataset::PlaceholderLiteralizer.loader(model, &block) 
+            Sequel::Dataset::PlaceholderLiteralizer.loader(model, &block) 
+          end
         end
+
         Sequel.synchronize{@finder_loaders[meth_name] = loader_proc}
         mod = opts[:mod] || (class << self; self; end)
-        def_finder_method(mod, meth_name, type)
+        if prepare
+          def_prepare_method(mod, meth_name)
+        else
+          def_finder_method(mod, meth_name, type)
+        end
       end
 
       # An alias for calling first on the model's dataset, but with
@@ -442,7 +473,7 @@ module Sequel
 
       # Clear the setter_methods cache when a module is included, as it
       # may contain setter methods.
-      def include(mod)
+      def include(*mods)
         clear_setter_methods_cache
         super
       end
@@ -573,6 +604,27 @@ module Sequel
         h
       end
   
+      # Similar to finder, but uses a prepared statement instead of a placeholder
+      # literalizer. This makes the SQL used static (cannot vary per call), but
+      # allows binding argument values instead of literalizing them into the SQL
+      # query string.
+      #
+      # If a block is used with this method, it is instance_execed by the model,
+      # and should accept the desired number of placeholder arguments.
+      #
+      # The options are the same as the options for finder, with the following
+      # exception:
+      # :type :: Specifies the type of prepared statement to create
+      def prepared_finder(meth=OPTS, opts=OPTS, &block)
+        if block
+          raise Error, "cannot pass both a method name argument and a block of Model.finder" unless meth.is_a?(Hash)
+          meth = meth.merge(:prepare=>true)
+        else
+          opts = opts.merge(:prepare=>true)
+        end
+        finder(meth, opts, &block)
+      end
+
       # Restrict the setting of the primary key(s) when using mass assignment (e.g. +set+).  Because
       # this is the default, this only make sense to use in a subclass where the
       # parent class has used +unrestrict_primary_key+.
@@ -818,6 +870,12 @@ module Sequel
         mod.send(:define_method, meth){|*args, &block| finder_for(meth).send(type, *args, &block)}
       end
 
+      # Define a prepared_finder method in the given module that will call the associated prepared
+      # statement.
+      def def_prepare_method(mod, meth)
+        mod.send(:define_method, meth){|*args, &block| finder_for(meth).call(prepare_method_arg_hash(args), &block)}
+      end
+
       # Find the finder to use for the give method.  If a finder has not been loaded
       # for the method, load the finder and set correctly in the finders hash, then
       # return the finder.
@@ -948,6 +1006,23 @@ module Sequel
         end
       end
   
+      # An hash of prepared argument values for the given arguments, with keys
+      # starting at a.  Used by the methods created by prepared_finder.
+      def prepare_method_arg_hash(args)
+        h = {}
+        prepare_method_args('a', args.length).zip(args).each{|k, v| h[k] = v}
+        h
+      end
+
+      # An array of prepared statement argument names, of length n and starting with base.
+      def prepare_method_args(base, n)
+        (0...n).map do
+          s = base.to_sym
+          base = base.next
+          s
+        end
+      end
+
       # Find the row in the dataset that matches the primary key.  Uses
       # a static SQL optimization if the table and primary key are simple.
       #

data/lib/sequel/plugins/association_pks.rb

@@ -49,85 +49,44 @@ module Sequel
         # a setter that deletes from or inserts into the join table.
         def def_many_to_many(opts)
           super
+
+          return if opts[:type] == :one_through_one
+
           # Grab values from the reflection so that the hash lookup only needs to be
           # done once instead of inside ever method call.
           lk, lpk, rk = opts.values_at(:left_key, :left_primary_key, :right_key)
+          clpk = lpk.is_a?(Array)
+          crk = rk.is_a?(Array)
 
-          # Add 2 separate implementations of the getter method optimized for the
-          # composite and singular left key cases, and 4 separate implementations of the setter
-          # method optimized for each combination of composite and singular keys for both
-          # the left and right keys.
-          if lpk.is_a?(Array)
+          if clpk
             def_association_pks_getter(opts) do
               h = {}
               lk.zip(lpk).each{|k, pk| h[k] = send(pk)}
               _join_table_dataset(opts).filter(h).select_map(rk)
             end
-
-            if rk.is_a?(Array)
-              def_association_pks_setter(opts) do |pks|
-                pks = convert_cpk_array(opts, pks)
-                checked_transaction do
-                  lpkv = lpk.map{|k| send(k)}
-                  ds = _join_table_dataset(opts).filter(lk.zip(lpkv))
-                  ds.exclude(rk=>pks).delete
-                  pks -= ds.select_map(rk)
-                  h = {}
-                  lk.zip(lpkv).each{|k, v| h[k] = v}
-                  pks.each do |pk|
-                    ih = h.dup
-                    rk.zip(pk).each{|k, v| ih[k] = v}
-                    ds.insert(ih)
-                  end
-                end
-              end
-            else
-              def_association_pks_setter(opts) do |pks|
-                pks = convert_pk_array(opts, pks)
-                checked_transaction do
-                  lpkv = lpk.map{|k| send(k)}
-                  ds = _join_table_dataset(opts).filter(lk.zip(lpkv))
-                  ds.exclude(rk=>pks).delete
-                  pks -= ds.select_map(rk)
-                  h = {}
-                  lk.zip(lpkv).each{|k, v| h[k] = v}
-                  pks.each do |pk|
-                    ds.insert(h.merge(rk=>pk))
-                  end
-                end
-              end
-            end
           else
             def_association_pks_getter(opts) do
               _join_table_dataset(opts).filter(lk=>send(lpk)).select_map(rk)
             end
+          end
 
-            if rk.is_a?(Array)
-              def_association_pks_setter(opts) do |pks|
-                pks = convert_cpk_array(opts, pks)
-                checked_transaction do
-                  lpkv = send(lpk)
-                  ds = _join_table_dataset(opts).filter(lk=>lpkv)
-                  ds.exclude(rk=>pks).delete
-                  pks -= ds.select_map(rk)
-                  pks.each do |pk|
-                    h = {lk=>lpkv}
-                    rk.zip(pk).each{|k, v| h[k] = v}
-                    ds.insert(h)
-                  end
-                end
-              end
-            else
-              def_association_pks_setter(opts) do |pks|
-                pks = convert_pk_array(opts, pks)
-                checked_transaction do
-                  lpkv = send(lpk)
-                  ds = _join_table_dataset(opts).filter(lk=>lpkv)
-                  ds.exclude(rk=>pks).delete
-                  pks -= ds.select_map(rk)
-                  pks.each{|pk| ds.insert(lk=>lpkv, rk=>pk)}
-                end
+          def_association_pks_setter(opts) do |pks|
+            pks = send(crk ? :convert_cpk_array : :convert_pk_array, opts, pks)
+            checked_transaction do
+              if clpk
+                lpkv = lpk.map{|k| send(k)}
+                cond = lk.zip(lpkv)
+              else
+                lpkv = send(lpk)
+                cond = {lk=>lpkv}
               end
+              ds = _join_table_dataset(opts).filter(cond)
+              ds.exclude(rk=>pks).delete
+              pks -= ds.select_map(rk)
+              lpkv = Array(lpkv)
+              key_array = crk ? pks.map{|pk| lpkv + pk} : pks.map{|pk| lpkv + [pk]}
+              key_columns = Array(lk) + Array(rk)
+              ds.import(key_columns, key_array)
             end
           end
         end

data/lib/sequel/plugins/auto_validations.rb

@@ -107,8 +107,9 @@ module Sequel
           @auto_validate_not_null_columns = not_null_cols - Array(primary_key)
           explicit_not_null_cols += Array(primary_key)
           @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
-          @auto_validate_unique_columns = if db.supports_index_parsing?
-            db.indexes(dataset.first_source_table).select{|name, idx| idx[:unique] == true}.map{|name, idx| idx[:columns]}
+          table = dataset.first_source_table
+          @auto_validate_unique_columns = if db.supports_index_parsing? && [Symbol, SQL::QualifiedIdentifier, SQL::Identifier, String].any?{|c| table.is_a?(c)}
+            db.indexes(table).select{|name, idx| idx[:unique] == true}.map{|name, idx| idx[:columns]}
           else
             []
           end

data/lib/sequel/plugins/dataset_associations.rb

@@ -99,9 +99,7 @@ module Sequel
           else
             raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
           end
-          ds = model.apply_association_dataset_opts(r, ds)
-          r[:extend].each{|m| ds.extend(m)}
-          ds
+          r.apply_eager_dataset_changes(ds).unlimited
         end
       end
     end

data/lib/sequel/plugins/many_through_many.rb

@@ -101,6 +101,11 @@ module Sequel
           END
         end
 
+        # The alias for the first join table.
+        def join_table_alias
+          final_reverse_edge[:alias]
+        end
+
         # Many through many associations don't have a reciprocal
         def reciprocal
           nil
@@ -108,6 +113,13 @@ module Sequel
 
         private
 
+        def _associated_dataset
+          ds = associated_class
+          reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
+          ft = final_reverse_edge
+          ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep)
+        end
+
         # Make sure to use unique table aliases when lazy loading or eager loading
         def calculate_reverse_edge_aliases(reverse_edges)
           aliases = [associated_class.table_name]
@@ -156,26 +168,10 @@ module Sequel
           h
         end
 
-        def filter_by_associations_add_conditions_dataset_filter(ds)
-          reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
-          ft = final_reverse_edge
-          k = qualify(ft[:alias], Array(self[:left_key]))
-          ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep).
-            where(Sequel.negate(k.zip([]))).
-            select(*k)
-        end
-
         def filter_by_associations_limit_key
           fe = edges.first
           Array(qualify(fe[:table], fe[:right])) + Array(qualify(associated_class.table_name, associated_class.primary_key))
         end
-
-        def filter_by_associations_limit_subquery
-          subquery = associated_eager_dataset.unlimited
-          reverse_edges.each{|t| subquery = subquery.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
-          ft = final_reverse_edge
-          subquery.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])), :table_alias=>ft[:alias], :qualify=>:deep)
-        end
       end
 
       class OneThroughManyAssociationReflection < ManyThroughManyAssociationReflection
@@ -214,8 +210,6 @@ module Sequel
         # Create the association methods and :eager_loader and :eager_grapher procs.
         def def_many_through_many(opts)
           one_through_many = opts[:type] == :one_through_many
-          name = opts[:name]
-          model = self
           opts[:read_only] = true
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
           opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
@@ -233,56 +227,17 @@ module Sequel
           end
 
           left_key = opts[:left_key] = opts[:through].first[:left]
-          uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
-          left_keys = Array(left_key)
+          opts[:left_keys] = Array(left_key)
+          opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
           opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
-          left_pks = opts[:left_primary_keys] = Array(left_pk)
+          opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
           lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
-          opts[:dataset] ||= lambda do
-            ds = opts.associated_dataset
-            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
-            ft = opts.final_reverse_edge
-            ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + opts.predicate_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias], :qualify=>:deep)
-          end
-
-          slice_range = opts.slice_range
-          left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
-          opts[:eager_loader] ||= lambda do |eo|
-            h = eo[:id_map]
-            rows = eo[:rows]
-            ds = opts.associated_class 
-            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
-            ft = opts.final_reverse_edge
-
-            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + [[opts.predicate_key, h.keys]], :table_alias=>ft[:alias], :qualify=>:deep)
-            ds = model.eager_loading_dataset(opts, ds, nil, eo[:associations], eo)
-            ds = opts.apply_eager_limit_strategy(ds)
-            opts.initialize_association_cache(rows)
+          opts[:dataset] ||= opts.association_dataset_proc
 
-            assign_singular = opts.assign_singular?
-            delete_rn = opts.delete_row_number_column(ds)
-            ds.all do |assoc_record|
-              assoc_record.values.delete(delete_rn) if delete_rn
-              hash_key = if uses_lcks
-                left_key_alias.map{|k| assoc_record.values.delete(k)}
-              else
-                assoc_record.values.delete(left_key_alias)
-              end
-              next unless objects = h[hash_key]
-              if assign_singular
-                objects.each do |object|
-                  object.associations[name] ||= assoc_record
-                end
-              else
-                objects.each do |object|
-                  object.associations[name].push(assoc_record)
-                end
-              end
-            end
-            opts.apply_ruby_eager_limit_strategy(rows)
-          end
+          opts[:left_key_alias] ||= opts.default_associated_key_alias
+          opts[:eager_loader] ||= opts.method(:default_eager_loader)
 
           join_type = opts[:graph_join_type]
           select = opts[:graph_select]
@@ -313,8 +268,6 @@ module Sequel
               ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, &graph_block)
             end
           end
-
-          def_association_dataset_methods(opts)
         end
 
         # Use def_many_through_many, since they share pretty much the same code.

data/lib/sequel/plugins/pg_array_associations.rb

@@ -47,11 +47,9 @@ module Sequel
     #
     # They support some additional options specific to this plugin:
     #
-    # :array_type :: This allows you to specify the type of the array.  This
-    #                is only necessary to set in very narrow circumstances,
-    #                such as when this plugin needs to create an array type,
-    #                and typecasting is turned off or not setup correctly
-    #                for the model object.
+    # :array_type :: This overrides the type of the array.  By default, the type
+    #                is determined by looking at the db_schema for the model, and if that fails,
+    #                it defaults to :integer.
     # :raise_on_save_failure :: Do not raise exceptions for hook or validation failures when saving associated
     #                           objects in the add/remove methods (return nil instead).
     # :save_after_modify :: For pg_array_to_many associations, this makes the
@@ -77,6 +75,16 @@ module Sequel
       class ManyToPgArrayAssociationReflection < Sequel::Model::Associations::AssociationReflection
         Sequel::Model::Associations::ASSOCIATION_TYPES[:many_to_pg_array] = self
 
+        def array_type
+          cached_fetch(:array_type) do
+            if (sch = associated_class.db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
+              t
+            else
+              :integer
+            end
+          end
+        end
+
         # The array column in the associated model containing foreign keys to
         # the current model.
         def associated_object_keys
@@ -107,6 +115,11 @@ module Sequel
           end
         end
 
+        # Don't use a filter by associations limit strategy
+        def filter_by_associations_limit_strategy
+          nil
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false.
         def handle_silent_modification_failure?
           self[:raise_on_save_failure] == false
@@ -131,6 +144,11 @@ module Sequel
     
         private
     
+        # The predicate condition to use for the eager_loader.
+        def eager_loading_predicate_condition(keys)
+          Sequel.pg_array_op(predicate_key).overlaps(Sequel.pg_array(keys, array_type))
+        end
+
         def filter_by_associations_add_conditions_dataset_filter(ds)
           key = qualify(associated_class.table_name, self[:key])
           ds.select{unnest(key)}.exclude(key=>nil)
@@ -149,12 +167,26 @@ module Sequel
         def reciprocal_type
           :pg_array_to_many
         end
+
+        def use_placeholder_loader?
+          false
+        end
       end
 
       # The AssociationReflection subclass for pg_array_to_many associations.
       class PgArrayToManyAssociationReflection < Sequel::Model::Associations::AssociationReflection
         Sequel::Model::Associations::ASSOCIATION_TYPES[:pg_array_to_many] = self
 
+        def array_type
+          cached_fetch(:array_type) do
+            if (sch = self[:model].db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
+              t
+            else
+              :integer
+            end
+          end
+        end
+
         # An array containing the primary key for the associated model.
         def associated_object_keys
           Array(primary_key)
@@ -190,6 +222,11 @@ module Sequel
           end
         end
 
+        # Don't use a filter by associations limit strategy
+        def filter_by_associations_limit_strategy
+          nil
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false
         # and save_after_modify is true.
         def handle_silent_modification_failure?
@@ -236,6 +273,10 @@ module Sequel
         def reciprocal_type
           :many_to_pg_array
         end
+
+        def use_placeholder_loader?
+          false
+        end
       end
 
       module ClassMethods
@@ -264,18 +305,13 @@ module Sequel
           key = opts[:key]
           key_column = opts[:key_column] ||= opts[:key]
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
-          slice_range = opts.slice_range
           opts[:dataset] ||= lambda do
-            opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains([send(pk)]))
+            opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains(Sequel.pg_array([send(pk)], opts.array_type)))
           end
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
-            rows = eo[:rows]
-            opts.initialize_association_cache(rows)
 
-            klass = opts.associated_class
-            ds = model.eager_loading_dataset(opts, klass.where(Sequel.pg_array_op(opts.predicate_key).overlaps(id_map.keys)), nil, eo[:associations], eo)
-            ds.all do |assoc_record|
+            eager_load_results(opts, eo.merge(:loader=>false)) do |assoc_record|
               if pks ||= assoc_record.send(key)
                 pks.each do |pkv|
                   next unless objects = id_map[pkv]
@@ -285,7 +321,6 @@ module Sequel
                 end
               end
             end
-            opts.apply_ruby_eager_limit_strategy(rows)
           end
 
           join_type = opts[:graph_join_type]
@@ -316,51 +351,40 @@ module Sequel
             ds
           end
 
-          def_association_dataset_methods(opts)
+          return if opts[:read_only]
 
-          unless opts[:read_only]
-            save_opts = {:validate=>opts[:validate]}
-            save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
+          save_opts = {:validate=>opts[:validate]}
+          save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
 
-            array_type = opts[:array_type] ||= :integer
-            adder = opts[:adder] || proc do |o|
-              if array = o.send(key)
-                array << send(pk)
-              else
-                o.send("#{key}=", Sequel.pg_array([send(pk)], array_type))
-              end
-              o.save(save_opts)
-            end
-            association_module_private_def(opts._add_method, opts, &adder)
-    
-            remover = opts[:remover] || proc do |o|
-              if (array = o.send(key)) && !array.empty?
-                array.delete(send(pk))
-                o.save(save_opts)
-              end
+          opts[:adder] ||= proc do |o|
+            if array = o.send(key)
+              array << send(pk)
+            else
+              o.send("#{key}=", Sequel.pg_array([send(pk)], opts.array_type))
             end
-            association_module_private_def(opts._remove_method, opts, &remover)
-
-            clearer = 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)))
+            o.save(save_opts)
+          end
+  
+          opts[:remover] ||= proc do |o|
+            if (array = o.send(key)) && !array.empty?
+              array.delete(send(pk))
+              o.save(save_opts)
             end
-            association_module_private_def(opts._remove_all_method, opts, &clearer)
+          end
 
-            def_add_method(opts)
-            def_remove_methods(opts)
+          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)))
           end
         end
 
         # Setup the pg_array_to_many-specific datasets, eager loaders, and modification methods.
         def def_pg_array_to_many(opts)
           name = opts[:name]
-          model = self
           opts[:key] = opts.default_key unless opts.has_key?(:key)
           key = opts[:key]
           key_column = opts[:key_column] ||= key
           opts[:eager_loader_key] = nil
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
-          slice_range = opts.slice_range
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(opts.predicate_key=>send(key).to_a)
           end
@@ -368,7 +392,6 @@ module Sequel
             rows = eo[:rows]
             id_map = {}
             pkm = opts.primary_key_method
-            opts.initialize_association_cache(rows)
 
             rows.each do |object|
               if associated_pks = object.send(key)
@@ -378,16 +401,13 @@ module Sequel
               end
             end
 
-            klass = opts.associated_class
-            ds = model.eager_loading_dataset(opts, klass.where(opts.predicate_key=>id_map.keys), nil, eo[:associations], eo)
-            ds.all do |assoc_record|
+            eager_load_results(opts, eo.merge(:id_map=>id_map)) do |assoc_record|
               if objects = id_map[assoc_record.send(pkm)]
                 objects.each do |object| 
                   object.associations[name].push(assoc_record)
                 end
               end
             end
-            opts.apply_ruby_eager_limit_strategy(rows)
           end
 
           join_type = opts[:graph_join_type]
@@ -418,51 +438,42 @@ module Sequel
             ds
           end
 
-          def_association_dataset_methods(opts)
+          return if opts[:read_only]
 
-          unless opts[:read_only]
-            save_opts = {:validate=>opts[:validate]}
-            save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
-            array_type = opts[:array_type] ||= :integer
+          save_opts = {:validate=>opts[:validate]}
+          save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
 
-            if opts[:save_after_modify]
-              save_after_modify = proc do |obj|
-                obj.save(save_opts)
-              end
+          if opts[:save_after_modify]
+            save_after_modify = proc do |obj|
+              obj.save(save_opts)
             end
+          end
 
-            adder = opts[:adder] || proc do |o|
-              opk = o.send(opts.primary_key) 
-              if array = send(key)
-                modified!(key)
-                array << opk
-              else
-                send("#{key}=", Sequel.pg_array([opk], array_type))
-              end
-              save_after_modify.call(self) if save_after_modify
+          opts[:adder] ||= proc do |o|
+            opk = o.send(opts.primary_key) 
+            if array = send(key)
+              modified!(key)
+              array << opk
+            else
+              send("#{key}=", Sequel.pg_array([opk], opts.array_type))
             end
-            association_module_private_def(opts._add_method, opts, &adder)
-    
-            remover = opts[:remover] || proc do |o|
-              if (array = send(key)) && !array.empty?
-                modified!(key)
-                array.delete(o.send(opts.primary_key))
-                save_after_modify.call(self) if save_after_modify
-              end
+            save_after_modify.call(self) if save_after_modify
+          end
+  
+          opts[:remover] ||= proc do |o|
+            if (array = send(key)) && !array.empty?
+              modified!(key)
+              array.delete(o.send(opts.primary_key))
+              save_after_modify.call(self) if save_after_modify
             end
-            association_module_private_def(opts._remove_method, opts, &remover)
+          end
 
-            clearer = opts[:clearer] || proc do
-              if (array = send(key)) && !array.empty?
-                modified!(key)
-                array.clear
-                save_after_modify.call(self) if save_after_modify
-              end
+          opts[:clearer] ||= proc do
+            if (array = send(key)) && !array.empty?
+              modified!(key)
+              array.clear
+              save_after_modify.call(self) if save_after_modify
             end
-            association_module_private_def(opts._remove_all_method, opts, &clearer)
-
-            def_add_method(opts)
-            def_remove_methods(opts)
           end
         end
       end
@@ -497,11 +508,11 @@ module Sequel
           expr = case obj
           when Sequel::Model
             if pkv = obj.send(ref.primary_key_method)
-              Sequel.pg_array_op(key).contains([pkv])
+              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?
-              Sequel.pg_array(key).overlaps(pkvs)
+              Sequel.pg_array(key).overlaps(Sequel.pg_array(pkvs, ref.array_type))
             end
           when Sequel::Dataset
             Sequel.function(:coalesce, Sequel.pg_array_op(key).overlaps(obj.select{array_agg(ref.qualify(obj.model.table_name, ref.primary_key))}), Sequel::SQL::Constants::FALSE)