sequel 3.21.0 → 3.36.0

data/spec/extensions/sql_expr_spec.rb

@@ -1,89 +1,58 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
 describe "Sequel sql_expr extension" do
+  before do
+    @ds = Sequel.mock.dataset
+  end
+
   specify "Object#sql_expr should wrap the object in a GenericComplexExpression" do
     o = Object.new
+    def o.sql_literal(ds) 'foo' end
     s = o.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
-    s.op.should == :NOOP
-    s.args.should == [o]
-    (s+1).should be_a_kind_of(Sequel::SQL::NumericExpression)
-    (s & true).should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    (s < 1).should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.sql_subscript(1).should be_a_kind_of(Sequel::SQL::Subscript)
-    s.like('a').should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.as(:a).should be_a_kind_of(Sequel::SQL::AliasedExpression)
-    s.cast(Integer).should be_a_kind_of(Sequel::SQL::Cast)
-    s.desc.should be_a_kind_of(Sequel::SQL::OrderedExpression)
-    s.sql_string.should be_a_kind_of(Sequel::SQL::StringExpression)
+    @ds.literal(s).should == "foo"
+    @ds.literal(s+1).should == "(foo + 1)"
+    @ds.literal(s & true).should == "(foo AND 't')"
+    @ds.literal(s < 1).should == "(foo < 1)"
+    @ds.literal(s.sql_subscript(1)).should == "foo[1]"
+    @ds.literal(s.like('a')).should == "(foo LIKE 'a')"
+    @ds.literal(s.as(:a)).should == "foo AS a"
+    @ds.literal(s.cast(Integer)).should == "CAST(foo AS integer)"
+    @ds.literal(s.desc).should == "foo DESC"
+    @ds.literal(s.sql_string + '1').should == "(foo || '1')"
   end
 
   specify "Numeric#sql_expr should wrap the object in a NumericExpression" do
-    [1, 2.0, 2^40, BigDecimal.new('1.0')].each do |o|
-      s = o.sql_expr
-      s.should be_a_kind_of(Sequel::SQL::NumericExpression)
-      s.op.should == :NOOP
-      s.args.should == [o]
+    [1, 2.0, 2^70, BigDecimal.new('1.0')].each do |o|
+      @ds.literal(o.sql_expr).should == @ds.literal(o)
+      @ds.literal(o.sql_expr + 1).should == "(#{@ds.literal(o)} + 1)"
     end
   end
 
   specify "String#sql_expr should wrap the object in a StringExpression" do
-    o = ""
-    s = o.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::StringExpression)
-    s.op.should == :NOOP
-    s.args.should == [o]
+    @ds.literal("".sql_expr).should == "''"
+    @ds.literal("".sql_expr + :a).should == "('' || a)"
   end
 
   specify "NilClass, TrueClass, and FalseClass#sql_expr should wrap the object in a BooleanExpression" do
     [nil, true, false].each do |o|
-      s = o.sql_expr
-      s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
-      s.op.should == :NOOP
-      s.args.should == [o]
+      @ds.literal(o.sql_expr).should == @ds.literal(o)
+      @ds.literal(o.sql_expr & :a).should == "(#{@ds.literal(o)} AND a)"
     end
   end
 
   specify "Proc#sql_expr should should treat the object as a virtual row block" do
-    s = proc{a}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.value.should == :a
-
-    s = proc{a__b}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::QualifiedIdentifier)
-    s.table.should == "a"
-    s.column.should == "b"
-
-    s = proc{a(b)}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::Function)
-    s.f.should == :a
-    s.args.length.should == 1
-    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.first.value.should == :b
+    @ds.literal(proc{a}.sql_expr).should == "a"
+    @ds.literal(proc{a__b}.sql_expr).should == "a.b"
+    @ds.literal(proc{a(b)}.sql_expr).should == "a(b)"
   end
 
   specify "Proc#sql_expr should should wrap the object in a GenericComplexExpression if the object is not already an expression" do
-    s = proc{1}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::GenericComplexExpression)
-    s.op.should == :NOOP
-    s.args.should == [1]
+    @ds.literal(proc{1}.sql_expr).should == "1"
+    @ds.literal(proc{1}.sql_expr + 2).should == "(1 + 2)"
   end
 
   specify "Proc#sql_expr should should convert a hash or array of two element arrays to a BooleanExpression" do
-    s = proc{{a=>b}}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.op.should == :"="
-    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.first.value.should == :a
-    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.last.value.should == :b
-
-    s = proc{[[a,b]]}.sql_expr
-    s.should be_a_kind_of(Sequel::SQL::BooleanExpression)
-    s.op.should == :"="
-    s.args.first.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.first.value.should == :a
-    s.args.last.should be_a_kind_of(Sequel::SQL::Identifier)
-    s.args.last.value.should == :b
+    @ds.literal(proc{{a=>b}}.sql_expr).should == "(a = b)"
+    @ds.literal(proc{[[a, b]]}.sql_expr & :a).should == "((a = b) AND a)"
   end
 end

data/spec/extensions/static_cache_spec.rb

@@ -0,0 +1,145 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::StaticCache" do
+  before do
+    @db = Sequel.mock
+    @db.fetch = [{:id=>1}, {:id=>2}]
+    @c = Class.new(Sequel::Model(@db[:t]))
+    @c.columns :id
+    @c.plugin :static_cache
+    @c1 = @c.cache[1]
+    @c2 = @c.cache[2]
+    @db.sqls
+  end
+
+  it "should use a ruby hash as a cache of all model instances" do
+    @c.cache.should == {1=>@c.load(:id=>1), 2=>@c.load(:id=>2)}
+  end
+
+  it "should work correctly with composite keys" do
+    @db.fetch = [{:id=>1, :id2=>1}, {:id=>2, :id2=>1}]
+    @c = Class.new(Sequel::Model(@db[:t]))
+    @c.columns :id, :id2
+    @c.set_primary_key([:id, :id2])
+    @c.plugin :static_cache
+    @db.sqls
+    @c1 = @c.cache[[1, 2]]
+    @c2 = @c.cache[[2, 1]]
+    @c[[1, 2]].should equal(@c1)
+    @c[[2, 1]].should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should make .[] method with primary key use the cache" do
+    @c[1].should equal(@c1)
+    @c[2].should equal(@c2)
+    @c[3].should be_nil
+    @c[[1, 2]].should be_nil
+    @c[nil].should be_nil
+    @c[].should be_nil
+    @db.sqls.should == []
+  end
+
+  it "should have .[] with a hash not use the cache" do
+    @db.fetch = {:id=>2}
+    @c[:id=>2].should == @c2
+    @db.sqls.should == ['SELECT * FROM t WHERE (id = 2) LIMIT 1']
+  end
+
+  it "should support cache_get_pk" do
+    @c.cache_get_pk(1).should equal(@c1)
+    @c.cache_get_pk(2).should equal(@c2)
+    @c.cache_get_pk(3).should be_nil
+    @db.sqls.should == []
+  end
+
+  it "should have each just iterate over the hash's values without sending a query" do
+    a = []
+    @c.each{|o| a << o}
+    a = a.sort_by{|o| o.id}
+    a.first.should equal(@c1)
+    a.last.should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have map just iterate over the hash's values without sending a query if no argument is given" do
+    @c.map{|v| v.id}.sort.should == [1, 2]
+    @db.sqls.should == []
+  end
+
+  it "should have map send a query if given an argument" do
+    @c.map(:id).sort.should == [1, 2]
+    @db.sqls.should == ["SELECT * FROM t"]
+  end
+
+  it "should have map without a block or argument not raise an exception or issue a query" do
+    @c.map
+    @db.sqls.should == []
+  end
+
+  it "should have map without a block not return a frozen object" do
+    @c.map.frozen?.should be_false
+  end
+
+  it "should have other enumerable methods work without sending a query" do
+    a = @c.sort_by{|o| o.id}
+    a.first.should equal(@c1)
+    a.last.should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have all just return the hashes' values" do
+    a = @c.all.sort_by{|o| o.id}
+    a.first.should equal(@c1)
+    a.last.should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have all not return a frozen object" do
+    @c.all.frozen?.should be_false
+  end
+
+  it "should have all return things in dataset order" do
+    @c.all.should == [@c1, @c2]
+  end
+
+  it "should have to_hash without arguments return the cached objects without a query" do
+    a = @c.to_hash
+    a[1].should equal(@c1)
+    a[2].should equal(@c2)
+    @db.sqls.should == []
+  end
+
+  it "should have to_hash with any arguments use a query" do
+    @c.to_hash(:id).should == {1=>@c1, 2=>@c2}
+    @db.sqls.should == ['SELECT * FROM t']
+    @c.to_hash(:id, :id).should == {1=>1, 2=>2}
+    @db.sqls.should == ['SELECT * FROM t']
+  end
+
+  it "should have all not return a frozen object" do
+    @c.to_hash.frozen?.should be_false
+  end
+
+  it "all of the static cache values (model instances) should be frozen" do
+    @c.all.all?{|o| o.frozen?}.should be_true
+  end
+
+  it "subclasses should work correctly" do
+    c = Class.new(@c)
+    c.all.should == [c.load(:id=>1), c.load(:id=>2)]
+    c.to_hash.should == {1=>c.load(:id=>1), 2=>c.load(:id=>2)}
+    @db.sqls.should == ['SELECT * FROM t']
+  end
+
+  it "set_dataset should work correctly" do
+    ds = @c.dataset.from(:t2)
+    ds.instance_variable_set(:@columns, [:id])
+    ds._fetch = {:id=>3}
+    @c.dataset = ds
+    @c.all.should == [@c.load(:id=>3)]
+    @c.to_hash.should == {3=>@c.load(:id=>3)}
+    @c.to_hash[3].should equal(@c.all.first)
+    @db.sqls.should == ['SELECT * FROM t2']
+  end
+end

data/spec/extensions/tactical_eager_loading_spec.rb

@@ -7,23 +7,13 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
       columns :id, :parent_id
       many_to_one :parent, :class=>self
       one_to_many :children, :class=>self, :key=>:parent_id
-      ds = dataset
-      def ds.fetch_rows(sql)
-        execute(sql)
-        where = @opts[:where]
-        if !where
-          yield(:id=>1, :parent_id=>101)
-          yield(:id=>2, :parent_id=>102)
-          yield(:id=>101, :parent_id=>nil)
-          yield(:id=>102, :parent_id=>nil)
-        elsif where.args.first.column == :id
-          Array(where.args.last).each do |x|
-            yield(:id=>x, :parent_id=>nil)
-          end
-        elsif where.args.first.column == :parent_id
-          Array(where.args.last).each do |x|
-            yield(:id=>x-100, :parent_id=>x) if x > 100
-          end
+      dataset._fetch = proc do |sql|
+        if sql !~ /WHERE/
+          [{:id=>1, :parent_id=>101}, {:id=>2, :parent_id=>102}, {:id=>101, :parent_id=>nil}, {:id=>102, :parent_id=>nil}]
+        elsif sql =~ /WHERE.*\bid IN \(([\d, ]*)\)/
+          $1.split(', ').map{|x| {:id=>x.to_i, :parent_id=>nil}}
+        elsif sql =~ /WHERE.*\bparent_id IN \(([\d, ]*)\)/
+          $1.split(', ').map{|x| {:id=>x.to_i - 100, :parent_id=>x.to_i} if x.to_i > 100}.compact
         end
       end
     end
@@ -49,9 +39,9 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     ts = @c.all
     MODEL_DB.sqls.length.should == 1
     ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 1
     ts.map{|x| x.children}.should == [[], [], [ts[0]], [ts[1]]]
-    MODEL_DB.sqls.length.should == 3
+    MODEL_DB.sqls.length.should == 1
   end
 
   it "association getter methods should not eagerly load the association if the association is cached" do
@@ -62,4 +52,12 @@ describe "Sequel::Plugins::TacticalEagerLoading" do
     @ds.should_not_receive(:eager_load)
     ts.map{|x| x.parent}.should == [ts[2], ts[3], nil, nil]
   end
+
+  it "should handle case where an association is valid on an instance, but not on all instances" do
+    c = Class.new(@c)
+    c.many_to_one :parent2, :class=>@c, :key=>:parent_id
+    @c.dataset.row_proc = proc{|r| (r[:parent_id] == 101 ? c : @c).call(r)}
+    @c.all{|x| x.parent2 if x.is_a?(c)}
+  end
+
 end

data/spec/extensions/thread_local_timezones_spec.rb

@@ -39,7 +39,27 @@ describe "Sequel thread_local_timezones extension" do
   end
     
   it "should be thread safe" do
-    [Thread.new{Sequel.thread_application_timezone = :utc; sleep 0.03; Sequel.application_timezone.should == :utc},
-     Thread.new{sleep 0.01; Sequel.thread_application_timezone = :local; sleep 0.01; Sequel.application_timezone.should == :local}].each{|x| x.join}
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
+    tz1, tz2 = nil, nil
+    t1 = Thread.new do
+      Sequel.thread_application_timezone = :utc
+      q2.push nil
+      q.pop
+      tz1 = Sequel.application_timezone
+    end
+    t2 = Thread.new do
+      Sequel.thread_application_timezone = :local
+      q2.push nil
+      q1.pop
+      tz2 = Sequel.application_timezone
+    end
+    q2.pop
+    q2.pop
+    q.push nil
+    q1.push nil
+    t1.join
+    t2.join
+    tz1.should == :utc
+    tz2.should == :local
   end
 end

data/spec/extensions/timestamps_spec.rb

@@ -13,9 +13,10 @@ describe "Sequel::Plugins::Timestamps" do
     @c.class_eval do
       columns :id, :created_at, :updated_at
       plugin :timestamps
+      def _save_refresh(*) end
       db.reset
-      def _refresh(ds); self end
     end
+    @c.dataset.autoid = nil
   end 
   after do
     Sequel.datetime_class = Time
@@ -40,8 +41,9 @@ describe "Sequel::Plugins::Timestamps" do
   it "should use the same value for the creation and update timestamps when creating if the :update_on_create option is given" do
     @c.plugin :timestamps, :update_on_create=>true
     o = @c.create
-    @c.db.sqls.length.should == 1
-    @c.db.sqls.first.should =~ /INSERT INTO t \((creat|updat)ed_at, (creat|updat)ed_at\) VALUES \('2009-08-01', '2009-08-01'\)/
+    sqls = @c.db.sqls
+    sqls.shift.should =~ /INSERT INTO t \((creat|updat)ed_at, (creat|updat)ed_at\) VALUES \('2009-08-01', '2009-08-01'\)/
+    sqls.should == []
     o.created_at.should === o.updated_at
   end
 
@@ -50,8 +52,7 @@ describe "Sequel::Plugins::Timestamps" do
     c.class_eval do
       columns :id, :c
       plugin :timestamps, :create=>:c
-      db.reset
-      def _refresh(ds); self end
+      def _save_refresh(*) end
     end
     o = c.create
     c.db.sqls.should == ["INSERT INTO t (c) VALUES ('2009-08-01')"]
@@ -64,7 +65,6 @@ describe "Sequel::Plugins::Timestamps" do
       columns :id, :u
       plugin :timestamps, :update=>:u
       db.reset
-      def _refresh(ds); self end
     end
     o = c.load(:id=>1).save
     c.db.sqls.should == ["UPDATE t SET u = '2009-08-01' WHERE (id = 1)"]

data/spec/extensions/to_dot_spec.rb

@@ -2,9 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "to_dot extension" do
   def dot(ds)
-    a = []
-    ds.send(:_to_dot, a, "", 0, ds, 0)
-    a[2..-1]
+    Sequel::ToDot.new(ds).instance_variable_get(:@dot)[4...-1]
   end
 
   before do
@@ -13,14 +11,13 @@ describe Sequel::Model, "to_dot extension" do
   end
 
   it "should output a string suitable for input to the graphviz dot program" do
-    @ds.to_dot.should == (<<END
+    @ds.to_dot.should == (<<END).strip
 digraph G {
 0 [label="self"];
 0 -> 1 [label=""];
 1 [label="Dataset"];
 }
 END
-).strip
   end
 
   it "should handle an empty dataset" do
@@ -123,7 +120,7 @@ END
   end
 
   it "should handle SQL::Subscript" do
-    dot(@ds.select(:a.sql_subscript(1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript: a\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
+    dot(@ds.select(:a.sql_subscript(1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
   end
 
   it "should handle SQL::WindowFunction" do
@@ -135,7 +132,7 @@ END
   end
 
   it "should handle JOIN ON" do
-    dot(@ds.from(:a).join(:d, :b=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN ON\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"on\"];", "7 [label=\"Array\"];", "7 -> 8 [label=\"0\"];", "8 [label=\"Array\"];", "8 -> 9 [label=\"0\"];", "9 [label=\"QualifiedIdentifier\"];", "9 -> 10 [label=\"table\"];", "10 [label=\"\\\"d\\\"\"];", "9 -> 11 [label=\"column\"];", "11 [label=\"\\\"b\\\"\"];", "8 -> 12 [label=\"1\"];", "12 [label=\"QualifiedIdentifier\"];", "12 -> 13 [label=\"table\"];", "13 [label=\"\\\"a\\\"\"];", "12 -> 14 [label=\"column\"];", "14 [label=\"\\\"c\\\"\"];"]
+    dot(@ds.from(:a).join(:d, :b=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN ON\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"on\"];", "7 [label=\"ComplexExpression: =\"];", "7 -> 8 [label=\"0\"];", "8 [label=\"QualifiedIdentifier\"];", "8 -> 9 [label=\"table\"];", "9 [label=\"\\\"d\\\"\"];", "8 -> 10 [label=\"column\"];", "10 [label=\"\\\"b\\\"\"];", "7 -> 11 [label=\"1\"];", "11 [label=\"QualifiedIdentifier\"];", "11 -> 12 [label=\"table\"];", "12 [label=\"\\\"a\\\"\"];", "11 -> 13 [label=\"column\"];", "13 [label=\"\\\"c\\\"\"];"]
   end
 
   it "should handle JOIN USING" do

data/spec/extensions/touch_spec.rb

@@ -2,9 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Touch plugin" do
   before do
-    @c = Class.new(Sequel::Model) do
-      def _refresh(*); end 
-    end
+    @c = Class.new(Sequel::Model)
     p = proc{def touch_instance_value; touch_association_value; end}
     @Artist = Class.new(@c, &p).set_dataset(:artists)
     @Album = Class.new(@c, &p).set_dataset(:albums)
@@ -63,8 +61,9 @@ describe "Touch plugin" do
   specify "should be able to give an array to the :associations option specifying multiple associations" do
     @Album.plugin :touch, :associations=>[:artist, :followup_albums]
     @Album.load(:id=>4, :artist_id=>1).touch
-    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    sqls.sort.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -85,8 +84,9 @@ describe "Touch plugin" do
   specify "should allow the mixed use of symbols and hashes inside an array for the :associations option" do
     @Album.plugin :touch, :associations=>[:artist, {:followup_albums=>:modified_on}]
     @Album.load(:id=>4, :artist_id=>1).touch
-    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -94,8 +94,9 @@ describe "Touch plugin" do
     @Album.plugin :touch
     @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
     @Album.load(:id=>4, :artist_id=>1).touch
-    MODEL_DB.sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"
+    sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -103,8 +104,9 @@ describe "Touch plugin" do
     @Album.plugin :touch
     @Album.touch_associations(:artist, {:followup_albums=>:modified_on})
     @Album.load(:id=>4, :artist_id=>1).destroy
-    MODEL_DB.sqls.shift.should == "DELETE FROM albums WHERE (id = 4)"
-    MODEL_DB.sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
+    sqls = MODEL_DB.sqls
+    sqls.shift.should == "DELETE FROM albums WHERE id = 4"
+    sqls.sort.should == ["UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.original_album_id = 4)",
       "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 1)"]
   end
 
@@ -133,18 +135,15 @@ describe "Touch plugin" do
     c1 = Class.new(@Artist)
     c1.load(:id=>4).touch
     MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 4)"]
-    MODEL_DB.reset
 
     c1.touch_column = :modified_on
     c1.touch_associations :albums
     c1.load(:id=>1).touch
     MODEL_DB.sqls.should == ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 1)",
       "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
-    MODEL_DB.reset
 
     @a.touch
     MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
-    MODEL_DB.reset
 
     @Artist.plugin :touch, :column=>:modified_on, :associations=>:albums
     c2 = Class.new(@Artist)

data/spec/extensions/tree_spec.rb

@@ -7,26 +7,11 @@ describe Sequel::Model, "tree plugin" do
     c.class_eval do
       def self.name; 'Node'; end
       columns :id, :name, :parent_id, :i, :pi
+      plugin :tree, opts
     end
-    ds = c.dataset
-    class << ds
-      attr_accessor :row_sets
-      def fetch_rows(sql)
-        @db << sql
-        if rs = row_sets.shift
-          rs.each{|row| yield row}
-        end
-      end
-    end
-    c.plugin :tree, opts
     c
   end
 
-  def y(c, *hs)
-    ds = c.dataset
-    ds.row_sets = hs
-  end
-
   before do
     @c = klass
     @ds = @c.dataset
@@ -71,7 +56,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have roots return an array of the tree's roots" do
-    y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+    @ds._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
     @c.roots.should == [@c.load(:id=>1, :parent_id=>nil, :name=>'r')]
     @db.sqls.should == ["SELECT * FROM nodes WHERE (parent_id IS NULL)"]
   end
@@ -81,14 +66,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have ancestors return the ancestors of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.ancestors.should == [@c.load(:id=>1, :parent_id=>5, :name=>'r'), @c.load(:id=>5, :parent_id=>nil, :name=>'r2')]
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
   end
 
   it "should have descendants return the descendants of the current node" do
-    y(@c, [{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], [])
+    @ds._fetch = [[{:id=>3, :parent_id=>2, :name=>'r'}, {:id=>4, :parent_id=>2, :name=>'r2'}], [{:id=>5, :parent_id=>4, :name=>'r3'}], []]
     @o.descendants.should == [@c.load(:id=>3, :parent_id=>2, :name=>'r'), @c.load(:id=>4, :parent_id=>2, :name=>'r2'), @c.load(:id=>5, :parent_id=>4, :name=>'r3')] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.parent_id = 2)",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 3)",
@@ -97,7 +82,7 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have root return the root of the current node" do
-    y(@c, [{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}])
+    @ds._fetch = [[{:id=>1, :parent_id=>5, :name=>'r'}], [{:id=>5, :parent_id=>nil, :name=>'r2'}]]
     @o.root.should == @c.load(:id=>5, :parent_id=>nil, :name=>'r2')
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.id = 5) LIMIT 1"]
@@ -113,14 +98,14 @@ describe Sequel::Model, "tree plugin" do
   end
 
   it "should have self_and_siblings return the children of the current node's parent" do
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.self_and_siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2'), @o] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
   end
 
   it "should have siblings return the children of the current node's parent, except for the current node" do
-    y(@c, [{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup])
+    @ds._fetch = [[{:id=>1, :parent_id=>3, :name=>'r'}], [{:id=>7, :parent_id=>1, :name=>'r2'}, @o.values.dup]]
     @o.siblings.should == [@c.load(:id=>7, :parent_id=>1, :name=>'r2')] 
     @db.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1",
       "SELECT * FROM nodes WHERE (nodes.parent_id = 1)"]
@@ -132,23 +117,23 @@ describe Sequel::Model, "tree plugin" do
     end
 
     it "should have root class method return the root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       @c.root.should == @c.load(:id=>1, :parent_id=>nil, :name=>'r')
     end
 
     it "prevents creating a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.create }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "errors when promoting an existing record to a second root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       n = @c.load(:id => 2, :parent_id => 1)
       lambda { n.update(:parent_id => nil) }.should raise_error(Sequel::Plugins::Tree::TreeMultipleRootError)
     end
 
     it "allows updating existing root" do
-      y(@c, [{:id=>1, :parent_id=>nil, :name=>'r'}])
+      @c.dataset._fetch = [{:id=>1, :parent_id=>nil, :name=>'r'}]
       lambda { @c.root.update(:name => 'fdsa') }.should_not raise_error
     end
   end

data/spec/extensions/typecast_on_load_spec.rb

@@ -2,22 +2,17 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "TypecastOnLoad plugin" do
   before do
-    @db = Sequel::Database.new({})
+    @db = Sequel.mock(:fetch=>{:id=>1, :b=>"1", :y=>"0"}, :columns=>[:id, :b, :y], :numrows=>1)
     def @db.schema(*args)
       [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
     end
     @c = Class.new(Sequel::Model(@db[:items])) do
-      include(Module.new{def _refresh(ds); values[:b] = b.to_s; self; end})
       attr_accessor :bset
       def b=(x)
         self.bset = true
         super
       end
     end
-    @c.instance_eval do
-      @columns = [:id, :b, :y]
-      def columns; @columns; end
-    end
   end 
 
   specify "should call setter method with value when loading the object, for all given columns" do
@@ -35,6 +30,14 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
     o.bset.should == true
   end
 
+  specify "should call setter method with value when automatically reloading the object on creation via insert_select" do
+    @c.plugin :typecast_on_load, :b
+    @c.dataset.meta_def(:insert_select){|h| insert(h); first}
+    o = @c.new({:id=>1, :b=>"1", :y=>"0"}, true)
+    o.save.values.should == {:id=>1, :b=>1, :y=>"0"}
+    o.bset.should == true
+  end
+
   specify "should allowing setting columns separately via add_typecast_on_load_columns" do
     @c.plugin :typecast_on_load
     @c.load(:id=>1, :b=>"1", :y=>"0").values.should == {:id=>1, :b=>"1", :y=>"0"}