sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/pg_row.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The pg_row plugin allows you to use Sequel::Model classes as composite type
@@ -39,64 +41,21 @@ module Sequel
     #
     #   Address.register_row_type
     #
-    # Note that automatic conversion only works with the native postgres adapter.
-    # For other adapters that connect to PostgreSQL, you need to call the conversion
-    # proc manually.
-    #
     # In addition to returning row-valued/composite types as instances of Sequel::Model,
     # this also lets you use model instances in datasets when inserting, updating, and
     # filtering:
     #
-    #   DB[:company].insert(:name=>'MS', :address=>
-    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345'))
+    #   DB[:company].insert(name: 'MS', address:
+    #     Address.load(street: '123 Foo St', city: 'Bar Town', zip: '12345'))
     module PgRow
       # When loading the extension, make sure the database has the pg_row extension
       # loaded, load the custom database extensions, and automatically register the
       # row type if the model has a dataset.
       def self.configure(model)
-        model.db.extension(:pg_row)
-        model.db.extend(DatabaseMethods)
+        model.db.extension(:pg_row, :_model_pg_row)
         model.register_row_type if model.instance_variable_get(:@dataset)
       end
 
-      module DatabaseMethods
-        ESCAPE_RE = /("|\\)/.freeze
-        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
-        COMMA = ','
-
-        # Handle Sequel::Model instances in bound variables.
-        def bound_variable_arg(arg, conn)
-          case arg
-          when Sequel::Model
-            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
-          else
-            super
-          end
-        end
-
-        # If a Sequel::Model instance is given, return it as-is
-        # instead of attempting to convert it.
-        def row_type(db_type, v)
-          if v.is_a?(Sequel::Model)
-            v
-          else
-            super
-          end
-        end
-
-        private
-
-        # Handle Sequel::Model instances in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when Sequel::Model
-            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
-          else
-            super
-          end
-        end
-      end
-
       module ClassMethods
         # Register the model's row type with the database.
         def register_row_type
@@ -107,14 +66,11 @@ module Sequel
       end
 
       module InstanceMethods
-        ROW = 'ROW'.freeze
-        CAST = '::'.freeze
-
         # Literalize the model instance and append it to the sql.
         def sql_literal_append(ds, sql)
-          sql << ROW
+          sql << 'ROW'
           ds.literal_append(sql, values.values_at(*columns))
-          sql << CAST
+          sql << '::'
           ds.quote_schema_table_append(sql, model.dataset.first_source_table)
         end
       end

data/lib/sequel/plugins/prepared_statements.rb

@@ -1,24 +1,13 @@
-module Sequel
-  class Model
-    module InstanceMethods
-      # Whether prepared statements should be used for the given type of query
-      # (:insert, :insert_select, :refresh, :update, or :delete).  True by default,
-      # can be overridden in other plugins to disallow prepared statements for
-      # specific types of queries.
-      def use_prepared_statements_for?(type)
-        true
-      end
-    end
-  end
+# frozen-string-literal: true
 
+module Sequel
   module Plugins
     # The prepared_statements plugin modifies the model to use prepared statements for
-    # instance level deletes and saves, as well as class level lookups by
-    # primary key.
+    # instance level inserts and updates.
     #
     # Note that this plugin is unsafe in some circumstances, as it can allow up to
     # 2^N prepared statements to be created for each type of insert and update query, where
-    # N is the number of colums in the table. It is recommended that you use the
+    # N is the number of columns in the table. It is recommended that you use the
     # +prepared_statements_safe+ plugin in addition to this plugin to reduce the number
     # of prepared statements that can be created, unless you tightly control how your
     # model instances are saved.
@@ -41,22 +30,20 @@ module Sequel
 
       # Setup the datastructure used to hold the prepared statements in the model.
       def self.apply(model)
-        model.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{})
+        model.instance_variable_set(:@prepared_statements, {:insert=>{}, :insert_select=>{}, :update=>{}}.freeze)
       end
 
       module ClassMethods
-        Plugins.inherited_instance_variables(self, :@prepared_statements=>lambda{|v| {:insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{}}})
+        Plugins.inherited_instance_variables(self, :@prepared_statements=>lambda{|v| {:insert=>{}, :insert_select=>{}, :update=>{}}.freeze})
 
         private
 
         # Create a prepared statement, but modify the SQL used so that the model's columns are explicitly
         # selected instead of using *, assuming that the dataset selects from a single table.
         def prepare_explicit_statement(ds, type, vals=OPTS)
-          f = ds.opts[:from]
-          meth = type == :insert_select ? :returning : :select
-          s = ds.opts[meth]
-          if f && f.length == 1 && !ds.opts[:join] && (!s || s.empty?)
-            ds = ds.send(meth, *columns.map{|c| Sequel.identifier(c)})
+          s = ds.opts[:returning]
+          if !s || s.empty?
+            ds = ds.returning(*columns.map{|c| Sequel.identifier(c)})
           end 
           
           prepare_statement(ds, type, vals)
@@ -65,19 +52,12 @@ module Sequel
         # Create a prepared statement based on the given dataset with a unique name for the given
         # type of query and values.
         def prepare_statement(ds, type, vals=OPTS)
-          ps = ds.prepare(type, :"smpsp_#{NEXT.call}", vals)
-          ps.log_sql = true
-          ps
+          ds.clone(:log_sql=>true).prepare(type, :"smpsp_#{NEXT.call}", vals)
         end
 
         # Return a sorted array of columns for use as a hash key.
         def prepared_columns(cols)
-          RUBY_VERSION >= '1.9' ? cols.sort : cols.sort_by(&:to_s)
-        end
-
-        # Return a prepared statement that can be used to delete a row from this model's dataset.
-        def prepared_delete
-          cached_prepared_statement(:fixed, :delete){prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)}
+          cols.sort
         end
 
         # Return a prepared statement that can be used to insert a row using the given columns.
@@ -88,19 +68,7 @@ module Sequel
         # Return a prepared statement that can be used to insert a row using the given columns
         # and return that column values for the row created.
         def prepared_insert_select(cols)
-          if dataset.supports_insert_select?
-            cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
-          end
-        end
-
-        # Return a prepared statement that can be used to lookup a row solely based on the primary key.
-        def prepared_lookup
-          cached_prepared_statement(:fixed, :lookup){prepare_explicit_statement(filter(prepared_statement_key_array(primary_key)), :first)}
-        end
-
-        # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
-        def prepared_refresh
-          cached_prepared_statement(:fixed, :refresh){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(prepared_statement_key_array(primary_key)), :first)}
+          cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
         end
 
         # Return an array of two element arrays with the column symbol as the first entry and the
@@ -127,12 +95,7 @@ module Sequel
 
         # Return a prepared statement that can be used to update row using the given columns.
         def prepared_update(cols)
-          cached_prepared_statement(:update, prepared_columns(cols)){prepare_statement(filter(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))}
-        end
-
-        # Use a prepared statement to query the database for the row matching the given primary key.
-        def primary_key_lookup(pk)
-          prepared_lookup.call(primary_key_hash(pk))
+          cached_prepared_statement(:update, prepared_columns(cols)){prepare_statement(where(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))}
         end
 
         # If a prepared statement has already been cached for the given type and subtype,
@@ -147,24 +110,21 @@ module Sequel
           ps = yield
           Sequel.synchronize{h[subtype] = ps}
         end
+
+        # Whether to use prepared statements for lookups by primary key.  True if the default
+        # primary key lookup isn't optimized.
+        def use_prepared_statements_for_pk_lookup?
+          !@fast_pk_lookup_sql && !dataset.joined_dataset?
+        end
       end
 
       module InstanceMethods
         private
 
-        # Use a prepared statement to delete the row.
-        def _delete_without_checking
-          if use_prepared_statements_for?(:delete)
-            model.send(:prepared_delete).call(pk_hash)
-          else
-            super
-          end
-        end
-
         # Use a prepared statement to insert the values into the model's dataset.
         def _insert_raw(ds)
           if use_prepared_statements_for?(:insert)
-            model.send(:prepared_insert, @values.keys).call(@values)
+            _set_prepared_statement_server(model.send(:prepared_insert, @values.keys)).call(@values)
           else
             super
           end
@@ -174,29 +134,50 @@ module Sequel
         # and return the new column values.
         def _insert_select_raw(ds)
           if use_prepared_statements_for?(:insert_select)
-            if ps = model.send(:prepared_insert_select, @values.keys)
-              ps.call(@values)
-            end
+            _set_prepared_statement_server(model.send(:prepared_insert_select, @values.keys)).call(@values)
           else
             super
           end
         end
 
-        # Use a prepared statement to refresh this model's column values.
-        def _refresh_get(ds)
-          if use_prepared_statements_for?(:refresh)
-            model.send(:prepared_refresh).call(pk_hash)
+        # Use a prepared statement to update this model's columns in the database.
+        def _update_without_checking(columns)
+          if use_prepared_statements_for?(:update)
+            _set_prepared_statement_server(model.send(:prepared_update, columns.keys)).call(columns.merge(pk_hash))
           else
             super
           end
         end
 
-        # Use a prepared statement to update this model's columns in the database.
-        def _update_without_checking(columns)
-          if use_prepared_statements_for?(:update)
-            model.send(:prepared_update, columns.keys).call(Hash[columns].merge!(pk_hash))
+        # If a server is set for the instance, return a prepared statement that will use that server.
+        def _set_prepared_statement_server(ps)
+          if @server
+            ps.server(@server)
           else
-            super
+            ps
+          end
+        end
+
+        # Whether prepared statements should be used for the given type of query
+        # (:insert, :insert_select, :update).  True by default,
+        # can be overridden in other plugins to disallow prepared statements for
+        # specific types of queries.
+        def use_prepared_statements_for?(type)
+          if defined?(super)
+            result = super
+            return result unless result.nil?
+          end
+
+          case type
+          when :insert, :insert_select, :update
+            true
+          # :nocov:
+          when :delete, :refresh
+            Sequel::Deprecation.deprecate("The :delete and :refresh prepared statement types", "There should be no need to check if these types are supported")
+            false
+          # :nocov:
+          else
+            raise Error, "unsupported type used: #{type.inspect}"
           end
         end
       end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The prepared_statements_safe plugin modifies the model to reduce the number of
@@ -26,7 +28,7 @@ module Sequel
       end
 
       module ClassMethods
-        # A hash with column symbol keys and default values.  Instance's
+        # A hash with column symbol keys and default values.  Instance
         # values are merged into this hash before creating to reduce the
         # number of free columns (columns that may or may not be present
         # in the INSERT statement), as the number of prepared statements
@@ -36,6 +38,13 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@prepared_statements_column_defaults=>:dup)
         Plugins.after_set_dataset(self, :set_prepared_statements_column_defaults)
 
+        # Freeze the prepared statements column defaults when freezing the model class.
+        def freeze
+          @prepared_statements_column_defaults.freeze if @prepared_statements_column_defaults
+
+          super
+        end
+
         private
 
         # Set the column defaults based on the database schema.  All columns
@@ -45,7 +54,8 @@ module Sequel
           if db_schema
             h = {}
             db_schema.each do |k, v|
-              h[k] = v[:ruby_default] if (v[:ruby_default] || !v[:default]) && !v[:primary_key]
+              default = v[:ruby_default]
+              h[k] = default if (default || !v[:default]) && !v[:primary_key] && !default.is_a?(Sequel::SQL::Expression)
             end
             @prepared_statements_column_defaults = h
           end
@@ -56,9 +66,7 @@ module Sequel
         # Merge the current values into the default values to reduce the number
         # of free columns.
         def before_create
-          if v = model.prepared_statements_column_defaults
-            @values = Hash[v].merge!(values)
-          end
+          @values = model.prepared_statements_column_defaults.merge(@values)
           super
         end
 

data/lib/sequel/plugins/rcte_tree.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # = Overview
@@ -10,26 +12,6 @@ module Sequel
     # level (where level 1 is children, level 2 is children and grandchildren
     # etc.) in a single query.
     #
-    # = Background
-    # 
-    # There are two types of common models for storing tree structured data
-    # in an SQL database, the adjacency list model and the nested set model.
-    # Before recursive common table expressions (or similar capabilities such
-    # as CONNECT BY for Oracle), the nested set model was the only easy way
-    # to retrieve all ancestors and descendants in a single query.  However,
-    # it has significant performance corner cases.
-    #
-    # On PostgreSQL 8.4, with a significant number of rows, the nested set
-    # model is almost 500 times slower than using a recursive common table
-    # expression with the adjacency list model to get all descendants, and
-    # almost 24,000 times slower to get all descendants to a given level.
-    #
-    # Considering that the nested set model requires more difficult management
-    # than the adjacency list model, it's almost always better to use the
-    # adjacency list model if your database supports common table expressions.
-    # See http://explainextended.com/2009/09/24/adjacency-list-vs-nested-sets-postgresql/
-    # for detailed analysis.
-    #
     # = Usage
     #
     # The rcte_tree plugin adds four associations to the model: parent, children, ancestors, and
@@ -54,12 +36,12 @@ module Sequel
     #   
     #   # Eager loading - also populates the :parent and children associations
     #   # for all ancestors and descendants
-    #   Model.filter(:id=>[1, 2]).eager(:ancestors, :descendants).all
+    #   Model.where(id: [1, 2]).eager(:ancestors, :descendants).all
     #   
-    #   # Eager loading children and grand children
-    #   Model.filter(:id=>[1, 2]).eager(:descendants=>2).all
-    #   # Eager loading children, grand children, and great grand children
-    #   Model.filter(:id=>[1, 2]).eager(:descendants=>3).all
+    #   # Eager loading children and grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 2).all
+    #   # Eager loading children, grandchildren, and great grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 3).all
     #
     # = Options
     #
@@ -74,8 +56,8 @@ module Sequel
     # Note that you can change the name of the above associations by specifying
     # a :name key in the appropriate hash of options above.  For example:
     #
-    #   Model.plugin :rcte_tree, :parent=>{:name=>:mother},
-    #    :children=>{:name=>:daughters}, :descendants=>{:name=>:offspring}
+    #   Model.plugin :rcte_tree, parent: {name: :mother},
+    #    children: {name: :daughters}, descendants: {name: :offspring}
     #
     # Any other keys in the main options hash are treated as options shared by
     # all of the associations.  Here's a few options that affect the plugin:
@@ -123,7 +105,6 @@ module Sequel
           key_present = lambda{|m| key_conv[m].all?}
           prkey_conv = lambda{|m| prkey_array.map{|k| m[k]}}
           key_aliases = (0...key_array.length).map{|i| :"#{ka}_#{i}"}
-          ka_conv = lambda{|m| key_aliases.map{|k| m[k]}}
           ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
@@ -132,27 +113,29 @@ module Sequel
           key_present = key_conv = lambda{|m| m[key]}
           prkey_conv = lambda{|m| m[prkey]}
           key_aliases = [ka]
-          ka_conv = lambda{|m| m[ka]}
           ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
           descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
           recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
           extract_key_alias = lambda{|m| bd_conv[m.values.delete(ka)]}
         end
         
-        parent = opts.merge(opts.fetch(:parent, {})).fetch(:name, :parent)
-        childrena = opts.merge(opts.fetch(:children, {})).fetch(:name, :children)
+        parent = opts.merge(opts.fetch(:parent, OPTS)).fetch(:name, :parent)
+        childrena = opts.merge(opts.fetch(:children, OPTS)).fetch(:name, :children)
         
         opts[:reciprocal] = nil
-        a = opts.merge(opts.fetch(:ancestors, {}))
+        a = opts.merge(opts.fetch(:ancestors, OPTS))
         ancestors = a.fetch(:name, :ancestors)
         a[:read_only] = true unless a.has_key?(:read_only)
+        a[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{ancestors} association for #{self} does not support eager graphing"
+        end
         a[:eager_loader_key] = key
         a[:dataset] ||= proc do
-          base_ds = model.filter(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
+          base_ds = model.where(prkey_array.zip(key_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, key_array.zip(prkey_array))
           if c = a[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -194,13 +177,13 @@ module Sequel
             obj.associations[parent] = nil
           end
           r = model.association_reflection(ancestors)
-          base_case = model.filter(prkey=>id_map.keys).
+          base_case = model.where(prkey=>id_map.keys).
            select(*ancestor_base_case_columns)
           recursive_case = model.join(t, key_array.zip(prkey_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -209,23 +192,19 @@ module Sequel
              :args=>((key_aliases + col_aliases) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[parent] = nil
               parent_map[opk] = obj
               (children_map[key_conv[obj]] ||= []) << obj
             end
             
-            if roots = id_map[extract_key_alias[obj]]
-              roots.each do |root|
-                root.associations[ancestors] << obj
-              end
+            id_map[extract_key_alias[obj]].each do |root|
+              root.associations[ancestors] << obj
             end
           end
           parent_map.each do |parent_id, obj|
@@ -238,16 +217,19 @@ module Sequel
         end
         model.one_to_many ancestors, a
         
-        d = opts.merge(opts.fetch(:descendants, {}))
+        d = opts.merge(opts.fetch(:descendants, OPTS))
         descendants = d.fetch(:name, :descendants)
         d[:read_only] = true unless d.has_key?(:read_only)
+        d[:eager_grapher] = proc do |_|
+          raise Sequel::Error, "the #{descendants} association for #{self} does not support eager graphing"
+        end
         la = d[:level_alias] ||= :x_level_x
         d[:dataset] ||= proc do
-          base_ds = model.filter(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
+          base_ds = model.where(key_array.zip(prkey_array.map{|k| get_column_value(k)}))
           recursive_ds = model.join(t, prkey_array.zip(key_array))
           if c = d[:conditions]
-            (base_ds, recursive_ds) = [base_ds, recursive_ds].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_ds, recursive_ds) = [base_ds, recursive_ds].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
@@ -292,21 +274,21 @@ module Sequel
             obj.associations[childrena] = []
           end
           r = model.association_reflection(descendants)
-          base_case = model.filter(key=>id_map.keys).
+          base_case = model.where(key=>id_map.keys).
            select(*descendant_base_case_columns)
           recursive_case = model.join(t, prkey_array.zip(key_array)).
            select(*recursive_case_columns)
           if c = r[:conditions]
-            (base_case, recursive_case) = [base_case, recursive_case].collect do |ds|
-              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.filter(*c) : ds.filter(c)
+            (base_case, recursive_case) = [base_case, recursive_case].map do |ds|
+              (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
             end
           end
           if associations.is_a?(Integer)
             level = associations
             no_cache_level = level - 1
             associations = {}
-            base_case = base_case.select_more(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
-            recursive_case = recursive_case.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).filter(SQL::QualifiedIdentifier.new(t, la) < level - 1)
+            base_case = base_case.select_append(SQL::AliasedExpression.new(Sequel.cast(0, Integer), la))
+            recursive_case = recursive_case.select_append(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, la) + 1, la)).where(SQL::QualifiedIdentifier.new(t, la) < level - 1)
           end
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
@@ -314,17 +296,15 @@ module Sequel
               :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases))
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
-          model.eager_load_results(r, eo.merge(:loader=>false, :initalize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>{})) do |obj|
+          model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
             if level
               no_cache = no_cache_level == obj.values.delete(la)
             end
             
             opk = prkey_conv[obj]
-            if parent_map.has_key?(opk)
-              if idm_obj = parent_map[opk]
-                key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
-                obj = idm_obj
-              end
+            if idm_obj = parent_map[opk]
+              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              obj = idm_obj
             else
               obj.associations[childrena] = [] unless no_cache
               parent_map[opk] = obj