sequel 3.8.0 → 3.9.0

data/lib/sequel/model/base.rb

@@ -720,7 +720,7 @@ module Sequel
       def save(*columns)
         opts = columns.last.is_a?(Hash) ? columns.pop : {}
         if opts[:validate] != false and !valid?
-          raise(ValidationFailed, errors.full_messages.join(', ')) if raise_on_save_failure 
+          raise(ValidationFailed.new(errors)) if raise_on_save_failure
           return
         end
         checked_save_failure{checked_transaction(opts){_save(columns, opts)}}
@@ -811,11 +811,18 @@ module Sequel
       # allow running inside a transaction
       def _destroy(opts)
         return save_failure(:destroy) if before_destroy == false
-        delete
+        _destroy_delete
         after_destroy
         self
       end
       
+      # Internal delete method to call when destroying an object,
+      # separated from delete to allow you to override destroy's version
+      # without affecting delete.
+      def _destroy_delete
+        delete
+      end
+
       def _insert
         ds = model.dataset
         if ds.respond_to?(:insert_select) and h = ds.insert_select(@values)

data/lib/sequel/model/default_inflections.rb

@@ -1,7 +1,7 @@
 module Sequel
   # Proc that is instance evaled to create the default inflections for both the
   # model inflector and the inflector extension.
-  DEFAULT_INFLECTIONS_PROC = lambda do
+  DEFAULT_INFLECTIONS_PROC = proc do
     plural(/$/, 's')
     plural(/s$/i, 's')
     plural(/(alias|(?:stat|octop|vir|b)us)$/i, '\1es')

data/lib/sequel/model/exceptions.rb

@@ -1,6 +1,16 @@
 module Sequel
   # This exception will be raised when raise_on_save_failure is set and validation fails
-  class ValidationFailed < Error; end
+  class ValidationFailed < Error
+    def initialize(errors)
+      if errors.respond_to?(:full_messages)
+        @errors = errors
+        super(errors.full_messages.join(', '))
+      else
+        super
+      end
+    end
+    attr_reader :errors
+  end
 
   # This exception will be raised when raise_on_save_failure is set and a before hook returns false
   class BeforeHookFailed < Error; end

data/lib/sequel/model/inflections.rb

@@ -39,7 +39,14 @@ module Sequel
     @plurals, @singulars, @uncountables = [], [], []
 
     class << self
-      attr_reader :plurals, :singulars, :uncountables
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for plurization.
+      attr_reader :plurals
+
+      # Array of 2 element arrays, first containing a regex, and the second containing a substitution pattern, used for singularization.
+      attr_reader :singulars
+
+      # Array of strings for words were the singular form is the same as the plural form
+      attr_reader :uncountables
     end
 
     # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,

data/lib/sequel/model/plugins.rb

@@ -60,25 +60,15 @@ module Sequel
       
       private
   
-      # Returns the new style location for the plugin name.
-      def plugin_gem_location(plugin)
-        "sequel/plugins/#{plugin}"
-      end
-
-      # Returns the old style location for the plugin name.
-      def plugin_gem_location_old(plugin)
-        "sequel_#{plugin}"
-      end
-  
       # Returns the module for the specified plugin. If the module is not 
       # defined, the corresponding plugin gem is automatically loaded.
       def plugin_module(plugin)
         module_name = plugin.to_s.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
         if not Sequel::Plugins.const_defined?(module_name)
           begin
-            require plugin_gem_location(plugin)
+            Sequel.tsk_require "sequel/plugins/#{plugin}"
           rescue LoadError
-            require plugin_gem_location_old(plugin)
+            Sequel.tsk_require "sequel_#{plugin}"
           end
         end
         Sequel::Plugins.const_get(module_name)

data/lib/sequel/plugins/active_model.rb

@@ -1,10 +1,15 @@
+require 'active_model'
 module Sequel
   module Plugins
     # The ActiveModel plugin makes Sequel::Model objects the
     # pass the ActiveModel::Lint tests, which should
     # hopefully mean full ActiveModel compliance.  This should
     # allow the full support of Sequel::Model objects in Rails 3.
+    # This plugin requires active_model in order to use
+    # ActiveModel::Naming.
     module ActiveModel
+      ClassMethods = ::ActiveModel::Naming
+
       module InstanceMethods
         # Record that an object was destroyed, for later use by
         # destroyed?

data/lib/sequel/plugins/association_dependencies.rb

@@ -16,7 +16,7 @@ module Sequel
     # and dependency action values.  You can provide the hash to the plugin call itself or
     # to the add_association_dependencies method:
     #
-    #   Business.plugin :association_dependencies, :address=>delete
+    #   Business.plugin :association_dependencies, :address=>:delete
     #   # or:
     #   Artist.plugin :association_dependencies
     #   Artist.add_association_dependencies :albums=>:destroy, :reviews=>:delete, :tags=>:nullify

data/lib/sequel/plugins/many_through_many.rb

@@ -193,7 +193,7 @@ module Sequel
           opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
             iq = table_alias
             opts.edges.each do |t|
-              ds = ds.graph(t[:table], t.include?(:only_conditions) ? t[:only_conditions] : (Array(t[:right]).zip(Array(t[:left])) + t[:conditions]), :select=>false, :table_alias=>ds.send(:eager_unique_table_alias, ds, t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
+              ds = ds.graph(t[:table], t.include?(:only_conditions) ? t[: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]

data/lib/sequel/plugins/optimistic_locking.rb

@@ -0,0 +1,65 @@
+module Sequel
+  module Plugins
+    # This plugin implements a simple database-independent locking mechanism
+    # to ensure that concurrent updates do not override changes. This is
+    # best implemented by a code example:
+    # 
+    #   class Person < Sequel::Model
+    #     plugin :optimistic_locking
+    #   end
+    #   p1 = Person[1]
+    #   p2 = Person[1]
+    #   p1.update(:name=>'Jim') # works
+    #   p2.update(:name=>'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #
+    # In order for this plugin to work, you need to make sure that the database
+    # table has a lock_version column (or other column you name via the lock_column
+    # class level accessor) that defaults to 0.
+    #
+    # This plugin does not work with the class_table_inheritance plugin.
+    module OptimisticLocking
+      # Exception class raised when trying to update or destroy a stale object.
+      class Error < Sequel::Error
+      end
+
+      # Set the lock_column to the :lock_column option, or :lock_version if
+      # that option is not given.
+      def self.configure(model, opts={})
+        model.lock_column = opts[:lock_column] || :lock_version
+      end
+      
+      module ClassMethods
+        # The column holding the version of the lock
+        attr_accessor :lock_column
+        
+        # Copy the lock_column value into the subclass
+        def inherited(subclass)
+          super
+          subclass.lock_column = lock_column
+        end
+      end
+    
+      module InstanceMethods
+        private
+        
+        # Only delete the object when destroying if it has the same lock version.  If the row
+        # doesn't have the same lock version, raise an error.
+        def _destroy_delete
+          lc = model.lock_column
+          raise(Error, "Attempt to destroy a stale object") if this.filter(lc=>send(lc)).delete != 1
+        end
+        
+        # Only update the row if it has the same lock version, and increment the
+        # lock version.  If the row doesn't have the same lock version, raise
+        # an Error.
+        def _update(columns)
+          lc = model.lock_column
+          lcv = send(lc)
+          columns[lc] = lcv + 1
+          raise(Error, "Attempt to update a stale object") if this.filter(lc=>lcv).update(columns) != 1
+          send("#{lc}=", lcv + 1)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -19,11 +19,10 @@ module Sequel
       # dataset's row_proc so that the dataset yields objects of varying classes,
       # where the class used has the same name as the key field.
       def self.configure(model, key)
-        m = model.method(:constantize)
         model.instance_eval do
           @sti_key = key 
           @sti_dataset = dataset
-          dataset.row_proc = lambda{|r| (m.call(r[key]) rescue model).load(r)}
+          dataset.row_proc = lambda{|r| model.sti_load(r)}
         end
       end
 
@@ -42,13 +41,25 @@ module Sequel
           super
           sk = sti_key
           sd = sti_dataset
-          subclass.set_dataset(sd.filter(sk=>subclass.name.to_s), :inherited=>true)
+          subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>subclass.name.to_s), :inherited=>true)
           subclass.instance_eval do
             @sti_key = sk
             @sti_dataset = sd
             @simple_table = nil
           end
         end
+
+        # Return an instance of the class specified by sti_key,
+        # used by the row_proc.
+        def sti_load(r)
+          v = r[sti_key]
+          model = if (v && v != '')
+            constantize(v) rescue self
+          else
+            self
+          end
+          model.load(r)
+        end
       end
 
       module InstanceMethods

data/lib/sequel/plugins/validation_helpers.rb

@@ -18,8 +18,8 @@ module Sequel
     #   attribute(s) to validate.
     # Options:
     # * :allow_blank - Whether to skip the validation if the value is blank.  You should
-    #   make sure all objects respond to blank if you use this option, which you can do by
-    #   requiring 'sequel/extensions/blank'
+    #   make sure all objects respond to blank if you use this option, which you can do by:
+    #     Sequel.extension :blank
     # * :allow_missing - Whether to skip the validation if the attribute isn't a key in the
     #   values hash.  This is different from allow_nil, because Sequel only sends the attributes
     #   in the values when doing an insert or update.  If the attribute is not present, Sequel

data/lib/sequel/sql.rb

@@ -360,7 +360,7 @@ module Sequel
     # and SQL::StringExpression).
     #
     # This defines the like (LIKE) and ilike methods, used for pattern matching.
-    # like is case sensitive, ilike is case insensitive.
+    # like is case sensitive (if the database supports it), ilike is case insensitive.
     module StringMethods
       # Create a BooleanExpression case insensitive pattern match of self
       # with the given patterns.  See StringExpression.like.
@@ -368,7 +368,7 @@ module Sequel
         StringExpression.like(self, *(ces << {:case_insensitive=>true}))
       end
 
-      # Create a BooleanExpression case sensitive pattern match of self with
+      # Create a BooleanExpression case sensitive (if the database supports it) pattern match of self with
       # the given patterns.  See StringExpression.like.
       def like(*ces)
         StringExpression.like(self, *ces)

data/lib/sequel/timezones.rb

@@ -49,8 +49,8 @@ module Sequel
     # same time and just modifying the timezone.
     def convert_input_datetime_no_offset(v, input_timezone)
       case input_timezone
-      when :utc
-        v# DateTime assumes UTC if no offset is given
+      when :utc, nil
+        v # DateTime assumes UTC if no offset is given
       when :local
         v.new_offset(LOCAL_DATETIME_OFFSET) - LOCAL_DATETIME_OFFSET
       else

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 8
+  MINOR = 9
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mssql_spec.rb

@@ -352,3 +352,22 @@ context "MSSSQL::Dataset#disable_insert_output" do
     MSSQL_DB[:test].disable_insert_output.send(:simple_select_all?).should == true
   end
 end
+
+context "MSSSQL::Dataset#into" do
+  before do
+    @db = MSSQL_DB
+  end
+
+  specify "should format SELECT statement" do
+    @db[:t].into(:new).select_sql.should == "SELECT * INTO NEW FROM T"
+  end
+
+  specify "should select rows into a new table" do
+    @db.create_table!(:t) {Integer :id; String :value}
+    @db[:t].insert(:id => 1, :value => "test")
+    @db << @db[:t].into(:new).select_sql
+    @db[:new].all.should == [{:id => 1, :value => "test"}]
+    @db.drop_table(:t)
+    @db.drop_table(:new)
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -79,6 +79,10 @@ context "A MySQL database" do
   specify "should provide the server version" do
     MYSQL_DB.server_version.should >= 40000
   end
+  
+  specify "should handle the creation and dropping of an InnoDB table with foreign keys" do
+    proc{MYSQL_DB.create_table!(:test_innodb, :engine=>:InnoDB){primary_key :id; foreign_key :fk, :test_innodb, :key=>:id}}.should_not raise_error
+  end
 end
 
 if MYSQL_DB.class.adapter_scheme == :mysql

data/spec/adapters/postgres_spec.rb

@@ -543,6 +543,186 @@ context "Postgres::Database schema qualified tables" do
   end
 end
 
+context "Postgres::Database schema qualified tables and eager graphing" do
+  before(:all) do
+    @db = POSTGRES_DB
+    @db.run "DROP SCHEMA s CASCADE" rescue nil
+    @db.run "CREATE SCHEMA s"
+    @db.quote_identifiers = true
+    
+    @db.create_table(:s__bands){primary_key :id; String :name}
+    @db.create_table(:s__albums){primary_key :id; String :name; foreign_key :band_id, :s__bands}
+    @db.create_table(:s__tracks){primary_key :id; String :name; foreign_key :album_id, :s__albums}
+    @db.create_table(:s__members){primary_key :id; String :name; foreign_key :band_id, :s__bands}
+    
+    @Band = Class.new(Sequel::Model(:s__bands))
+    @Album = Class.new(Sequel::Model(:s__albums))
+    @Track = Class.new(Sequel::Model(:s__tracks))
+    @Member = Class.new(Sequel::Model(:s__members))
+    def @Band.name; :Band; end
+    def @Album.name; :Album; end
+    def @Track.name; :Track; end
+    def @Member.name; :Member; end
+    
+    @Band.one_to_many :albums, :class=>@Album, :order=>:name
+    @Band.one_to_many :members, :class=>@Member, :order=>:name
+    @Album.many_to_one :band, :class=>@Band, :order=>:name
+    @Album.one_to_many :tracks, :class=>@Track, :order=>:name
+    @Track.many_to_one :album, :class=>@Album, :order=>:name
+    @Member.many_to_one :band, :class=>@Band, :order=>:name
+    
+    @Member.many_to_many :members, :class=>@Member, :join_table=>:s__bands, :right_key=>:id, :left_key=>:id, :left_primary_key=>:band_id, :right_primary_key=>:band_id, :order=>:name
+    @Band.many_to_many :tracks, :class=>@Track, :join_table=>:s__albums, :right_key=>:id, :right_primary_key=>:album_id, :order=>:name
+    
+    @b1 = @Band.create(:name=>"BM")
+    @b2 = @Band.create(:name=>"J")
+    @a1 = @Album.create(:name=>"BM1", :band=>@b1)
+    @a2 = @Album.create(:name=>"BM2", :band=>@b1)
+    @a3 = @Album.create(:name=>"GH", :band=>@b2)
+    @a4 = @Album.create(:name=>"GHL", :band=>@b2)
+    @t1 = @Track.create(:name=>"BM1-1", :album=>@a1)
+    @t2 = @Track.create(:name=>"BM1-2", :album=>@a1)
+    @t3 = @Track.create(:name=>"BM2-1", :album=>@a2)
+    @t4 = @Track.create(:name=>"BM2-2", :album=>@a2)
+    @m1 = @Member.create(:name=>"NU", :band=>@b1)
+    @m2 = @Member.create(:name=>"TS", :band=>@b1)
+    @m3 = @Member.create(:name=>"NS", :band=>@b2)
+    @m4 = @Member.create(:name=>"JC", :band=>@b2)
+  end
+  after(:all) do
+    @db.quote_identifiers = false
+    @db.run "DROP SCHEMA s CASCADE"
+  end
+  
+  specify "should return all eager graphs correctly" do
+    bands = @Band.order(:bands__name).eager_graph(:albums).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+
+    bands = @Band.order(:bands__name).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.albums.map{|y| y.tracks}}.should == [[[@t1, @t2], [@t3, @t4]], [[], []]]
+
+    bands = @Band.order(:bands__name).eager_graph({:albums=>:tracks}, :members).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.albums.map{|y| y.tracks}}.should == [[[@t1, @t2], [@t3, @t4]], [[], []]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+  end
+
+  specify "should have eager graphs work with previous joins" do
+    bands = @Band.order(:bands__name).select(:s__bands.*).join(:s__members, :band_id=>:id).from_self(:alias=>:bands0).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.albums.map{|y| y.tracks}}.should == [[[@t1, @t2], [@t3, @t4]], [[], []]]
+  end
+
+  specify "should have eager graphs work with joins with the same tables" do
+    bands = @Band.order(:bands__name).select(:s__bands.*).join(:s__members, :band_id=>:id).eager_graph({:albums=>:tracks}, :members).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.albums.map{|y| y.tracks}}.should == [[[@t1, @t2], [@t3, @t4]], [[], []]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+  end
+
+  specify "should have eager graphs work with self referential associations" do
+    bands = @Band.order(:bands__name).eager_graph(:tracks=>{:album=>:band}).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+    bands.map{|x| x.tracks.map{|y| y.album}}.should == [[@a1, @a1, @a2, @a2], []]
+    bands.map{|x| x.tracks.map{|y| y.album.band}}.should == [[@b1, @b1, @b1, @b1], []]
+
+    members = @Member.order(:members__name).eager_graph(:members).all
+    members.should == [@m4, @m3, @m1, @m2]
+    members.map{|x| x.members}.should == [[@m4, @m3], [@m4, @m3], [@m1, @m2], [@m1, @m2]]
+
+    members = @Member.order(:members__name).eager_graph(:band, :members=>:band).all
+    members.should == [@m4, @m3, @m1, @m2]
+    members.map{|x| x.band}.should == [@b2, @b2, @b1, @b1]
+    members.map{|x| x.members}.should == [[@m4, @m3], [@m4, @m3], [@m1, @m2], [@m1, @m2]]
+    members.map{|x| x.members.map{|y| y.band}}.should == [[@b2, @b2], [@b2, @b2], [@b1, @b1], [@b1, @b1]]
+  end
+
+  specify "should have eager graphs work with a from_self dataset" do
+    bands = @Band.order(:bands__name).from_self.eager_graph(:tracks=>{:album=>:band}).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+    bands.map{|x| x.tracks.map{|y| y.album}}.should == [[@a1, @a1, @a2, @a2], []]
+    bands.map{|x| x.tracks.map{|y| y.album.band}}.should == [[@b1, @b1, @b1, @b1], []]
+  end
+
+  specify "should have eager graphs work with different types of aliased from tables" do
+    bands = @Band.order(:tracks__name).from(:s__bands___tracks).eager_graph(:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+
+    bands = @Band.order(:tracks__name).from(:s__bands.as(:tracks)).eager_graph(:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+
+    bands = @Band.order(:tracks__name).from(:s__bands.as(:tracks.identifier)).eager_graph(:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+
+    bands = @Band.order(:tracks__name).from(:s__bands.as('tracks')).eager_graph(:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+  end
+
+  specify "should have eager graphs work with join tables with aliases" do
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums___tracks, :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums.as(:tracks), :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums.as('tracks'), :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums.as(:tracks.identifier), :band_id=>:id.qualify(:s__bands)).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>:id.qualify(:s__bands)}, :table_alias=>:tracks).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>:id.qualify(:s__bands)}, :table_alias=>'tracks').eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+
+    bands = @Band.order(:bands__name).eager_graph(:members).join(:s__albums, {:band_id=>:id.qualify(:s__bands)}, :table_alias=>:tracks.identifier).eager_graph(:albums=>:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.albums}.should == [[@a1, @a2], [@a3, @a4]]
+    bands.map{|x| x.members}.should == [[@m1, @m2], [@m4, @m3]]
+  end
+
+  specify "should have eager graphs work with different types of qualified from tables" do
+    bands = @Band.order(:bands__name).from(:bands.qualify(:s)).eager_graph(:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+
+    bands = @Band.order(:bands__name).from(:bands.identifier.qualify(:s)).eager_graph(:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+
+    bands = @Band.order(:bands__name).from(Sequel::SQL::QualifiedIdentifier.new(:s, 'bands')).eager_graph(:tracks).all
+    bands.should == [@b1, @b2]
+    bands.map{|x| x.tracks}.should == [[@t1, @t2, @t3, @t4], []]
+  end
+
+end
+
 if POSTGRES_DB.server_version >= 80300
 
   POSTGRES_DB.create_table! :test6 do