sequel 3.27.0 → 3.28.0

data/lib/sequel/dataset/features.rb

@@ -6,9 +6,6 @@ module Sequel
     # dataset supports a feature.
     # ---------------------
     
-    # Method used to check if WITH is supported
-    WITH_SUPPORTED=:select_with_sql
-    
     # Whether this dataset quotes identifiers.
     def quote_identifiers?
       if defined?(@quote_identifiers)
@@ -34,11 +31,20 @@ module Sequel
     end
 
     # Whether the dataset supports common table expressions (the WITH clause).
-    def supports_cte?
-      select_clause_methods.include?(WITH_SUPPORTED)
+    # If given, +type+ can be :select, :insert, :update, or :delete, in which case it
+    # determines whether WITH is supported for the respective statement type.
+    def supports_cte?(type=:select)
+      send(:"#{type}_clause_methods").include?(:"#{type}_with_sql")
     end
 
-    # Whether the dataset supports the DISTINCT ON clause, false by default.
+    # Whether the dataset supports common table expressions (the WITH clause)
+    # in subqueries.  If false, applies the WITH clause to the main query, which can cause issues
+    # if multiple WITH clauses use the same name.
+    def supports_cte_in_subqueries?
+      false
+    end
+
+    # Whether the dataset supports or can emulate the DISTINCT ON clause, false by default.
     def supports_distinct_on?
       false
     end
@@ -46,7 +52,7 @@ module Sequel
     # Whether this dataset supports the +insert_select+ method for returning all columns values
     # directly from an insert query.
     def supports_insert_select?
-      false
+      supports_returning?(:insert)
     end
 
     # Whether the dataset supports the INTERSECT and EXCEPT compound operations, true by default.
@@ -79,7 +85,24 @@ module Sequel
     def supports_multiple_column_in?
       true
     end
+
+    # Whether the dataset supports or can fully emulate the DISTINCT ON clause,
+    # including respecting the ORDER BY clause, false by default
+    def supports_ordered_distinct_on?
+      supports_distinct_on?
+    end
     
+    # Whether the RETURNING clause is supported for the given type of query.
+    # +type+ can be :insert, :update, or :delete.
+    def supports_returning?(type)
+      send(:"#{type}_clause_methods").include?(:"#{type}_returning_sql")
+    end
+
+    # Whether the database supports SELECT *, column FROM table
+    def supports_select_all_and_column?
+      true
+    end
+
     # Whether the dataset supports timezones in literal timestamps
     def supports_timestamp_timezones?
       false
@@ -94,5 +117,19 @@ module Sequel
     def supports_window_functions?
       false
     end
+    
+    # Whether the dataset supports WHERE TRUE (or WHERE 1 for databases that
+    # that use 1 for true).
+    def supports_where_true?
+      true
+    end
+
+    private
+
+    # Whether the RETURNING clause is used for the given dataset.
+    # +type+ can be :insert, :update, or :delete.
+    def uses_returning?(type)
+      opts[:returning] && !@opts[:sql] && supports_returning?(type)
+    end
   end
 end

data/lib/sequel/dataset/misc.rb

@@ -140,7 +140,13 @@ module Sequel
       "#<#{self.class}: #{sql.inspect}>"
     end
     
-    # Splits a possible implicit alias in C, handling both SQL::AliasedExpressions
+    # The alias to use for the row_number column, used when emulating OFFSET
+    # support and for eager limit strategies
+    def row_number_column
+      :x_sequel_row_number_x
+    end
+
+    # Splits a possible implicit alias in +c+, handling both SQL::AliasedExpressions
     # and Symbols.  Returns an array of two elements, with the first being the
     # main expression, and the second being the alias.
     def split_alias(c)
@@ -150,6 +156,8 @@ module Sequel
         [c_table ? SQL::QualifiedIdentifier.new(c_table, column.to_sym) : column.to_sym, aliaz]
       when SQL::AliasedExpression
         [c.expression, c.aliaz]
+      when SQL::JoinClause
+        [c.table, c.table_alias]
       else
         [c, nil]
       end

data/lib/sequel/dataset/prepared_statements.rb

@@ -80,9 +80,9 @@ module Sequel
         when :select, :all
           select_sql
         when :first
-          clone(:limit=>1).select_sql
+          limit(1).select_sql
         when :insert_select
-          clone(:returning=>nil).insert_sql(*@prepared_modify_values)
+          returning.insert_sql(*@prepared_modify_values)
         when :insert
           insert_sql(*@prepared_modify_values)
         when :update

data/lib/sequel/dataset/query.rb

@@ -433,6 +433,11 @@ module Sequel
     #   # SELECT * FROM a NATURAL JOIN b INNER JOIN c
     #   #   ON ((c.d > b.e) AND (c.f IN (SELECT g FROM b)))
     def join_table(type, table, expr=nil, options={}, &block)
+      if table.is_a?(Dataset) && table.opts[:with] && !supports_cte_in_subqueries?
+        s, ds = hoist_cte(table)
+        return s.join_table(type, ds, expr, options, &block)
+      end
+
       using_join = expr.is_a?(Array) && !expr.empty? && expr.all?{|x| x.is_a?(Symbol)}
       if using_join && !supports_join_using?
         h = {}
@@ -653,6 +658,18 @@ module Sequel
       qualify_to(first_source)
     end
     
+    # Modify the RETURNING clause, only supported on a few databases.  If returning
+    # is used, instead of insert returning the autogenerated primary key or
+    # update/delete returning the number of modified rows, results are
+    # returned using +fetch_rows+.
+    #
+    #   DB[:items].returning # RETURNING *
+    #   DB[:items].returning(nil) # RETURNING NULL
+    #   DB[:items].returning(:id, :name) # RETURNING id, name
+    def returning(*values)
+      clone(:returning=>values)
+    end
+
     # Returns a copy of the dataset with the order reversed. If no order is
     # given, the existing order is inverted.
     #
@@ -695,7 +712,7 @@ module Sequel
       if tables.empty?
         clone(:select => nil)
       else
-        select(*tables.map{|t| SQL::ColumnAll.new(t)})
+        select(*tables.map{|t| i, a = split_alias(t); a || i}.map{|t| SQL::ColumnAll.new(t)})
       end
     end
     
@@ -708,7 +725,12 @@ module Sequel
     #   DB[:items].select_append(:b) # SELECT *, b FROM items
     def select_append(*columns, &block)
       cur_sel = @opts[:select]
-      cur_sel = [WILDCARD] if !cur_sel || cur_sel.empty?
+      if !cur_sel || cur_sel.empty?
+        unless supports_select_all_and_column?
+          return select_all(*(Array(@opts[:from]) + Array(@opts[:join]))).select_more(*columns, &block)
+        end
+        cur_sel = [WILDCARD]
+      end
       select(*(cur_sel + columns), &block)
     end
 
@@ -888,8 +910,20 @@ module Sequel
     # to keep the same row_proc/graph, but change the SQL used to custom SQL.
     #
     #   DB[:items].with_sql('SELECT * FROM foo') # SELECT * FROM foo
+    #
+    # You can use placeholders in your SQL and provide arguments for those placeholders:
+    #
+    #   DB[:items].with_sql('SELECT ? FROM foo', 1) # SELECT 1 FROM foo
+    #
+    # You can also provide a method name and arguments to call to get the SQL:
+    #
+    #   DB[:items].with_sql(:insert_sql, :b=>1) # INSERT INTO items (b) VALUES (1)
     def with_sql(sql, *args)
-      sql = SQL::PlaceholderLiteralString.new(sql, args) unless args.empty?
+      if sql.is_a?(Symbol)
+        sql = send(sql, *args)
+      else
+        sql = SQL::PlaceholderLiteralString.new(sql, args) unless args.empty?
+      end
       clone(:sql=>sql)
     end
     
@@ -926,12 +960,6 @@ module Sequel
       _filter_or_exclude(false, clause, *cond, &block)
     end
 
-    # Treat the +block+ as a virtual_row block if not +nil+ and
-    # add the resulting columns to the +columns+ array (modifies +columns+).
-    def virtual_row_columns(columns, block)
-      columns.concat(Array(Sequel.virtual_row(&block))) if block
-    end
-    
     # Add the dataset to the list of compounds
     def compound_clone(type, dataset, opts)
       ds = compound_from_self.clone(:compounds=>Array(@opts[:compounds]).map{|x| x.dup} + [[type, dataset.compound_from_self, opts[:all]]])
@@ -964,7 +992,13 @@ module Sequel
       when Symbol, SQL::Expression
         expr
       when TrueClass, FalseClass
-        SQL::BooleanExpression.new(:NOOP, expr)
+        if supports_where_true?
+          SQL::BooleanExpression.new(:NOOP, expr)
+        elsif expr
+          SQL::Constants::SQLTRUE
+        else
+          SQL::Constants::SQLFALSE
+        end
       when String
         LiteralString.new("(#{expr})")
       else
@@ -972,6 +1006,13 @@ module Sequel
       end
     end
     
+    # Return two datasets, the first a clone of the receiver with the WITH
+    # clause from the given dataset added to it, and the second a clone of
+    # the given dataset with the WITH clause removed.
+    def hoist_cte(ds)
+      [clone(:with => (opts[:with] || []) + ds.opts[:with]), ds.clone(:with => nil)]
+    end
+
     # Inverts the given order by breaking it into a list of column references
     # and inverting them.
     #
@@ -989,5 +1030,17 @@ module Sequel
         end
       end
     end
+
+    # Return self if the dataset already has a server, or a cloned dataset with the
+    # default server otherwise.
+    def default_server
+      @opts[:server] ? self : clone(:server=>:default)
+    end
+
+    # Treat the +block+ as a virtual_row block if not +nil+ and
+    # add the resulting columns to the +columns+ array (modifies +columns+).
+    def virtual_row_columns(columns, block)
+      columns.concat(Array(Sequel.virtual_row(&block))) if block
+    end
   end
 end

data/lib/sequel/dataset/sql.rb

@@ -100,10 +100,8 @@ module Sequel
         literal_false
       when Array
         literal_array(v)
-      when SQLTime
-        literal_sqltime(v)
       when Time
-        literal_time(v)
+        v.is_a?(SQLTime) ? literal_sqltime(v) : literal_time(v)
       when DateTime
         literal_datetime(v)
       when Date
@@ -214,7 +212,11 @@ module Sequel
 
     # SQL fragment for BooleanConstants
     def boolean_constant_sql(constant)
-      literal(constant)
+      if (constant == true || constant == false) && !supports_where_true?
+        constant == true ? '(1 = 1)' : '(1 = 0)'
+      else
+        literal(constant)
+      end
     end
 
     # SQL fragment for CaseExpression
@@ -303,6 +305,8 @@ module Sequel
         literal(args.at(0))
       when :'B~'
         "~#{literal(args.at(0))}"
+      when :extract
+        "extract(#{args.at(0)} FROM #{literal(args.at(1))})"
       else
         raise(InvalidOperation, "invalid operator #{op}")
       end
@@ -437,7 +441,7 @@ module Sequel
         when :all
           "ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING"
         when :rows
-          "ROWS UNBOUNDED PRECEDING"
+          "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW"
         when String
           opts[:frame]
         else
@@ -639,6 +643,15 @@ module Sequel
       end
     end
 
+    # SQL fragment specifying the values to return.
+    def insert_returning_sql(sql)
+      if opts.has_key?(:returning)
+        sql << " RETURNING #{column_list(Array(opts[:returning]))}"
+      end
+    end
+    alias delete_returning_sql insert_returning_sql
+    alias update_returning_sql insert_returning_sql
+
     # SQL fragment specifying a JOIN type, converts underscores to
     # spaces and upcases.
     def join_type_sql(join_type)
@@ -870,6 +883,10 @@ module Sequel
       return if !ws || ws.empty?
       sql.replace("#{select_with_sql_base}#{ws.map{|w| "#{quote_identifier(w[:name])}#{"(#{argument_list(w[:args])})" if w[:args]} AS #{literal_dataset(w[:dataset])}"}.join(COMMA_SEPARATOR)} #{sql}")
     end
+    alias delete_with_sql select_with_sql
+    alias insert_with_sql select_with_sql
+    alias update_with_sql select_with_sql
+
     
     # The base keyword to use for the SQL WITH clause
     def select_with_sql_base

data/lib/sequel/model.rb

@@ -11,9 +11,9 @@ module Sequel
   #             with the +Database+ in +source+ to create the
   #             dataset to use) 
   # Dataset :: Sets the dataset for this model to +source+. 
-  # Symbol :: Sets the table name for this model to +source+. The
-  #           class will use the default database for model
-  #           classes in order to create the dataset.
+  # other :: Sets the table name for this model to +source+. The
+  #          class will use the default database for model
+  #          classes in order to create the dataset.
   #
   # The purpose of this method is to set the dataset/database automatically
   # for a model class, if the table name doesn't match the implicit

data/lib/sequel/model/associations.rb

@@ -79,6 +79,27 @@ module Sequel
           true
         end
     
+        # The eager limit strategy to use for this dataset.
+        def eager_limit_strategy
+          fetch(:_eager_limit_strategy) do
+            self[:_eager_limit_strategy] = if self[:limit]
+              case s = self.fetch(:eager_limit_strategy){self[:model].default_eager_limit_strategy || :ruby}
+              when true
+                ds = associated_class.dataset
+                if ds.supports_window_functions?
+                  :window_function
+                else
+                  :ruby
+                end
+              else
+                s
+              end
+            else
+              nil
+            end
+          end
+        end
+
         # By default associations do not need to select a key in an associated table
         # to eagerly load.
         def eager_loading_use_associated_key?
@@ -92,6 +113,15 @@ module Sequel
           true
         end
     
+        # The limit and offset for this association (returned as a two element array).
+        def limit_and_offset
+          if (v = self[:limit]).is_a?(Array)
+            v
+          else
+            [v, nil]
+          end
+        end
+
         # Whether the associated object needs a primary key to be added/removed,
         # false by default.
         def need_associated_primary_key?
@@ -193,6 +223,11 @@ module Sequel
           self[:key].nil?
         end
     
+        # many_to_one associations don't need an eager limit strategy
+        def eager_limit_strategy
+          nil
+        end
+
         # The key to use for the key hash when eager loading
         def eager_loader_key
           self[:eager_loader_key] ||= self[:key]
@@ -248,7 +283,7 @@ module Sequel
         def can_have_associated_objects?(obj)
           !self[:primary_keys].any?{|k| obj.send(k).nil?}
         end
-    
+
         # Default foreign key name symbol for key in associated table that points to
         # current table's primary key.
         def default_key
@@ -259,6 +294,11 @@ module Sequel
         def eager_loader_key
           self[:eager_loader_key] ||= primary_key
         end
+
+        # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
+        def eager_loading_predicate_key
+          self[:eager_loading_predicate_key] ||= self[:uses_composite_keys] ? self[:keys].map{|k| SQL::QualifiedIdentifier.new(associated_class.table_name, k)} : SQL::QualifiedIdentifier.new(associated_class.table_name, self[:key])
+        end
     
         # The column in the current table that the key in the associated table references.
         def primary_key
@@ -297,6 +337,31 @@ module Sequel
       class OneToOneAssociationReflection < OneToManyAssociationReflection
         ASSOCIATION_TYPES[:one_to_one] = self
         
+        # one_to_one associations don't use an eager limit strategy by default, but
+        # support both DISTINCT ON and window functions as strategies.
+        def eager_limit_strategy
+          fetch(:_eager_limit_strategy) do
+            self[:_eager_limit_strategy] = case s = self[:eager_limit_strategy]
+            when Symbol
+              s
+            when true
+              ds = associated_class.dataset
+              if ds.supports_ordered_distinct_on?
+                :distinct_on
+              elsif ds.supports_window_functions?
+                :window_function
+              end
+            else
+              nil
+            end
+          end
+        end
+
+        # The limit and offset for this association (returned as a two element array).
+        def limit_and_offset
+          [1, nil]
+        end
+
         # one_to_one associations return a single object, not an array
         def returns_array?
           false
@@ -362,6 +427,11 @@ module Sequel
           self[:eager_loader_key] ||= self[:left_primary_key]
         end
     
+        # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
+        def eager_loading_predicate_key
+          self[:eager_loading_predicate_key] ||= self[:uses_left_composite_keys] ? self[:left_keys].map{|k| SQL::QualifiedIdentifier.new(self[:join_table], k)} : SQL::QualifiedIdentifier.new(self[:join_table], self[:left_key])
+        end
+    
         # many_to_many associations need to select a key in an associated table to eagerly load
         def eager_loading_use_associated_key?
           true
@@ -457,6 +527,12 @@ module Sequel
       #   Project.association_reflection(:portfolio)
       #   => {:type => :many_to_one, :name => :portfolio, ...}
       #
+      # Associations should not have the same names as any of the columns in the
+      # model's current table they reference. If you are dealing with an existing schema that
+      # has a column named status, you can't name the association status, you'd
+      # have to name it foo_status or something else.  If you give an association the same name
+      # as a column, you will probably end up with an association that doesn't work, or a SystemStackError.
+      #
       # For a more in depth general overview, as well as a reference guide,
       # see the {Association Basics guide}[link:files/doc/association_basics_rdoc.html].
       # For examples of advanced usage, see the {Advanced Associations guide}[link:files/doc/advanced_associations_rdoc.html].
@@ -464,6 +540,9 @@ module Sequel
         # All association reflections defined for this model (default: {}).
         attr_reader :association_reflections
 
+        # The default :eager_limit_strategy option to use for *_many associations (default: nil)
+        attr_accessor :default_eager_limit_strategy
+
         # Array of all association reflections for this model class
         def all_association_reflections
           association_reflections.values
@@ -495,8 +574,7 @@ module Sequel
         # :after_add :: Symbol, Proc, or array of both/either specifying a callback to call
         #               after a new item is added to the association.
         # :after_load :: Symbol, Proc, or array of both/either specifying a callback to call
-        #                after the associated record(s) have been retrieved from the database.  Not called
-        #                when eager loading via eager_graph, but called when eager loading via eager.
+        #                after the associated record(s) have been retrieved from the database.
         # :after_remove :: Symbol, Proc, or array of both/either specifying a callback to call
         #                  after an item is removed from the association.
         # :after_set :: Symbol, Proc, or array of both/either specifying a callback to call
@@ -538,6 +616,14 @@ module Sequel
         #                   additional key :eager_block, a callback accepting one argument, the associated dataset. This
         #                   is used to customize the association at query time.
         #                   Should return a copy of the dataset with the association graphed into it.
+        # :eager_limit_strategy :: Determines the strategy used for enforcing limits when eager loading associations via
+        #                          the +eager+ method.  For one_to_one associations, no strategy is used by default, and
+        #                          for *_many associations, the :ruby strategy is used by default, which still retrieves
+        #                          all records but slices the resulting array after the association is retrieved.  You
+        #                          can pass a +true+ value for this option to have Sequel pick what it thinks is the best
+        #                          choice for the database, or specify a specific symbol to manually select a strategy.
+        #                          one_to_one associations support :distinct_on, :window_function, and :correlated_subquery.
+        #                          *_many associations support :ruby, :window_function, and :correlated_subquery.
         # :eager_loader :: A proc to use to implement eager loading, overriding the default.  Takes one or three arguments.
         #                  If three arguments, the first should be a key hash (used solely to enhance performance), the
         #                  second an array of records, and the third a hash of dependent associations. If one argument, is
@@ -705,7 +791,8 @@ module Sequel
         # Copy the association reflections to the subclass
         def inherited(subclass)
           super
-          subclass.instance_variable_set(:@association_reflections, @association_reflections.dup)
+          subclass.instance_variable_set(:@association_reflections, association_reflections.dup)
+          subclass.default_eager_limit_strategy =  default_eager_limit_strategy
         end
       
         # Shortcut for adding a many_to_many association, see #associate
@@ -730,6 +817,73 @@ module Sequel
         
         private
       
+        # Use a correlated subquery to limit the results of the eager loading dataset.
+        def apply_correlated_subquery_eager_limit_strategy(ds, opts)
+          klass = opts.associated_class
+          kds = klass.dataset
+          dsa = ds.send(:dataset_alias, 1)
+          raise Error, "can't use a correlated subquery if the associated class (#{opts.associated_class.inspect}) does not have a primary key" unless pk = klass.primary_key
+          pka = Array(pk)
+          raise Error, "can't use a correlated subquery if the associated class (#{opts.associated_class.inspect}) has a composite primary key and the database does not support multiple column IN" if pka.length > 1 && !ds.supports_multiple_column_in?
+          table = kds.opts[:from]
+          raise Error, "can't use a correlated subquery unless the associated class (#{opts.associated_class.inspect}) uses a single FROM table" unless table && table.length == 1
+          table = table.first
+          if order = ds.opts[:order]
+            oproc = lambda do |x|
+              case x
+              when Symbol
+                t, c, a = ds.send(:split_symbol, x)
+                if t && t.to_sym == table
+                  SQL::QualifiedIdentifier.new(dsa, c)
+                else
+                  x
+                end
+              when SQL::QualifiedIdentifier
+                if x.table == table
+                  SQL::QualifiedIdentifier.new(dsa, x.column)
+                else
+                  x
+                end
+              when SQL::OrderedExpression
+                SQL::OrderedExpression.new(oproc.call(x.expression), x.descending, :nulls=>x.nulls)
+              else
+                x
+              end
+            end
+            order = order.map(&oproc) 
+          end
+          limit, offset = opts.limit_and_offset
+
+          subquery = yield kds.
+            unlimited.
+            from(SQL::AliasedExpression.new(table, dsa)).
+            select(*pka.map{|k| SQL::QualifiedIdentifier.new(dsa, k)}).
+            order(*order).
+            limit(limit, offset)
+
+          pk = if pk.is_a?(Array)
+            pk.map{|k| SQL::QualifiedIdentifier.new(table, k)}
+          else
+            SQL::QualifiedIdentifier.new(table, pk)
+          end
+          ds.filter(pk=>subquery)
+        end
+
+        # Use a window function to limit the results of the eager loading dataset.
+        def apply_window_function_eager_limit_strategy(ds, opts)
+          rn = ds.row_number_column 
+          limit, offset = opts.limit_and_offset
+          ds = ds.unordered.select_append{row_number(:over, :partition=>opts.eager_loading_predicate_key, :order=>ds.opts[:order]){}.as(rn)}.from_self
+          ds = if opts[:type] == :one_to_one
+            ds.where(rn => 1)
+          elsif offset
+            offset += 1
+            ds.where(rn => (offset...(offset+limit))) 
+          else
+            ds.where{SQL::Identifier.new(rn) <= limit} 
+          end
+        end
+
         # The module to use for the association's methods.  Defaults to
         # the overridable_methods_module.
         def association_module(opts={})
@@ -807,10 +961,24 @@ module Sequel
 
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:key_hash][left_pk]
-            eo[:rows].each{|object| object.associations[name] = []}
+            rows = eo[:rows]
+            rows.each{|object| object.associations[name] = []}
             r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
             l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, h.keys]] : [[left, h.keys]]
-            model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), Array(opts.select), eo[:associations], eo).all do |assoc_record|
+            ds = model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), Array(opts.select), eo[:associations], eo)
+            case opts.eager_limit_strategy
+            when :window_function
+              delete_rn = true
+              rn = ds.row_number_column
+              ds = apply_window_function_eager_limit_strategy(ds, opts)
+            when :correlated_subquery
+              ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
+                dsa = ds.send(:dataset_alias, 2)
+                xds.inner_join(join_table, r + lcks.map{|k| [k, SQL::QualifiedIdentifier.new(join_table, k)]}, :table_alias=>dsa)
+              end
+            end
+            ds.all do |assoc_record|
+              assoc_record.values.delete(rn) if delete_rn
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
               else
@@ -819,6 +987,10 @@ module Sequel
               next unless objects = h[hash_key]
               objects.each{|object| object.associations[name].push(assoc_record)}
             end
+            if opts.eager_limit_strategy == :ruby
+              limit, offset = opts.limit_and_offset
+              rows.each{|o| o.associations[name] = o.associations[name].slice(offset||0, limit) || []}
+            end
           end
           
           join_type = opts[:graph_join_type]
@@ -928,20 +1100,38 @@ module Sequel
           end
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:key_hash][primary_key]
+            rows = eo[:rows]
             if one_to_one
-              eo[:rows].each{|object| object.associations[name] = nil}
+              rows.each{|object| object.associations[name] = nil}
             else
-              eo[:rows].each{|object| object.associations[name] = []}
+              rows.each{|object| object.associations[name] = []}
             end
             reciprocal = opts.reciprocal
             klass = opts.associated_class
-            model.eager_loading_dataset(opts, klass.filter(uses_cks ? {cks.map{|k| SQL::QualifiedIdentifier.new(klass.table_name, k)}=>h.keys} : {SQL::QualifiedIdentifier.new(klass.table_name, key)=>h.keys}), opts.select, eo[:associations], eo).all do |assoc_record|
+            filter_keys = opts.eager_loading_predicate_key
+            ds = model.eager_loading_dataset(opts, klass.filter(filter_keys=>h.keys), opts.select, eo[:associations], eo)
+            case opts.eager_limit_strategy
+            when :distinct_on
+              ds = ds.distinct(*filter_keys).order_prepend(*filter_keys)
+            when :window_function
+              delete_rn = true
+              rn = ds.row_number_column
+              ds = apply_window_function_eager_limit_strategy(ds, opts)
+            when :correlated_subquery
+              ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
+                xds.where(opts.associated_object_keys.map{|k| [SQL::QualifiedIdentifier.new(xds.first_source_alias, k), SQL::QualifiedIdentifier.new(xds.first_source_table, k)]})
+              end
+            end
+            ds.all do |assoc_record|
+              assoc_record.values.delete(rn) if delete_rn
               hash_key = uses_cks ? cks.map{|k| assoc_record.send(k)} : assoc_record.send(key)
               next unless objects = h[hash_key]
               if one_to_one
                 objects.each do |object| 
-                  object.associations[name] = assoc_record
-                  assoc_record.associations[reciprocal] = object if reciprocal
+                  unless object.associations[name]
+                    object.associations[name] = assoc_record
+                    assoc_record.associations[reciprocal] = object if reciprocal
+                  end
                 end
               else
                 objects.each do |object| 
@@ -950,6 +1140,10 @@ module Sequel
                 end
               end
             end
+            if opts.eager_limit_strategy == :ruby
+              limit, offset = opts.limit_and_offset
+              rows.each{|o| o.associations[name] = o.associations[name].slice(offset||0, limit) || []}
+            end
           end
           
           join_type = opts[:graph_join_type]
@@ -1170,7 +1364,6 @@ module Sequel
             associations[name]
           else
             objs = _load_associated_objects(opts, dynamic_opts)
-            run_association_callbacks(opts, :after_load, objs)
             if opts.set_reciprocal_to_self?
               if opts.returns_array?
                 objs.each{|o| add_reciprocal_object(opts, o)}
@@ -1179,6 +1372,8 @@ module Sequel
               end
             end
             associations[name] = objs
+            run_association_callbacks(opts, :after_load, objs)
+            associations[name]
           end
         end
 
@@ -1453,10 +1648,9 @@ module Sequel
           else
             # Each of the following have a symbol key for the table alias, with the following values: 
             # :reciprocals - the reciprocal instance variable to use for this association
+            # :reflections - AssociationReflection instance related to this association
             # :requirements - array of requirements for this association
-            # :alias_association_type_map - the type of association for this association
-            # :alias_association_name_map - the name of the association for this association
-            clone(:eager_graph=>{:requirements=>{}, :master=>alias_symbol(first_source), :alias_association_type_map=>{}, :alias_association_name_map=>{}, :reciprocals=>{}, :cartesian_product_number=>0})
+            clone(:eager_graph=>{:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :cartesian_product_number=>0})
           end
           ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations)
         end
@@ -1504,8 +1698,7 @@ module Sequel
           ds = ds.order_more(*qualified_expression(r[:order], assoc_table_alias)) if r[:order] and r[:order_eager_graph]
           eager_graph = ds.opts[:eager_graph]
           eager_graph[:requirements][assoc_table_alias] = requirements.dup
-          eager_graph[:alias_association_name_map][assoc_table_alias] = assoc_name
-          eager_graph[:alias_association_type_map][assoc_table_alias] = r.returns_array?
+          eager_graph[:reflections][assoc_table_alias] = r
           eager_graph[:cartesian_product_number] += r[:cartesian_product_number] || 2
           ds = ds.eager_graph_associations(ds, r.associated_class, assoc_table_alias, requirements + [assoc_table_alias], *associations) unless associations.empty?
           ds
@@ -1682,6 +1875,9 @@ module Sequel
       # hashes and returning an array of model objects with all eager_graphed associations already set in the
       # association cache.
       class EagerGraphLoader
+        # Hash with table alias symbol keys and after_load hook values
+        attr_reader :after_load_map
+        
         # Hash with table alias symbol keys and association name values
         attr_reader :alias_map
         
@@ -1692,6 +1888,10 @@ module Sequel
         # Recursive hash with table alias symbol keys mapping to hashes with dependent table alias symbol keys.
         attr_reader :dependency_map
         
+        # Hash with table alias symbol keys and [limit, offset] values
+        attr_reader :limit_map
+        
+        # Hash with table alias symbol keys and callable values used to create model instances
         # The table alias symbol for the primary model
         attr_reader :master
         
@@ -1707,6 +1907,9 @@ module Sequel
         # to model instances.  Used so that only a single model instance is created for each object.
         attr_reader :records_map
         
+        # Hash with table alias symbol keys and AssociationReflection values
+        attr_reader :reflection_map
+        
         # Hash with table alias symbol keys and callable values used to create model instances
         attr_reader :row_procs
         
@@ -1721,11 +1924,21 @@ module Sequel
           eager_graph = opts[:eager_graph]
           @master =  eager_graph[:master]
           requirements = eager_graph[:requirements]
-          alias_map = @alias_map = eager_graph[:alias_association_name_map]
-          type_map = @type_map = eager_graph[:alias_association_type_map]
+          reflection_map = @reflection_map = eager_graph[:reflections]
           reciprocal_map = @reciprocal_map = eager_graph[:reciprocals]
           @unique = eager_graph[:cartesian_product_number] > 1
       
+          alias_map = @alias_map = {}
+          type_map = @type_map = {}
+          after_load_map = @after_load_map = {}
+          limit_map = @limit_map = {}
+          reflection_map.each do |k, v|
+            alias_map[k] = v[:name]
+            type_map[k] = v.returns_array?
+            after_load_map[k] = v[:after_load] unless v[:after_load].empty?
+            limit_map[k] = v.limit_and_offset if v[:limit]
+          end
+
           # Make dependency map hash out of requirements array for each association.
           # This builds a tree of dependencies that will be used for recursion
           # to ensure that all parts of the object graph are loaded into the
@@ -1830,8 +2043,9 @@ module Sequel
           end
       
           # Remove duplicate records from all associations if this graph could possibly be a cartesian product
-          unique(records, dm) if @unique
-          
+          # Run after_load procs if there are any
+          post_process(records, dm) if @unique || !after_load_map.empty? || !limit_map.empty?
+
           records
         end
       
@@ -1863,7 +2077,7 @@ module Sequel
               assoc[assoc_name].push(rec) 
               rec.associations[rcm] = current if rcm
             else
-              current.associations[assoc_name] = rec
+              current.associations[assoc_name] ||= rec
             end
             # Recurse into dependencies of the current object
             _load(deps, rec, h) unless deps.empty?
@@ -1921,16 +2135,25 @@ module Sequel
         # In that case, for each object in all associations loaded via +eager_graph+, run
         # uniq! on the association to make sure no duplicate records show up.
         # Note that this can cause legitimate duplicate records to be removed.
-        def unique(records, dependency_map)
+        def post_process(records, dependency_map)
           records.each do |record|
             dependency_map.each do |ta, deps|
-              list = record.send(alias_map[ta])
-              list = if type_map[ta]
+              assoc_name = alias_map[ta]
+              list = record.send(assoc_name)
+              rec_list = if type_map[ta]
                 list.uniq!
-                unique(list, deps) if !list.empty? && !deps.empty?
+                if lo = limit_map[ta]
+                  limit, offset = lo
+                  list.replace(list[offset||0, limit])
+                end
+                list
               elsif list
-                unique([list], deps) unless deps.empty?
+                [list]
+              else
+                []
               end
+              record.send(:run_association_callbacks, reflection_map[ta], :after_load, list) if after_load_map[ta]
+              post_process(rec_list, deps) if !rec_list.empty? && !deps.empty?
             end
           end
         end