sequel 3.22.0 → 3.23.0

data/lib/sequel/extensions/migration.rb

@@ -302,7 +302,7 @@ module Sequel
   #
   # Part of the +migration+ extension.
   class Migrator
-    MIGRATION_FILE_PATTERN = /\A\d+_.+\.rb\z/i.freeze
+    MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
     MIGRATION_SPLITTER = '_'.freeze
     MINIMUM_TIMESTAMP = 20000101
 
@@ -589,7 +589,7 @@ module Sequel
         next unless MIGRATION_FILE_PATTERN.match(file)
         files << File.join(directory, file)
       end
-      files.sort
+      files.sort_by{|f| MIGRATION_FILE_PATTERN.match(File.basename(f))[1].to_i}
     end
     
     # Returns tuples of migration, filename, and direction

data/lib/sequel/model/associations.rb

@@ -529,8 +529,12 @@ module Sequel
         #     set to nil.
         #   - :eager_graph - The associations to eagerly load via +eager_graph+ when loading the associated object(s).
         #   - :eager_grapher - A proc to use to implement eager loading via +eager_graph+, overriding the default.
-        #     Takes three arguments, a dataset, an alias to use for the table to graph for this association,
-        #     and the alias that was used for the current table (since you can cascade associations),
+        #     Takes one or three arguments. If three arguments, they are a dataset, an alias to use for
+        #     the table to graph for this association, and the alias that was used for the current table
+        #     (since you can cascade associations). If one argument, is passed a hash with keys :self,
+        #     :table_alias, and :implicit_qualifier, corresponding to the three arguments, and an optional
+        #     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_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,
@@ -628,7 +632,8 @@ module Sequel
           raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
           raise(Error, 'Model.associate name argument must be a symbol') unless Symbol === name
           raise(Error, ':eager_loader option must have an arity of 1 or 3') if opts[:eager_loader] && ![1, 3].include?(opts[:eager_loader].arity)
-      
+          raise(Error, ':eager_grapher option must have an arity of 1 or 3') if opts[:eager_grapher] && ![1, 3].include?(opts[:eager_grapher].arity)
+
           # dup early so we don't modify opts
           orig_opts = opts.dup
           orig_opts = association_reflection(opts[:clone])[:orig_opts].merge(orig_opts) if opts[:clone]
@@ -678,16 +683,18 @@ module Sequel
           if opts[:eager_graph]
             ds = ds.eager_graph(opts[:eager_graph])
             ds = ds.add_graph_aliases(opts.associated_key_alias=>[opts.associated_class.table_name, opts.associated_key_alias, SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column)]) if opts.eager_loading_use_associated_key?
-          elsif opts.eager_loading_use_associated_key?
+          end
+          ds = ds.eager(associations) unless Array(associations).empty?
+          ds = opts[:eager_block].call(ds) if opts[:eager_block]
+          ds = eager_options[:eager_block].call(ds) if eager_options[:eager_block]
+          if !opts[:eager_graph] && opts.eager_loading_use_associated_key?
             ds = if opts[:uses_left_composite_keys]
               t = opts.associated_key_table
-              ds.select_more(*opts.associated_key_alias.zip(opts.associated_key_column).map{|a, c| SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, c), a)})
+              ds.select_append(*opts.associated_key_alias.zip(opts.associated_key_column).map{|a, c| SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, c), a)})
             else
-              ds.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column), opts.associated_key_alias)) 
+              ds.select_append(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column), opts.associated_key_alias))
             end
           end
-          ds = ds.eager(associations) unless Array(associations).empty?
-          ds = opts[:eager_block].call(ds) if opts[:eager_block]
           ds
         end
 
@@ -753,9 +760,20 @@ module Sequel
           def_association_method(opts)
         end
 
-        # Adds the association method to the association methods module. 
-        def def_association_method(opts)
-          association_module_def(opts.association_method, opts){|*reload| load_associated_objects(opts, reload[0])}
+        # Adds the association method to the association methods module. Be backwards
+        # compatible with ruby 1.8.6, which doesn't support blocks taking block arguments.
+        if RUBY_VERSION >= '1.8.7'
+          class_eval <<-END, __FILE__, __LINE__+1
+            def def_association_method(opts)
+              association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
+            end
+          END
+        else
+          class_eval <<-END, __FILE__, __LINE__+1
+            def def_association_method(opts)
+              association_module_def(opts.association_method, opts){|*dynamic_opts| load_associated_objects(opts, dynamic_opts[0])}
+            end
+          END
         end
       
         # Configures many_to_many association reflection and adds the related association methods
@@ -782,8 +800,7 @@ module Sequel
           opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
           opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, rcks.zip(opts.right_primary_keys) + lcks.zip(lcpks.map{|k| send(k)}))}
-          database = db
-          
+
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:key_hash][left_pk]
             eo[:rows].each{|object| object.associations[name] = []}
@@ -810,9 +827,10 @@ module Sequel
           jt_only_conditions = opts[:graph_join_table_only_conditions]
           jt_join_type = opts[:graph_join_table_join_type]
           jt_graph_block = opts[:graph_join_table_block]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table), :join_type=>jt_join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :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], :join_type=>join_type, &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -876,8 +894,9 @@ module Sequel
           only_conditions = opts[:graph_only_conditions]
           conditions = opts[:graph_conditions]
           graph_block = opts[:graph_block]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : opts.primary_keys.zip(cks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &graph_block)
+          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(cks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -936,10 +955,11 @@ module Sequel
           conditions = opts[:graph_conditions]
           opts[:cartesian_product_number] ||= one_to_one ? 0 : 1
           graph_block = opts[:graph_block]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds = ds.graph(opts.associated_class, use_only_conditions ? only_conditions : cks.zip(cpks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &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(cpks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
-            ds.opts[:eager_graph][:reciprocals][assoc_alias] = opts.reciprocal
+            ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
           end
       
@@ -993,6 +1013,15 @@ module Sequel
           association_module_def(opts.remove_method, opts){|o,*args| remove_associated_object(opts, o, *args)}
           association_module_def(opts.remove_all_method, opts){|*args| remove_all_associated_objects(opts, *args)}
         end
+
+        # Return dataset to graph into given the association reflection, applying the :callback option if set.
+        def eager_graph_dataset(opts, eager_options)
+          ds = opts.associated_class.dataset
+          if cb = eager_options[:callback]
+            ds = cb.call(ds)
+          end
+          ds
+        end
       end
 
       # Instance methods used to implement the associations support.
@@ -1033,6 +1062,15 @@ module Sequel
           ds
         end
 
+        # Return a dataset for the association after applying any dynamic callback.
+        def _associated_dataset(opts, dynamic_opts)
+          ds = send(opts.dataset_method)
+          if callback = dynamic_opts[:callback]
+            ds = callback.call(ds)
+          end
+          ds
+        end
+        
         # Return an association dataset for the given association reflection
         def _dataset(opts)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
@@ -1045,13 +1083,14 @@ module Sequel
           opts[:join_table_block] ? opts[:join_table_block].call(ds) : ds
         end
 
-        # Return the associated objects from the dataset, without callbacks, reciprocals, and caching.
-        def _load_associated_objects(opts)
+        # Return the associated objects from the dataset, without association callbacks, reciprocals, and caching.
+        # Still apply the dynamic callback if present.
+        def _load_associated_objects(opts, dynamic_opts={})
           if opts.returns_array?
-            opts.can_have_associated_objects?(self) ? send(opts.dataset_method).all : []
+            opts.can_have_associated_objects?(self) ? _associated_dataset(opts, dynamic_opts).all : []
           else
             if opts.can_have_associated_objects?(self)
-              send(opts.dataset_method).all.first
+              _associated_dataset(opts, dynamic_opts).all.first
             end
           end
         end
@@ -1113,12 +1152,20 @@ module Sequel
         end
 
         # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
-        def load_associated_objects(opts, reload=false)
+        def load_associated_objects(opts, dynamic_opts=nil)
+          if dynamic_opts == true or dynamic_opts == false or dynamic_opts == nil
+            dynamic_opts = {:reload=>dynamic_opts}
+          elsif dynamic_opts.respond_to?(:call)
+            dynamic_opts = {:callback=>dynamic_opts}
+          end
+          if block_given?
+            dynamic_opts = dynamic_opts.merge(:callback=>Proc.new)
+          end
           name = opts[:name]
-          if associations.include?(name) and !reload
+          if associations.include?(name) and !dynamic_opts[:callback] and !dynamic_opts[:reload]
             associations[name]
           else
-            objs = _load_associated_objects(opts)
+            objs = _load_associated_objects(opts, dynamic_opts)
             run_association_callbacks(opts, :after_load, objs)
             if opts.set_reciprocal_to_self?
               if opts.returns_array?
@@ -1259,6 +1306,24 @@ module Sequel
       #   Artist.eager_graph(:albums=>:tracks).all
       #   Artist.eager(:albums=>{:tracks=>:genre}).all
       #   Artist.eager_graph(:albums=>{:tracks=>:genre}).all
+      #
+      # You can also pass a callback as a hash value in order to customize the dataset being
+      # eager loaded at query time, analogous to the way the :eager_block association option
+      # allows you to customize it at association definition time. For example,
+      # if you wanted artists with their albums since 1990:
+      #
+      #   Artist.eager(:albums => proc{|ds| ds.filter{year > 1990}})
+      #
+      # Or if you needed albums and their artist's name only, using a single query:
+      #
+      #   Albums.eager_graph(:artist => proc{|ds| ds.select(:name)})
+      #
+      # To cascade eager loading while using a callback, you substitute the cascaded
+      # associations with a single entry hash that has the proc callback as the key and 
+      # the cascaded associations as the value.  This will load artists with their albums
+      # since 1990, and also the tracks on those albums and the genre for those tracks:
+      #
+      #   Artist.eager(:albums => {proc{|ds| ds.filter{year > 1990}}=>{:tracks => :genre}})
       module DatasetMethods
         # Add the <tt>eager!</tt> and <tt>eager_graph!</tt> mutation methods to the dataset.
         def self.extended(obj)
@@ -1343,6 +1408,33 @@ module Sequel
           ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations)
         end
         
+        # If the expression is in the form <tt>x = y</tt> where +y+ is a <tt>Sequel::Model</tt>
+        # instance, assume +x+ is an association symbol and look up the association reflection
+        # via the dataset's model.  From there, return the appropriate SQL based on the type of
+        # association and the values of the foreign/primary keys of +y+.  For most association
+        # types, this is a simple transformation, but for +many_to_many+ associations this 
+        # creates a subquery to the join table.
+        def complex_expression_sql(op, args)
+          if op == :'=' and args.at(1).is_a?(Sequel::Model)
+            l, r = args
+            if ar = model.association_reflections[l]
+              unless r.is_a?(ar.associated_class)
+                raise Sequel::Error, "invalid association class #{r.class.inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}, expected class #{ar.associated_class.inspect}"
+              end
+
+              if exp = association_filter_expression(ar, r)
+                literal(exp)
+              else
+                raise Sequel::Error, "invalid association type #{ar[:type].inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}"
+              end
+            else
+              raise Sequel::Error, "invalid association #{l.inspect} used in dataset filter for model #{model.inspect}"
+            end
+          else
+            super
+          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
@@ -1366,10 +1458,23 @@ module Sequel
         # r :: association reflection for the current association
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
-          klass = r.associated_class
           assoc_name = r[:name]
           assoc_table_alias = ds.unused_table_alias(assoc_name)
-          ds = r[:eager_grapher].call(ds, assoc_table_alias, ta)
+          loader = r[:eager_grapher]
+          if !associations.empty?
+            if associations.first.respond_to?(:call)
+              callback = associations.first
+              associations = {}
+            elsif associations.length == 1 && (assocs = associations.first).is_a?(Hash) && assocs.length == 1 && (pr_assoc = assocs.to_a.first) && pr_assoc.first.respond_to?(:call)
+              callback, assoc = pr_assoc
+              associations = assoc.is_a?(Array) ? assoc : [assoc]
+            end
+          end
+          ds = if loader.arity == 1
+            loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>ta, :callback=>callback)
+          else
+            loader.call(ds, assoc_table_alias, ta)
+          end
           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
@@ -1471,6 +1576,12 @@ module Sequel
       
         private
       
+        # Return an expression for filtering by the given association reflection and associated object.
+        def association_filter_expression(ref, obj)
+          meth = :"#{ref[:type]}_association_filter_expression"
+          send(meth, ref, obj) if respond_to?(meth, true)
+        end
+
         # Make sure the association is valid for this model, and return the related AssociationReflection.
         def check_association(model, association)
           raise(Sequel::UndefinedAssociation, "Invalid association #{association} for #{model.name}") unless reflection = model.association_reflection(association)
@@ -1557,15 +1668,40 @@ module Sequel
           
           reflections.each do |r|
             loader = r[:eager_loader]
+            associations = eager_assoc[r[:name]]
+            if associations.respond_to?(:call)
+              eager_block = associations
+              associations = {}
+            elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
+              eager_block, associations = pr_assoc
+            end
             if loader.arity == 1
-              loader.call(:key_hash=>key_hash, :rows=>a, :associations=>eager_assoc[r[:name]], :self=>self)
+              loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block)
             else
-              loader.call(key_hash, a, eager_assoc[r[:name]])
+              loader.call(key_hash, a, associations)
             end
             a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} unless r[:after_load].empty?
           end 
         end
       
+        # Return a subquery expression for filering by a many_to_many association
+        def many_to_many_association_filter_expression(ref, obj)
+            lpks, lks, rks = ref.values_at(:left_primary_keys, :left_keys, :right_keys)
+            lpks = lpks.first if lpks.length == 1
+            SQL::BooleanExpression.from_value_pairs(lpks=>model.db[ref[:join_table]].select(*lks).where(rks.zip(ref.right_primary_keys.map{|k| obj.send(k)})))
+        end
+
+        # Return a simple equality expression for filering by a many_to_one association
+        def many_to_one_association_filter_expression(ref, obj)
+          SQL::BooleanExpression.from_value_pairs(ref[:keys].zip(ref.primary_keys.map{|k| obj.send(k)}))
+        end
+
+        # Return a simple equality expression for filering by a one_to_* association
+        def one_to_many_association_filter_expression(ref, obj)
+          SQL::BooleanExpression.from_value_pairs(ref[:primary_keys].zip(ref[:keys].map{|k| obj.send(k)}))
+        end
+        alias one_to_one_association_filter_expression one_to_many_association_filter_expression
+
         # Build associations from the graph if #eager_graph was used, 
         # and/or load other associations if #eager was used.
         def post_load(all_records)

data/lib/sequel/model/base.rb

@@ -162,7 +162,7 @@ module Sequel
       def db
         return @db if @db
         @db = self == Model ? DATABASES.first : superclass.db
-        raise(Error, "No database associated with #{self}") unless @db
+        raise(Error, "No database associated with #{self}: have you called Sequel.connect or #{self}.db= ?") unless @db
         @db
       end
       
@@ -1086,10 +1086,10 @@ module Sequel
       # For each of the fields in the given array +fields+, call the setter
       # method with the value of that +hash+ entry for the field. Returns self.
       #
-      #   artist.set_fields({:name=>'Jim'}, :name)
+      #   artist.set_fields({:name=>'Jim'}, [:name])
       #   artist.name # => 'Jim'
       #
-      #   artist.set_fields({:hometown=>'LA'}, :name)
+      #   artist.set_fields({:hometown=>'LA'}, [:name])
       #   artist.name # => nil
       #   artist.hometown # => 'Sac'
       def set_fields(hash, fields)
@@ -1149,10 +1149,10 @@ module Sequel
       # Update the instances values by calling +set_fields+ with the +hash+
       # and +fields+, then save any changes to the record.  Returns self.
       #
-      #   artist.update_fields({:name=>'Jim'}, :name)
+      #   artist.update_fields({:name=>'Jim'}, [:name])
       #   # UPDATE artists SET name = 'Jim' WHERE (id = 1)
       #
-      #   artist.update_fields({:hometown=>'LA'}, :name)
+      #   artist.update_fields({:hometown=>'LA'}, [:name])
       #   # UPDATE artists SET name = NULL WHERE (id = 1)
       def update_fields(hash, fields)
         set_fields(hash, fields)
@@ -1230,7 +1230,7 @@ module Sequel
       # the record should be refreshed from the database.
       def _insert
         ds = _insert_dataset
-        if ds.respond_to?(:insert_select) and h = ds.insert_select(@values)
+        if !ds.opts[:select] and ds.respond_to?(:insert_select) and h = ds.insert_select(@values)
           @values = h
           nil
         else

data/lib/sequel/plugins/identity_map.rb

@@ -121,9 +121,9 @@ module Sequel
         # key option has a value and the association uses the primary key of
         # the associated class as the :primary_key option, check the identity
         # map for the associated object and return it if present.
-        def _load_associated_objects(opts)
+        def _load_associated_objects(opts, dynamic_opts={})
           klass = opts.associated_class
-          if klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts[:primary_key] == klass.primary_key and
+          if !dynamic_opts[:callback] && klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts.primary_key == klass.primary_key and
            opts[:key] and pk = _associated_object_pk(opts[:key]) and o = idm[klass.identity_map_key(pk)]
             o
           else

data/lib/sequel/plugins/many_through_many.rb

@@ -116,6 +116,7 @@ module Sequel
           nil
         end
       end
+
       module ClassMethods
         # Create a many_through_many association.  Arguments:
         # * name - Same as associate, the name of the association.
@@ -204,19 +205,43 @@ module Sequel
           only_conditions = opts[:graph_only_conditions]
           use_only_conditions = opts.include?(:graph_only_conditions)
           conditions = opts[:graph_conditions]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            iq = table_alias
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            iq = eo[:implicit_qualifier]
             opts.edges.each do |t|
               ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
               iq = nil
             end
             fe = opts[:final_edge]
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
+            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :join_type=>join_type, &graph_block)
           end
 
           def_association_dataset_methods(opts)
         end
       end
+
+      module DatasetMethods
+        private
+
+        # Use a subquery to filter rows to those related to the given associated object
+        def many_through_many_association_filter_expression(ref, obj)
+          lpks = ref[:left_primary_keys]
+          lpks = lpks.first if lpks.length == 1
+          edges = ref.edges
+          first, rest = edges.first, edges[1..-1]
+          last = edges.last
+          ds = model.db[first[:table]].select(*Array(first[:right]).map{|x| ::Sequel::SQL::QualifiedIdentifier.new(first[:table], x)})
+          rest.each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:right]).zip(Array(e[:left])) + e[:conditions])), :table_alias=>ds.unused_table_alias(e[:table]), &e[:block])}
+          last_alias = if rest.empty?
+            first[:table]
+          else
+            last_join = ds.opts[:join].last
+            last_join.table_alias || last_join.table
+          end
+          ds = ds.where(Array(ref[:final_edge][:left]).map{|x| ::Sequel::SQL::QualifiedIdentifier.new(last_alias, x)}.zip(ref.right_primary_keys.map{|k| obj.send(k)}))
+          SQL::BooleanExpression.from_value_pairs(lpks=>ds)
+        end
+      end
     end
   end
 end