sequel 3.21.0 → 3.31.0

data/spec/extensions/association_dependencies_spec.rb

@@ -6,17 +6,9 @@ describe "AssociationDependencies plugin" do
     @c = Class.new(Sequel::Model)
     @c.plugin :association_dependencies
     @Artist = Class.new(@c).set_dataset(:artists)
-    ds1 = @Artist.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>2, :name=>'Ar'})
-    end
+    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
     @Album = Class.new(@c).set_dataset(:albums)
-    ds1 = @Album.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>1, :name=>'Al', :artist_id=>2})
-    end
+    @Album.dataset._fetch = {:id=>1, :name=>'Al', :artist_id=>2}
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
@@ -113,11 +105,9 @@ describe "AssociationDependencies plugin" do
     c.add_association_dependencies :artist=>:destroy
     c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
     MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
-    MODEL_DB.reset
 
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
     MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)']
-    MODEL_DB.reset
 
     @Album.add_association_dependencies :artist=>:destroy
     c2 = Class.new(@Album)

data/spec/extensions/association_pks_spec.rb

@@ -2,31 +2,18 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::AssociationPks" do
   before do
-    @db = MODEL_DB.clone
-    mod = Module.new do
-      def fetch_rows(sql)
-        case sql
-        when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
-          yield({:id=>1})
-          yield({:id=>2})
-          yield({:id=>3})
-        when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
-          yield({:tag_id=>1}) if $1 == '1'
-          yield({:tag_id=>2}) if $1 != '3'
-          yield({:tag_id=>3}) if $1 == '2'
-        end
+    @db = Sequel.mock(:fetch=>proc do |sql|
+      case sql
+      when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
+        [{:id=>1}, {:id=>2}, {:id=>3}]
+      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
+        a = []
+        a << {:tag_id=>1} if $1 == '1'
+        a << {:tag_id=>2} if $1 != '3'
+        a << {:tag_id=>3} if $1 == '2'
+        a
       end
-    end
-    @db.meta_def(:dataset) do |*opts|
-      ds = super(*opts)
-      ds.extend mod
-      ds
-    end
-    def @db.transaction(opts)
-      execute('BEGIN')
-      yield
-      execute('COMMIT')
-    end
+    end)
     @Artist = Class.new(Sequel::Model(@db[:artists]))
     @Artist.columns :id
     @Album= Class.new(Sequel::Model(@db[:albums]))
@@ -37,7 +24,7 @@ describe "Sequel::Plugins::AssociationPks" do
     @Album.plugin :association_pks
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
     @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
-    @db.reset
+    @db.sqls
   end
 
   specify "should return correct associated pks for one_to_many associations" do
@@ -57,10 +44,20 @@ describe "Sequel::Plugins::AssociationPks" do
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
   end
 
+  specify "should use associated class's primary key for a one_to_many association" do
+    @Album.set_primary_key :foo
+    @Artist.load(:id=>1).album_pks = [1, 2]
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (foo IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (foo NOT IN (1, 2)))"]
+  end
+
   specify "should set associated pks correctly for a many_to_many association" do
     @Album.load(:id=>2).tag_pks = [1, 3]
-    @db.sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    @db.sqls[1].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls.length.should == 3
   end
 
   specify "should use transactions if the object is configured to use transactions" do
@@ -71,15 +68,52 @@ describe "Sequel::Plugins::AssociationPks" do
       "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))",
       "COMMIT"]
-    @db.reset
 
     album = @Album.load(:id=>2)
     album.use_transactions = true
     album.tag_pks = [1, 3]
-    @db.sqls[0].should == "BEGIN"
-    @db.sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    @db.sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
-    @db.sqls[3].should == "COMMIT"
+    sqls = @db.sqls
+    sqls[0].should == "BEGIN"
+    sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[2].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls[4].should == "COMMIT"
+    sqls.length.should == 5
+  end
+
+  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+    @Album.db_schema[:id][:type] = :integer
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
+  end
+
+  specify "should not automatically convert keys if the primary key is not an integer for many_to_many associations" do
+    @Album.db_schema[:id][:type] = :string
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (id IN ('1', '2'))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN ('1', '2')))"]
+  end
+
+  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+    @Tag.db_schema[:id][:type] = :integer
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls.length.should == 3
+  end
+
+  specify "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
+    @Tag.db_schema[:id][:type] = :string
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/
+    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/
+    sqls.length.should == 4
   end
 
 end

data/spec/extensions/caching_spec.rb

@@ -2,8 +2,6 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "caching" do
   before do
-    MODEL_DB.reset
-    
     @cache_class = Class.new(Hash) do
       attr_accessor :ttl
       def set(k, v, ttl); self[k] = v; @ttl = ttl; end
@@ -44,31 +42,14 @@ describe Sequel::Model, "caching" do
       columns :name, :id
     end
    
-
-    $cache_dataset_row = {:name => 'sharon', :id => 1}
     @dataset = @c.dataset = @c3.dataset = @c4.dataset
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield $cache_dataset_row
-      end
-      
-      def update(values)
-        $sqls << update_sql(values)
-        $cache_dataset_row.merge!(values)
-        1
-      end
-      
-      def delete
-        $sqls << delete_sql
-        1
-      end
-    })
+    @dataset._fetch = {:name => 'sharon', :id => 1}
+    @dataset.numrows = 1
     
     @c2 = Class.new(@c) do
       def self.name; 'SubItem' end
     end    
+    @c.db.reset
   end
   
   it "should set the model's cache store" do
@@ -154,27 +135,26 @@ describe Sequel::Model, "caching" do
   end
   
   it "should set the cache when reading from the database" do
-    $sqls.should == []
+    @c.db.sqls.should == []
     @cache.should be_empty
     
     m = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m.values.should == $cache_dataset_row
+    @c.db.sqls.should == ['SELECT * FROM items WHERE id = 1']
+    m.values.should == {:name=>"sharon", :id=>1}
     @cache[m.cache_key].should == m
     m2 = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    @c.db.sqls.should == []
     m2.should == m
-    m2.values.should == $cache_dataset_row
+    m2.values.should == {:name=>"sharon", :id=>1}
 
-    $sqls.clear
     m = @c2[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m.values.should == $cache_dataset_row
+    @c.db.sqls.should == ['SELECT * FROM items WHERE id = 1']
+    m.values.should == {:name=>"sharon", :id=>1}
     @cache[m.cache_key].should == m
     m2 = @c2[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    @c.db.sqls.should == []
     m2.should == m
-    m2.values.should == $cache_dataset_row
+    m2.values.should == {:name=>"sharon", :id=>1}
   end
   
   it "should delete the cache when writing to the database" do
@@ -183,14 +163,14 @@ describe Sequel::Model, "caching" do
     m.name = 'hey'
     m.save
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey' WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
 
     m = @c2[1]
     @cache[m.cache_key].should == m
     m.name = 'hey'
     m.save
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey' WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
   end
 
   it "should delete the cache when deleting the record" do
@@ -198,40 +178,33 @@ describe Sequel::Model, "caching" do
     @cache[m.cache_key].should == m
     m.delete
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE (id = 1)"]
 
     m = @c2[1]
     @cache[m.cache_key].should == m
     m.delete
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE (id = 1)"]
   end
   
   it "should support #[] as a shortcut to #find with hash" do
     m = @c[:id => 3]
     @cache[m.cache_key].should be_nil
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c[1]
     @cache[m.cache_key].should == m
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1"]
     @c[:id => 4]
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
 
-    $sqls.clear
     m = @c2[:id => 3]
     @cache[m.cache_key].should be_nil
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c2[1]
     @cache[m.cache_key].should == m
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1"]
     @c2[:id => 4]
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
   end
   
   it "should support ignore_exception option" do
@@ -245,6 +218,6 @@ describe Sequel::Model, "caching" do
   end
   
   it "should rescue an exception if cache_store is memcached and ignore_exception is enabled" do
-    @c4[1].values.should == $cache_dataset_row
+    @c4[1].values.should == {:name => 'sharon', :id => 1}
   end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -2,17 +2,16 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "class_table_inheritance plugin" do
   before do
-    @db = db = MODEL_DB.clone
-    def db.schema(table, opts={})
+    @db = Sequel.mock(:autoid=>proc{|sql| 1})
+    def @db.schema(table, opts={})
       {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
        :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}]],
        :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
        :staff=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
-       }[table]
+       }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
      end
-    def db.dataset(*args)
-      ds = super(*args)
-      def ds.columns
+    @db.extend_datasets do
+      def columns
         {[:employees]=>[:id, :name, :kind],
          [:managers]=>[:id, :num_staff],
          [:executives]=>[:id, :num_managers],
@@ -22,13 +21,8 @@ describe "class_table_inheritance plugin" do
          [:employees, :staff]=>[:id, :name, :kind, :manager_id],
         }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
       end
-      def ds.insert(*args)
-        db << insert_sql(*args)
-        1
-      end
-      ds
     end
-    class ::Employee < Sequel::Model(db)
+    class ::Employee < Sequel::Model(@db)
       def _refresh(x); @values[:id] = 1 end
       def self.columns
         dataset.columns
@@ -44,7 +38,7 @@ describe "class_table_inheritance plugin" do
       many_to_one :manager
     end 
     @ds = Employee.dataset
-    @db.reset
+    @db.sqls
   end
   after do
     Object.send(:remove_const, :Executive)
@@ -53,8 +47,8 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Employee)
   end
 
-  specify "should have simple_table = nil" do
-    Employee.simple_table.should == nil
+  specify "should have simple_table = nil for subclasses" do
+    Employee.simple_table.should == "employees"
     Manager.simple_table.should == nil
     Executive.simple_table.should == nil
     Staff.simple_table.should == nil
@@ -68,33 +62,18 @@ describe "class_table_inheritance plugin" do
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'Employee'})
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-      yield({:kind=>'Staff'})
-    end 
+    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Manager, Executive, Staff]
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-    end 
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
     Manager.all.collect{|x| x.class}.should == [Manager, Executive]
   end
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
-    ds = Employee.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Employee'})
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-      yield({:kind=>'Staff'})
-    end 
+    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Employee, Employee, Employee]
   end
   
@@ -102,35 +81,19 @@ describe "class_table_inheritance plugin" do
     Employee.plugin(:class_table_inheritance)
     Object.send(:remove_const, :Executive)
     Object.send(:remove_const, :Manager)
-    class ::Manager < Employee
-    end 
-    class ::Executive < Manager
-    end 
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-    end 
+    class ::Manager < Employee; end 
+    class ::Executive < Manager; end 
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
     Manager.all.collect{|x| x.class}.should == [Manager, Manager]
   end
   
   it "should fallback to the main class if the given class does not exist" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'Employee'})
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Blah'})
-      yield({:kind=>'Staff'})
-    end 
+    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Blah'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Manager, Employee, Staff]
   end
   
   it "should fallback to the main class if the given class does not exist in subclasses" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-      yield({:kind=>'Blah'})
-    end 
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Blah'}]
     Manager.all.collect{|x| x.class}.should == [Manager, Executive, Manager]
   end
 
@@ -167,19 +130,10 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should lazily load attributes for columns in subclass tables" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2})
-    end
+    Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2}
     m = Manager[1]
     @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (id = 1) LIMIT 1']
-    @db.reset
-    ds = Executive.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:num_managers=>3})
-    end
+    Executive.dataset._fetch = {:num_managers=>3}
     m.num_managers.should == 3
     @db.sqls.should == ['SELECT num_managers FROM employees INNER JOIN managers USING (id) INNER JOIN executives USING (id) WHERE (id = 1) LIMIT 1']
     m.values.should == {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3}
@@ -210,20 +164,22 @@ describe "class_table_inheritance plugin" do
 
   it "should insert the correct rows into all tables when inserting" do
     Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
-    @db.sqls.length.should == 3
-    @db.sqls[0].should =~ /INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/
-    @db.sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/
-    @db.sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/
+    sqls = @db.sqls
+    sqls.length.should == 3
+    sqls[0].should =~ /INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/
+    sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/
+    sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/
     end
     
   it "should insert the correct rows into all tables with a given primary key" do
     e = Executive.new(:num_managers=>3, :num_staff=>2, :name=>'E')
     e.id = 2
     e.save
-    @db.sqls.length.should == 3
-    @db.sqls[0].should =~ /INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/
-    @db.sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/
-    @db.sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/
+    sqls = @db.sqls
+    sqls.length.should == 3
+    sqls[0].should =~ /INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/
+    sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/
+    sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/
   end
 
   it "should update the correct rows in all tables when updating" do
@@ -232,21 +188,13 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should handle many_to_one relationships correctly" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3})
-    end
+    Manager.dataset._fetch = {:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3}
     Staff.load(:manager_id=>3).manager.should == Executive.load(:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3)
     @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (managers.id = 3) LIMIT 1']
   end
   
   it "should handle one_to_many relationships correctly" do
-    ds = Staff.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3})
-    end
+    Staff.dataset._fetch = {:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3}
     Executive.load(:id=>3).staff_members.should == [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
     @db.sqls.should == ['SELECT * FROM employees INNER JOIN staff USING (id) WHERE (staff.manager_id = 3)']
   end

data/spec/extensions/columns_introspection_spec.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe "Sequel::Dataset.introspect_all_columns" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    class Sequel::Dataset
+      # Handle case where introspect_all_columns has already been called
+      alias columns columns_without_introspection unless instance_methods(false).map{|x| x.to_s}.include?('columns')
+    end
+    Sequel::Dataset.introspect_all_columns
+    @db.reset
+  end
+  after do
+    class Sequel::Dataset
+      alias columns columns_without_introspection
+    end
+  end
+
+  specify "should turn on column introspection by default" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+end
+
+describe "columns_introspection extension" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    @ds.extend(Sequel::ColumnsIntrospection.dup) # dup to allow multiple places in class hierarchy
+    @db.reset
+  end
+
+  specify "should not issue a database query if the columns are already loaded" do
+    @ds.instance_variable_set(:@columns, [:x])
+    @ds.columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+  
+  specify "should handle plain symbols without a database query" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified symbols without a database query" do
+    @ds.select(:t__x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle aliased symbols without a database query" do
+    @ds.select(:x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified and aliased symbols without a database query" do
+    @ds.select(:t__x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::Identifiers " do
+    @ds.select(:x.identifier).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers" do
+    @ds.select(:x.qualify(:t)).columns.should == [:x]
+    @ds.select(:x.identifier.qualify(:t)).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::AliasedExpressions" do
+    @ds.select(:x.as(:a)).columns.should == [:a]
+    @ds.select(:x.as(:a.identifier)).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should issue a database query if the wildcard is selected" do
+    @ds.columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should issue a database query if an unsupported type is used" do
+    @ds.select(1).columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should not have column introspection on by default" do
+    @db[:a].select(:x).columns
+    @db.sqls.length.should == 1
+  end
+end