sequel 4.7.0 → 4.8.0

data/lib/sequel/extensions/query.rb

@@ -1,6 +1,12 @@
-# The query extension adds Sequel::Dataset#query which allows
+# The query extension adds a query method which allows
 # a different way to construct queries instead of the usual
-# method chaining.  See Sequel::Dataset#query for details.
+# method chaining:
+#
+#   dataset = DB[:items].query do
+#     select :x, :y, :z
+#     filter{(x > 1) & (y > 2)}
+#     reverse :z
+#   end
 #
 # You can load this extension into specific datasets:
 #

data/lib/sequel/extensions/to_dot.rb

@@ -91,7 +91,7 @@ module Sequel
       when SQL::AliasedExpression
         dot "AliasedExpression"
         v(e.expression, :expression)
-        v(e.aliaz, :alias)
+        v(e.alias, :alias)
       when SQL::CaseExpression
         dot "CaseExpression"
         v(e.expression, :expression) if e.expression

data/lib/sequel/model/associations.rb

@@ -70,12 +70,84 @@ module Sequel
           end
           ds = ds.order(*self[:order]) if self[:order]
           ds = ds.limit(*self[:limit]) if self[:limit]
-          ds = ds.limit(1) if !returns_array? && self[:key]
+          ds = ds.limit(1) if limit_to_single_row?
           ds = ds.eager(*self[:eager]) if self[:eager]
           ds = ds.distinct if self[:distinct]
           ds
         end
-        
+
+        # Apply the eager graph limit strategy to the dataset to graph into the current dataset, or return
+        # the dataset unmodified if no SQL limit strategy is needed.
+        def apply_eager_graph_limit_strategy(strategy, ds)
+          case strategy
+          when :distinct_on
+            apply_distinct_on_eager_limit_strategy(ds.order_prepend(*self[:order]))
+          when :window_function
+            apply_window_function_eager_limit_strategy(ds.order_prepend(*self[:order])).select(*ds.columns)
+          else
+            ds
+          end
+        end
+
+        # Apply an eager limit strategy to the dataset, or return the dataset
+        # unmodified if it doesn't need an eager limit strategy.
+        def apply_eager_limit_strategy(ds)
+          case eager_limit_strategy
+          when :distinct_on
+            apply_distinct_on_eager_limit_strategy(ds)
+          when :window_function
+            apply_window_function_eager_limit_strategy(ds)
+          else
+            ds
+          end
+        end
+
+        # Use DISTINCT ON and ORDER BY clauses to limit the results to the first record with matching keys.
+        def apply_distinct_on_eager_limit_strategy(ds)
+          keys = predicate_key
+          ds.distinct(*keys).order_prepend(*keys)
+        end
+
+        # Use a window function to limit the results of the eager loading dataset.
+        def apply_window_function_eager_limit_strategy(ds)
+          rn = ds.row_number_column 
+          limit, offset = limit_and_offset
+          ds = ds.unordered.select_append{|o| o.row_number{}.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
+          ds = if !returns_array?
+            ds.where(rn => offset ? offset+1 : 1)
+          elsif offset
+            offset += 1
+            if limit
+              ds.where(rn => (offset...(offset+limit))) 
+            else
+              ds.where{SQL::Identifier.new(rn) >= offset} 
+            end
+          else
+            ds.where{SQL::Identifier.new(rn) <= limit} 
+          end
+        end
+
+        # If the ruby eager limit strategy is being used, slice the array using the slice
+        # range to return the object(s) at the correct offset/limit.
+        def apply_ruby_eager_limit_strategy(rows)
+          if eager_limit_strategy == :ruby
+            name = self[:name]
+            if returns_array?
+              range = slice_range
+              rows.each{|o| o.associations[name] = o.associations[name][range] || []}
+            elsif slice_range
+              offset = slice_range.begin
+              rows.each{|o| o.associations[name] = o.associations[name][offset]}
+            end
+          end
+        end
+
+        # Whether the associations cache should use an array when storing the
+        # associated records during eager loading.
+        def assign_singular?
+          !returns_array?
+        end
+
         # Whether this association can have associated objects, given the current
         # object.  Should be false if obj cannot have associated objects because
         # the necessary key columns are NULL.
@@ -83,6 +155,12 @@ module Sequel
           true
         end
 
+        # Whether you are able to clone from the given association type to the current
+        # association type, true by default only if the types match.
+        def cloneable?(ref)
+          ref[:type] == self[:type]
+        end
+
         # Name symbol for the dataset association method
         def dataset_method
           :"#{self[:name]}_dataset"
@@ -93,23 +171,41 @@ module Sequel
           true
         end
     
+        # Return the symbol used for the row number column if the window function
+        # eager limit strategy is being used, or nil otherwise.
+        def delete_row_number_column(ds)
+          if eager_limit_strategy == :window_function
+            ds.row_number_column 
+          end
+        end
+
+        # The eager_graph limit strategy to use for this dataset
+        def eager_graph_limit_strategy(strategy)
+          if self[:limit] || !returns_array?
+            strategy = strategy[self[:name]] if strategy.is_a?(Hash)
+            case strategy
+            when true
+              true_eager_limit_strategy
+            when Symbol
+              strategy
+            else
+              if returns_array? || offset
+                :ruby
+              end
+            end
+          end
+        end
+        
         # The eager limit strategy to use for this dataset.
         def eager_limit_strategy
           cached_fetch(:_eager_limit_strategy) do
-            if self[:limit]
-              case s = cached_fetch(:eager_limit_strategy){self[:model].default_eager_limit_strategy || :ruby}
+            if self[:limit] || !returns_array?
+              case s = cached_fetch(:eager_limit_strategy){default_eager_limit_strategy}
               when true
-                ds = associated_class.dataset
-                if ds.supports_window_functions?
-                  :window_function
-                else
-                  :ruby
-                end
+                true_eager_limit_strategy
               else
                 s
               end
-            else
-              nil
             end
           end
         end
@@ -140,7 +236,7 @@ module Sequel
         # Whether additional conditions should be added when using the filter
         # by associations support.
         def filter_by_associations_add_conditions?
-          self[:conditions] || self[:eager_block]
+          self[:conditions] || self[:eager_block] || self[:limit]
         end
 
         # The expression to use for the additional conditions to be added for
@@ -158,6 +254,16 @@ module Sequel
           false
         end
 
+        # Initialize the associations cache for the current association for the given objects.
+        def initialize_association_cache(objects)
+          name = self[:name]
+          if assign_singular?
+            objects.each{|object| object.associations[name] = nil}
+          else
+            objects.each{|object| object.associations[name] = []}
+          end
+        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)
@@ -319,6 +425,48 @@ module Sequel
           end
         end
 
+        # Apply a limit strategy to the given dataset so that filter by
+        # associations works with a limited dataset.
+        def apply_filter_by_associations_limit_strategy(ds)
+          case eager_limit_strategy
+          when :distinct_on
+            apply_filter_by_associations_distinct_on_limit_strategy(ds)
+          when :window_function
+            apply_filter_by_associations_window_function_limit_strategy(ds)
+          else
+            ds
+          end
+        end
+
+        # Apply a distinct on eager limit strategy using IN with a subquery
+        # that uses DISTINCT ON to ensure only the first matching record for
+        # each key is included.
+        def apply_filter_by_associations_distinct_on_limit_strategy(ds)
+          k = filter_by_associations_limit_key 
+          ds.where(k=>apply_distinct_on_eager_limit_strategy(filter_by_associations_limit_subquery.select(*k)))
+        end
+
+        # Apply a distinct on eager limit strategy using IN with a subquery
+        # that uses a filter on the row_number window function to ensure
+        # that only rows inside the limit are returned.
+        def apply_filter_by_associations_window_function_limit_strategy(ds)
+          ds.where(filter_by_associations_limit_key=>apply_window_function_eager_limit_strategy(filter_by_associations_limit_subquery.select(*filter_by_associations_limit_alias_key)).select(*filter_by_associations_limit_aliases))
+        end
+
+        # The associated_dataset with the eager_block callback already applied.
+        def associated_eager_dataset
+          cached_fetch(:associated_eager_dataset) do
+            ds = associated_dataset
+            ds = self[:eager_block].call(ds) if self[:eager_block]
+            ds
+          end
+        end
+
+        # The default eager limit strategy to use for this association
+        def default_eager_limit_strategy
+          self[:model].default_eager_limit_strategy || :ruby
+        end
+
         # The conditions to add to the filter by associations conditions
         # subquery to restrict it to to the object(s) that was used as the
         # filter value.
@@ -339,13 +487,28 @@ module Sequel
         # values.
         def filter_by_associations_conditions_dataset
           cached_fetch(:filter_by_associations_conditions_dataset) do
-            ds = associated_dataset.unordered.unlimited
+            ds = associated_eager_dataset.unordered.unlimited
             ds = filter_by_associations_add_conditions_dataset_filter(ds)
-            ds = self[:eager_block].call(ds) if self[:eager_block]
+            ds = apply_filter_by_associations_limit_strategy(ds)
             ds
           end
         end
 
+        # The base subquery to use when filtering by limited associations
+        def filter_by_associations_limit_subquery
+          associated_eager_dataset.unlimited
+        end
+
+        # Whether to limit the associated dataset to a single row.
+        def limit_to_single_row?
+          !returns_array?
+        end
+        
+        # Any offset to use for this association (or nil if there is no offset).
+        def offset
+          limit_and_offset.last
+        end
+
         # Whether the given association reflection is possible reciprocal
         # association for the current association reflection.
         def reciprocal_association?(assoc_reflect)
@@ -360,6 +523,16 @@ module Sequel
         def transform(s)
           s.is_a?(Array) ? s.map(&Proc.new) : (yield s)
         end
+
+        # The eager limit strategy used when true is given as the value, choosing the
+        # best strategy based on what the database supports.
+        def true_eager_limit_strategy
+          if associated_class.dataset.supports_window_functions?
+            :window_function
+          else
+            :ruby
+          end
+        end
       end
     
       class ManyToOneAssociationReflection < AssociationReflection
@@ -388,6 +561,11 @@ module Sequel
           self[:key].nil?
         end
     
+        # many_to_one associations don't need an eager_graph limit strategy
+        def eager_graph_limit_strategy(_)
+          nil
+        end
+
         # many_to_one associations don't need an eager limit strategy
         def eager_limit_strategy
           nil
@@ -454,6 +632,12 @@ module Sequel
           qualify(self[:model].table_name, self[:key_column])
         end
 
+        # many_to_one associations do not need to be limited to a single row if they
+        # explicitly do not have a key.
+        def limit_to_single_row?
+          super && self[:key]
+        end
+        
         def reciprocal_association?(assoc_reflect)
           super && self[:keys] == assoc_reflect[:keys] && primary_key == assoc_reflect.primary_key
         end
@@ -479,6 +663,11 @@ module Sequel
           !self[:primary_keys].any?{|k| obj.send(k).nil?}
         end
 
+        # one_to_many and one_to_one associations can be clones
+        def cloneable?(ref)
+          ref[:type] == :one_to_many || ref[:type] == :one_to_one
+        end
+
         # Default foreign key name symbol for key in associated table that points to
         # current table's primary key.
         def default_key
@@ -538,6 +727,18 @@ module Sequel
           qualify(self[:model].table_name, self[:primary_key_column])
         end
 
+        def filter_by_associations_limit_alias_key
+          Array(filter_by_associations_limit_key)
+        end
+
+        def filter_by_associations_limit_aliases
+          filter_by_associations_limit_alias_key.map{|v| v.column}
+        end
+
+        def filter_by_associations_limit_key
+          qualify(associated_class.table_name, associated_class.primary_key)
+        end
+
         def reciprocal_association?(assoc_reflect)
           super && self[:keys] == assoc_reflect[:keys] && primary_key == assoc_reflect.primary_key
         end
@@ -547,46 +748,48 @@ module Sequel
           :many_to_one
         end
       end
-      
-      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
-          cached_fetch(:_eager_limit_strategy) do
-            offset = limit_and_offset.last
-            case s = self.fetch(:eager_limit_strategy){(self[:model].default_eager_limit_strategy || :ruby) if offset}
-            when Symbol
-              s
-            when true
-              ds = associated_class.dataset
-              if ds.supports_ordered_distinct_on? && offset.nil?
-                :distinct_on
-              elsif ds.supports_window_functions?
-                :window_function
-              else
-                :ruby
-              end
-            else
-              nil
-            end
-          end
+
+      # Methods that turn an association that returns multiple objects into an association that
+      # returns a single object.
+      module SingularAssociationReflection
+        # Singular associations do not assign singular if they are using the ruby eager limit strategy
+        # and have a slice range, since they need to store the array of associated objects in order to
+        # pick the correct one with an offset.
+        def assign_singular?
+          super && (eager_limit_strategy != :ruby || !slice_range)
         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
+        # Add conditions when filtering by singular associations with orders, since the
+        # underlying relationship is probably not one-to-one.
+        def filter_by_associations_add_conditions?
+          super || self[:order]
         end
 
-        # one_to_one associations return a single object, not an array
+        # Singular associations always return a single object, not an array.
         def returns_array?
           false
         end
+
+        private
+
+        # Only use a eager limit strategy by default if there is an offset or an order.
+        def default_eager_limit_strategy
+          super if self[:order] || offset
+        end
+
+        # Use the DISTINCT ON eager limit strategy for true if the database supports it.
+        def true_eager_limit_strategy
+          if associated_class.dataset.supports_ordered_distinct_on? && !offset
+            :distinct_on
+          else
+            super
+          end
+        end
+      end
+      
+      class OneToOneAssociationReflection < OneToManyAssociationReflection
+        ASSOCIATION_TYPES[:one_to_one] = self
+        include SingularAssociationReflection
       end
     
       class ManyToManyAssociationReflection < AssociationReflection
@@ -597,6 +800,17 @@ module Sequel
           self[:left_key_alias]
         end
 
+        # Array of associated keys used when eagerly loading.
+        def associated_key_array
+          cached_fetch(:associated_key_array) do
+            if self[:uses_left_composite_keys]
+              associated_key_alias.zip(predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)}
+            else
+              [SQL::AliasedExpression.new(predicate_key, associated_key_alias)]
+            end
+          end
+        end
+
         # The column to use for the associated key when eagerly loading
         def associated_key_column
           self[:left_key]
@@ -613,6 +827,11 @@ module Sequel
           !self[:left_primary_keys].any?{|k| obj.send(k).nil?}
         end
 
+        # one_through_one and many_to_many associations can be clones
+        def cloneable?(ref)
+          ref[:type] == :many_to_many || ref[:type] == :one_through_one
+        end
+
         # The default associated key alias(es) to use when eager loading
         # associations via eager.
         def default_associated_key_alias
@@ -710,7 +929,9 @@ module Sequel
         private
 
         def filter_by_associations_add_conditions_dataset_filter(ds)
-          ds.select(*qualify(join_table_alias, self[:left_keys])).
+          k = qualify(join_table_alias, self[:left_keys])
+          ds.select(*k).
+            where(Sequel.negate(k.zip([]))).
             inner_join(self[:join_table], Array(self[:right_keys]).zip(right_primary_keys), :qualify=>:deep)
         end
 
@@ -718,6 +939,23 @@ module Sequel
           qualify(self[:model].table_name, self[:left_primary_key_column])
         end
 
+        def filter_by_associations_limit_alias_key
+          aliaz = 'a'
+          filter_by_associations_limit_key.map{|c| c.as(Sequel.identifier(aliaz = aliaz.next))}
+        end
+
+        def filter_by_associations_limit_aliases
+          filter_by_associations_limit_alias_key.map{|v| v.alias}
+        end
+
+        def filter_by_associations_limit_key
+          qualify(join_table_alias, self[:left_keys]) + Array(qualify(associated_class.table_name, associated_class.primary_key))
+        end
+
+        def filter_by_associations_limit_subquery
+          super.inner_join(self[:join_table], Array(self[:right_keys]).zip(right_primary_keys))
+        end
+
         def reciprocal_association?(assoc_reflect)
           super && assoc_reflect[:left_keys] == self[:right_keys] &&
             assoc_reflect[:right_keys] == self[:left_keys] &&
@@ -736,6 +974,22 @@ module Sequel
         end
       end
   
+      class OneThroughOneAssociationReflection < ManyToManyAssociationReflection
+        ASSOCIATION_TYPES[:one_through_one] = self
+        include SingularAssociationReflection
+        
+        # one_through_one associations should not singularize the association name when
+        # creating the foreign key.
+        def default_right_key
+          :"#{self[:name]}_id"
+        end
+      
+        # one_through_one associations have no reciprocals
+        def reciprocal
+          nil
+        end
+      end
+    
       # This module contains methods added to all association datasets
       module AssociationDatasetMethods
         # The model object that created the association dataset
@@ -839,6 +1093,9 @@ module Sequel
         #                 model's primary key.   Each current model object can be associated with
         #                 more than one associated model objects.  Each associated model object
         #                 can be associated with only one current model object.
+        # :one_through_one :: Similar to many_to_many in terms of foreign keys, but only one object
+        #                     is associated to the current object through the association.
+        #                     Provides only getter methods, no setter or modification methods.
         # :one_to_one :: Similar to one_to_many in terms of foreign keys, but
         #                only one object is associated to the current object through the
         #                association.  The methods created are similar to many_to_one, except
@@ -871,11 +1128,11 @@ module Sequel
         #                before an item is set using the association setter method.
         # :cartesian_product_number :: the number of joins completed by this association that could cause more
         #                              than one row for each row in the current table (default: 0 for
-        #                              many_to_one and one_to_one associations, 1 for one_to_many and
-        #                              many_to_many associations).
+        #                              many_to_one, one_to_one, and one_through_one associations, 1
+        #                              for one_to_many and many_to_many associations).
         # :class :: The associated class or its name as a string or symbol. If not
         #           given, uses the association's name, which is camelized (and
-        #           singularized unless the type is :many_to_one or :one_to_one).  If this is specified
+        #           singularized unless the type is :many_to_one, :one_to_one, or one_through_one).  If this is specified
         #           as a string or symbol, you must specify the full class name (e.g. "SomeModule::MyModel"). 
         # :clearer :: Proc used to define the private _remove_all_* method for doing the database work
         #             to remove all objects associated to the current object (*_to_many assocations).
@@ -895,10 +1152,9 @@ module Sequel
         # :eager_graph :: The associations to eagerly load via +eager_graph+ when loading the associated object(s).
         #                 many_to_many associations with this option cannot be eagerly loaded via +eager+.
         # :eager_grapher :: A proc to use to implement eager loading via +eager_graph+, overriding the default.
-        #                   Takes an options hash with the entries :self (the receiver of the eager_graph call),
-        #                   :table_alias (the alias to use for table to graph into the association), :implicit_qualifier
-        #                   (the alias that was used for the current table), and possibly :eager_block (a callback
-        #                   proc accepting the associated dataset, for per-call customization).
+        #                   Takes an options hash with at least the entries :self (the receiver of the eager_graph call),
+        #                   :table_alias (the alias to use for table to graph into the association), and :implicit_qualifier
+        #                   (the alias that was used for the current table).
         #                   Should return a copy of the dataset with the association graphed into it.
         # :eager_limit_strategy :: Determines the strategy used for enforcing limits and offsets when eager loading
         #                          associations via the +eager+ method.  
@@ -926,6 +1182,10 @@ module Sequel
         # :graph_only_conditions :: The conditions to use on the SQL join when eagerly loading
         #                           the association via +eager_graph+, instead of the default conditions specified by the
         #                           foreign/primary keys.  This option causes the :graph_conditions option to be ignored.
+        # :graph_order :: Over the order to use when using eager_graph, instead of the default order.  This should be used
+        #                 in the case where :order contains an identifier qualified by the table's name, which may not match
+        #                 the alias used when eager graphing.  By setting this to the unqualified identifier, it will be
+        #                 automatically qualified when using eager_graph.
         # :graph_select :: A column or array of columns to select from the associated table
         #                  when eagerly loading the association via +eager_graph+. Defaults to all
         #                  columns in the associated table.
@@ -939,7 +1199,8 @@ module Sequel
         # :order_eager_graph :: Whether to add the association's order to the graphed dataset's order when graphing
         #                       via +eager_graph+.  Defaults to true, so set to false to disable.
         # :read_only :: Do not add a setter method (for many_to_one or one_to_one associations),
-        #               or add_/remove_/remove_all_ methods (for one_to_many and many_to_many associations).
+        #               or add_/remove_/remove_all_ methods (for one_to_many and many_to_many associations). Always
+        #               true for one_through_one associations.
         # :reciprocal :: the symbol name of the reciprocal association,
         #                if it exists.  By default, Sequel will try to determine it by looking at the
         #                associated model's assocations for a association that matches
@@ -988,7 +1249,7 @@ module Sequel
         #                        conjunction with defining a model alias method for the primary key column.
         # :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) [one_to_many only].
-        # === :many_to_many
+        # === :many_to_many and :one_through_one
         # :graph_join_table_block :: The block to pass to +join_table+ for
         #                            the join table when eagerly loading the association via +eager_graph+.
         # :graph_join_table_conditions :: The additional conditions to use on the SQL join for
@@ -1034,14 +1295,20 @@ module Sequel
 
           # dup early so we don't modify opts
           orig_opts = opts.dup
+
           if opts[:clone]
             cloned_assoc = association_reflection(opts[:clone])
-            raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})") unless cloned_assoc[:type] == type || [cloned_assoc[:type], type].all?{|t| [:one_to_many, :one_to_one].include?(t)}
             orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
           end
+
           opts = orig_opts.merge(:type => type, :name => name, :cache=>{}, :model => self)
           opts[:block] = block if block
           opts = assoc_class.new.merge!(opts)
+
+          if opts[:clone] && !opts.cloneable?(cloned_assoc)
+            raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})")
+          end
+
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
           if !opts.has_key?(:predicate_key) && opts.has_key?(:eager_loading_predicate_key)
             opts[:predicate_key] = opts[:eager_loading_predicate_key]
@@ -1091,11 +1358,7 @@ module Sequel
           ds = ds.eager(associations) unless Array(associations).empty?
           ds = eager_options[:eager_block].call(ds) if eager_options[:eager_block]
           if opts.eager_loading_use_associated_key?
-            ds = if opts[:uses_left_composite_keys]
-              ds.select_append(*opts.associated_key_alias.zip(opts.predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)})
-            else
-              ds.select_append(SQL::AliasedExpression.new(opts.predicate_key, opts.associated_key_alias))
-            end
+            ds = ds.select_append(*opts.associated_key_array)
           end
           ds
         end
@@ -1110,6 +1373,11 @@ module Sequel
           associate(:many_to_one, name, opts, &block)
         end
         
+        # Shortcut for adding a one_through_one association, see #associate.
+        def one_through_one(name, opts=OPTS, &block)
+          associate(:one_through_one, name, opts, &block)
+        end
+
         # Shortcut for adding a one_to_many association, see #associate
         def one_to_many(name, opts=OPTS, &block)
           associate(:one_to_many, name, opts, &block)
@@ -1121,29 +1389,10 @@ module Sequel
         end
 
         Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_eager_limit_strategy=>nil)
-        Plugins.def_dataset_methods(self, [:eager, :eager_graph])
+        Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private
       
-        # 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.predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
-          ds = if opts[:type] == :one_to_one
-            ds.where(rn => offset ? offset+1 : 1)
-          elsif offset
-            offset += 1
-            if limit
-              ds.where(rn => (offset...(offset+limit))) 
-            else
-              ds.where{SQL::Identifier.new(rn) >= offset} 
-            end
-          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=OPTS)
@@ -1179,8 +1428,10 @@ module Sequel
           association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
         end
       
-        # Configures many_to_many association reflection and adds the related association methods
+        # Configures many_to_many and one_through_one association reflection and adds the related association methods
         def def_many_to_many(opts)
+          one_through_one = opts[:type] == :one_through_one
+          opts[:read_only] = true if one_through_one
           name = opts[:name]
           model = self
           left = (opts[:left_key] ||= opts.default_left_key)
@@ -1199,7 +1450,7 @@ module Sequel
           end
           uses_lcks = opts[:uses_left_composite_keys] = lcks.length > 1
           opts[:uses_right_composite_keys] = rcks.length > 1
-          opts[:cartesian_product_number] ||= 1
+          opts[:cartesian_product_number] ||= one_through_one ? 0 : 1
           join_table = (opts[:join_table] ||= opts.default_join_table)
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
           graph_jt_conds = opts[:graph_join_table_conditions] = opts.fetch(:graph_join_table_conditions, []).to_a
@@ -1211,28 +1462,34 @@ module Sequel
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:id_map]
             rows = eo[:rows]
-            rows.each{|object| object.associations[name] = []}
             r = rcks.zip(opts.right_primary_keys)
             l = [[opts.predicate_key, h.keys]]
+
             ds = model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l, :qualify=>:deep), nil, eo[:associations], eo)
-            if opts.eager_limit_strategy == :window_function
-              delete_rn = true
-              rn = ds.row_number_column
-              ds = apply_window_function_eager_limit_strategy(ds, opts)
-            end
+            ds = opts.apply_eager_limit_strategy(ds)
+            opts.initialize_association_cache(rows)
+
+            assign_singular = opts.assign_singular?
+            delete_rn = opts.delete_row_number_column(ds)
             ds.all do |assoc_record|
-              assoc_record.values.delete(rn) if delete_rn
+              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]
-              objects.each{|object| object.associations[name].push(assoc_record)}
-            end
-            if opts.eager_limit_strategy == :ruby
-              rows.each{|o| o.associations[name] = o.associations[name][slice_range] || []}
+              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
           
           join_type = opts[:graph_join_type]
@@ -1247,13 +1504,25 @@ module Sequel
           jt_graph_block = opts[:graph_join_table_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lpkcs) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :qualify=>:deep, :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
-            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>join_type, &graph_block)
+            egls = eo[:limit_strategy]
+            if egls && egls != :ruby
+              associated_key_array = opts.associated_key_array
+              orig_egds = egds = eager_graph_dataset(opts, eo)
+              egds = egds.
+                inner_join(join_table, rcks.zip(opts.right_primary_keys) + graph_jt_conds, :qualify=>:deep).
+                select_all(egds.first_source).
+                select_append(*associated_key_array)
+              egds = opts.apply_eager_graph_limit_strategy(egls, egds)
+              ds.graph(egds, associated_key_array.map{|v| v.alias}.zip(lpkcs) + conditions, :qualify=>:deep, :table_alias=>eo[:table_alias], :implicit_qualifier=>eo[:implicit_qualifier], :join_type=>eo[:join_type]||join_type, :from_self_alias=>eo[:from_self_alias], :select=>select||orig_egds.columns, &graph_block)
+            else
+              ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lpkcs) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>eo[:join_type]||jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :qualify=>:deep, :from_self_alias=>eo[:from_self_alias], &jt_graph_block)
+              ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + 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)
       
-          return if opts[:read_only]
+          return if opts[:read_only] || one_through_one
       
           adder = opts[:adder] || proc do |o|
             h = {}
@@ -1311,9 +1580,9 @@ module Sequel
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:id_map]
             keys = h.keys
-            # Default the cached association to nil, so any object that doesn't have it
-            # populated will have cached the negative lookup.
-            eo[:rows].each{|object| object.associations[name] = nil}
+
+            opts.initialize_association_cache(eo[:rows])
+
             # Skip eager loading if no objects have a foreign key for this association
             unless keys.empty?
               klass = opts.associated_class
@@ -1334,7 +1603,7 @@ module Sequel
           graph_cks = opts[:graph_keys]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :qualify=>:deep, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -1371,26 +1640,15 @@ module Sequel
             rows = eo[:rows]
             reciprocal = opts.reciprocal
             klass = opts.associated_class
-            filter_keys = opts.predicate_key
-            ds = model.eager_loading_dataset(opts, klass.where(filter_keys=>h.keys), nil, eo[:associations], eo)
-            assign_singular = true if one_to_one 
-            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 :ruby
-              assign_singular = false if one_to_one && slice_range
-            end
-            if assign_singular
-              rows.each{|object| object.associations[name] = nil}
-            else
-              rows.each{|object| object.associations[name] = []}
-            end
+
+            ds = model.eager_loading_dataset(opts, klass.where(opts.predicate_key=>h.keys), nil, eo[:associations], eo)
+            ds = opts.apply_eager_limit_strategy(ds)
+            opts.initialize_association_cache(rows)
+
+            assign_singular = opts.assign_singular?
+            delete_rn = opts.delete_row_number_column(ds)
             ds.all do |assoc_record|
-              assoc_record.values.delete(rn) if delete_rn
+              assoc_record.values.delete(delete_rn) if delete_rn
               hash_key = uses_cks ? km.map{|k| assoc_record.send(k)} : assoc_record.send(km)
               next unless objects = h[hash_key]
               if assign_singular
@@ -1407,15 +1665,7 @@ module Sequel
                 end
               end
             end
-            if opts.eager_limit_strategy == :ruby
-              if one_to_one
-                if slice_range
-                  rows.each{|o| o.associations[name] = o.associations[name][slice_range.begin]}
-                end
-              else
-                rows.each{|o| o.associations[name] = o.associations[name][slice_range] || []}
-              end
-            end
+            opts.apply_ruby_eager_limit_strategy(rows)
           end
           
           join_type = opts[:graph_join_type]
@@ -1427,7 +1677,7 @@ module Sequel
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>join_type, :qualify=>:deep, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
@@ -1481,6 +1731,11 @@ module Sequel
           end
         end
 
+        # Alias of def_many_to_many, since they share pretty much the same code.
+        def def_one_through_one(opts)
+          def_many_to_many(opts)
+        end
+        
         # Alias of def_one_to_many, since they share pretty much the same code.
         def def_one_to_one(opts)
           def_one_to_many(opts)
@@ -1844,6 +2099,26 @@ module Sequel
       #   Artist.eager(:albums => {proc{|ds| ds.where{year > 1990}}=>{:tracks => :genre}})
       module DatasetMethods
         Sequel::Dataset.def_mutation_method(:eager, :eager_graph, :module=>self)
+
+        %w'inner left right full'.each do |type|
+          class_eval <<END, __FILE__, __LINE__+1
+            def association_#{type}_join(*associations)
+              _association_join(:#{type}, associations)
+            end
+END
+        end
+
+        # Adds one or more INNER JOINs to the existing dataset using the keys and conditions
+        # specified by the given association.  The following methods also exist for specifying
+        # a different type of JOIN:
+        #
+        # association_full_join :: FULL JOIN
+        # association_inner_join :: INNER JOIN
+        # association_left_join :: LEFT JOIN
+        # association_right_join :: RIGHT JOIN
+        def association_join(*associations)
+          association_inner_join(*associations)
+        end
       
         # If the expression is in the form <tt>x = y</tt> where +y+ is a <tt>Sequel::Model</tt>
         # instance, array of <tt>Sequel::Model</tt> instances, or a <tt>Sequel::Model</tt> dataset,
@@ -1951,7 +2226,7 @@ module Sequel
         # 
         # Each association's order, if definied, is respected. +eager_graph+ probably
         # won't work correctly on a limited dataset, unless you are
-        # only graphing many_to_one and one_to_one associations.
+        # only graphing many_to_one, one_to_one, and one_through_one associations.
         # 
         # Does not use the block defined for the association, since it does a single query for
         # all objects.  You can use the :graph_* association options to modify the SQL query.
@@ -1959,22 +2234,48 @@ module Sequel
         # Like +eager+, you need to call +all+ on the dataset for the eager loading to work.  If you just
         # call +each+, it will yield plain hashes, each containing all columns from all the tables.
         def eager_graph(*associations)
+          eager_graph_with_options(associations)
+        end
+
+        # Run eager_graph with some options specific to just this call. Unlike eager_graph, this takes
+        # the associations as a single argument instead of multiple arguments.
+        #
+        # Options:
+        #
+        # :join_type :: Override the join type specified in the association
+        # :limit_strategy :: Use a strategy for handling limits on associations.
+        #                    Appropriate :limit_strategy values are:
+        #                    true :: Pick the most appropriate based on what the database supports
+        #                    :distinct_on :: Force use of DISTINCT ON stategy (*_one associations only)
+        #                    :window_function :: Force use of window function strategy
+        #                    :ruby :: Don't modify the SQL, implement limits/offsets with array slicing
+        #
+        #                    This can also be a hash with association name symbol keys and one of the above values,
+        #                    to use different strategies per association.
+        #
+        #                    The default is the :ruby strategy.  Choosing a different strategy can make your code
+        #                    significantly slower in some cases (perhaps even the majority of cases), so you should
+        #                    only use this if you have benchmarked that it is faster for your use cases.
+        def eager_graph_with_options(associations, opts=OPTS)
+          associations = [associations] unless associations.is_a?(Array)
           if eg = @opts[:eager_graph]
             eg = eg.dup
-            [:requirements, :reflections, :reciprocals].each{|k| eg[k] = eg[k].dup}
+            [:requirements, :reflections, :reciprocals, :limits].each{|k| eg[k] = eg[k].dup}
+            eg[:local] = opts
             ds = clone(:eager_graph=>eg)
             ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations)
           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
-            ds = clone(:eager_graph=>{:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :cartesian_product_number=>0, :row_proc=>row_proc})
-            ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).
-              naked
+            # :reciprocals :: the reciprocal value to use for this association
+            # :reflections :: AssociationReflection instance related to this association
+            # :requirements :: array of requirements for this association
+            # :limits :: Any limit/offset array slicing that need to be handled in ruby land after loading
+            opts = {:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :limits=>{}, :local=>opts, :cartesian_product_number=>0, :row_proc=>row_proc}
+            ds = clone(:eager_graph=>opts)
+            ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
           end
         end
-        
+
         # Do not attempt to split the result set into associations,
         # just return results as simple objects.  This is useful if you
         # want to use eager_graph as a shortcut to have all of the joins
@@ -2004,7 +2305,7 @@ module Sequel
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
           if r.is_a?(SQL::AliasedExpression)
-            alias_base = r.aliaz
+            alias_base = r.alias
             r = r.expression
           else
             alias_base = r[:graph_alias_base]
@@ -2020,11 +2321,19 @@ module Sequel
               associations = assoc.is_a?(Array) ? assoc : [assoc]
             end
           end
-          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>ta, :callback=>callback)
-          ds = ds.order_more(*qualified_expression(r[:order], assoc_table_alias)) if r[:order] and r[:order_eager_graph]
+          orig_ds = ds
+          local_opts = ds.opts[:eager_graph][:local]
+          limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
+          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>ta, :callback=>callback, :join_type=>local_opts[:join_type], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
+          if r[:order_eager_graph] && (order = r.fetch(:graph_order, r[:order]))
+            ds = ds.order_more(*qualified_expression(order, assoc_table_alias))
+          end
           eager_graph = ds.opts[:eager_graph]
           eager_graph[:requirements][assoc_table_alias] = requirements.dup
           eager_graph[:reflections][assoc_table_alias] = r
+          if limit_strategy == :ruby
+            eager_graph[:limits][assoc_table_alias] = r.limit_and_offset 
+          end
           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
@@ -2065,12 +2374,18 @@ module Sequel
       
         private
 
+        # Return a new dataset with JOINs of the given type added, using the tables and
+        # conditions specified by the associations.
+        def _association_join(type, associations)
+          clone(:join=>clone(:graph_from_self=>false).eager_graph_with_options(associations, :join_type=>type).opts[:join])
+        end
+
         # If the association has conditions itself, then it requires additional filters be
         # added to the current dataset to ensure that the passed in object would also be
         # included by the association's conditions.
         def add_association_filter_conditions(ref, obj, expr)
           if expr != SQL::Constants::FALSE && ref.filter_by_associations_add_conditions?
-            Sequel.&(expr, ref.filter_by_associations_conditions_expression(obj))
+            Sequel.expr(ref.filter_by_associations_conditions_expression(obj))
           else
             expr
           end
@@ -2130,7 +2445,7 @@ module Sequel
         # per-call determining of the alias base.
         def eager_graph_check_association(model, association)
           if association.is_a?(SQL::AliasedExpression)
-            SQL::AliasedExpression.new(check_association(model, association.expression), association.aliaz)
+            SQL::AliasedExpression.new(check_association(model, association.expression), association.alias)
           else
             check_association(model, association)
           end
@@ -2210,6 +2525,7 @@ module Sequel
 
           association_filter_handle_inversion(op, expr, Array(lpks))
         end
+        alias one_through_one_association_filter_expression many_to_many_association_filter_expression
 
         # Return a simple equality expression for filering by a many_to_one association
         def many_to_one_association_filter_expression(op, ref, obj)
@@ -2304,17 +2620,20 @@ module Sequel
           requirements = eager_graph[:requirements]
           reflection_map = @reflection_map = eager_graph[:reflections]
           reciprocal_map = @reciprocal_map = eager_graph[:reciprocals]
+          limit_map = @limit_map = eager_graph[:limits]
           @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]
+            type_map[k] = if v.returns_array?
+              true
+            elsif (limit_and_offset = limit_map[k]) && !limit_and_offset.last.nil?
+              :offset
+            end
           end
 
           # Make dependency map hash out of requirements array for each association.
@@ -2523,9 +2842,14 @@ module Sequel
                 if lo = limit_map[ta]
                   limit, offset = lo
                   offset ||= 0
-                  list.replace(list[(offset)..(limit ? (offset)+limit-1 : -1)])
+                  if type_map[ta] == :offset
+                    [record.associations[assoc_name] = list[offset]]
+                  else
+                    list.replace(list[(offset)..(limit ? (offset)+limit-1 : -1)] || [])
+                  end
+                else
+                  list
                 end
-                list
               elsif list
                 [list]
               else