sequel 3.29.0 → 3.30.0

data/spec/extensions/schema_dumper_spec.rb

@@ -43,19 +43,17 @@ describe "Sequel::Schema::Generator dump methods" do
       index [:b, :c], :unique=>true
     end
 
-    t = <<END_CODE
+    g.dump_indexes(:add_index=>:t).should == (<<END_CODE).strip
 add_index :t, [:a]
 add_index :t, [:c, :e], :name=>:blah
 add_index :t, [:b, :c], :unique=>true
 END_CODE
-    g.dump_indexes(:add_index=>:t).should == t.strip
 
-    t = <<END_CODE
+    g.dump_indexes(:drop_index=>:t).should == (<<END_CODE).strip
 drop_index :t, [:a]
 drop_index :t, [:c, :e], :name=>:blah
 drop_index :t, [:b, :c], :unique=>true
 END_CODE
-    g.dump_indexes(:drop_index=>:t).should == t.strip
   end
 
   it "should raise an error if you try to dump a Generator that uses a constraint with a proc" do
@@ -296,7 +294,7 @@ END_MIG
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
     end
-    table = <<END_MIG
+    @d.dump_table_schema(:x).should == (<<END_MIG).chomp
 create_table(:x) do
   Integer :c1
   Integer :c2
@@ -365,6 +363,5 @@ create_table(:x) do
   Bignum :c65
 end
 END_MIG
-    @d.dump_table_schema(:x).should == table.chomp
   end
 end

data/spec/extensions/serialization_spec.rb

@@ -9,10 +9,6 @@ else
 describe "Serialization plugin" do
   before do
     @c = Class.new(Sequel::Model(:items)) do
-      include(Module.new do
-        def before_save
-        end
-      end)
       no_primary_key
       columns :id, :abc, :def, :ghi
     end
@@ -79,11 +75,7 @@ describe "Serialization plugin" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def
     vals = nil
-
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    end
+    @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
 
     o = @c.first
     o.id.should == 1
@@ -94,18 +86,16 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     @c.create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should translate values to and from marshal serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :marshal, :abc, :def
-
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m'))
-    end
+    @c.dataset._fetch = [:id => 1, :abc =>[Marshal.dump(1)].pack('m'), :def =>[Marshal.dump('hello')].pack('m')]
 
     o = @c.first
     o.id.should == 1
@@ -116,18 +106,16 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     @c.create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{[Marshal.dump(23)].pack('m')}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[Marshal.dump([1, 2, 3])].pack('m')}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
   
   it "should translate values to and from json serialization format using accessor methods" do
     @c.set_primary_key :id
     @c.plugin :serialization, :json, :abc, :def
-    
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc => [1].to_json, :def => ["hello"].to_json)
-    end
+    @c.dataset._fetch = {:id => 1, :abc => [1].to_json, :def => ["hello"].to_json}
     
     o = @c.first
     o.id.should == 1
@@ -139,18 +127,16 @@ describe "Serialization plugin" do
     o.update(:abc => [23])
     @c.create(:abc => [1,2,3])
     
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{[23].to_json}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1,2,3].to_json}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should copy serialization formats and columns to subclasses" do
     @c.set_primary_key :id
     @c.plugin :serialization, :yaml, :abc, :def
-
-    ds = @c.dataset
-    def ds.fetch_rows(sql, &block)
-      block.call(:id => 1, :abc => "--- 1\n", :def => "--- hello\n")
-    end
+    @c.dataset._fetch = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
 
     o = Class.new(@c).first
     o.id.should == 1
@@ -161,8 +147,10 @@ describe "Serialization plugin" do
 
     o.update(:abc => 23)
     Class.new(@c).create(:abc => [1, 2, 3])
-    MODEL_DB.sqls.should == ["UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
-      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')"]
+    MODEL_DB.sqls.should == ["SELECT * FROM items LIMIT 1",
+      "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)",
+      "INSERT INTO items (abc) VALUES ('#{[1, 2, 3].to_yaml}')",
+      "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should clear the deserialized columns when refreshing" do

data/spec/extensions/sharding_spec.rb

@@ -2,271 +2,197 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "sharding plugin" do
   before do
-    @db = Sequel::Model.db.clone
+    @db = Sequel.mock(:numrows=>1, :autoid=>proc{1}, :servers=>{:s1=>{}, :s2=>{}, :s3=>{}, :s4=>{}})
     @Artist = Class.new(Sequel::Model(@db[:artists]))
     @Artist.class_eval do
+      dataset._fetch = {:id=>2, :name=>'YJM'}
       columns :id, :name
-
-      def self.y
-        {:id=>2, :name=>'YJM'}
-      end
+      plugin :sharding
     end
     @Album = Class.new(Sequel::Model(@db[:albums]))
     @Album.class_eval do
+      dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
       columns :id, :artist_id, :name
-
-      def self.ds_ext(m=nil)
-        @ds_ext = m if m
-        @ds_ext
-      end
-
-      def self.y
-        {:id=>1, :name=>'RF', :artist_id=>2}
-      end
-      
-      private
-
-      def _join_table_dataset(opts)
-        ds = super
-        m = model
-        ds.meta_def(:model){m}
-        ds.extend model.ds_ext
-        ds
-      end
+      plugin :sharding
     end
     @Tag = Class.new(Sequel::Model(@db[:tags]))
     @Tag.class_eval do
+      dataset._fetch = {:id=>3, :name=>'M'}
       columns :id, :name
-
-      def self.y
-        {:id=>3, :name=>'M'}
-      end
+      plugin :sharding
     end
-    models = [@Artist, @Album, @Tag]
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
     @Album.many_to_one :artist, :class=>@Artist
     @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:albums_tags
-    m = Module.new do
-      def actions
-        @actions ||= []
-      end
-    end
-    models.each do |model|
-      model.extend m
-      model.plugin :sharding
-      model.dataset.extend(ds_ext = Module.new do
-        def insert(h={})
-          model.actions << [:insert, h.dup, opts[:server]]
-          1
-        end
-        def delete
-          model.actions << [:delete,(literal(opts[:where]) if opts[:where]), opts[:server]]
-          1
-        end
-        def update(h={})
-          model.actions << [:update, h.dup, (literal(opts[:where]) if opts[:where]), opts[:server]]
-          1
-        end
-        def fetch_rows(sql)
-          model.actions << [:fetch, (literal(opts[:where] || opts[:join]) if opts[:where] || opts[:join]), opts[:server]]
-          yield(model.y)
-        end
-      end)
-      @Album.ds_ext(ds_ext)
-    end
-    def @db.actions; @actions ||= []; end
-    def @db.transaction(opts)
-      actions << [:transaction, opts[:server]]
-      super
-    end
+    @db.sqls
   end 
 
   specify "should allow you to instantiate a new object for a specified shard" do
     @Album.new_using_server(:s1, :name=>'RF').save
-    @Album.actions.should == [[:insert, {:name=>"RF"}, :s1], [:fetch, "(id = 1)", :s1]]
+    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
     
-    @Album.actions.clear
     @Album.new_using_server(:s2){|o| o.name = 'MO'}.save
-    @Album.actions.should == [[:insert, {:name=>"MO"}, :s2], [:fetch, "(id = 1)", :s2]]
+    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
   end 
 
   specify "should allow you to create and save a new object for a specified shard" do
     @Album.create_using_server(:s1, :name=>'RF')
-    @Album.actions.should == [[:insert, {:name=>"RF"}, :s1], [:fetch, "(id = 1)", :s1]]
-    
-    @Album.actions.clear
+    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
+
     @Album.create_using_server(:s2){|o| o.name = 'MO'}
-    @Album.actions.should == [[:insert, {:name=>"MO"}, :s2], [:fetch, "(id = 1)", :s2]]
+    @db.sqls.should == ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
   end 
 
   specify "should have objects retrieved from a specific shard update that shard" do
     @Album.server(:s1).first.update(:name=>'MO')
-    @Album.actions.should == [[:fetch, nil, :s1], [:update, {:name=>"MO"}, "(id = 1)", :s1]]
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s1"]
   end 
 
   specify "should have objects retrieved from a specific shard delete from that shard" do
     @Album.server(:s1).first.delete
-    @Album.actions.should == [[:fetch, nil, :s1], [:delete, "(id = 1)", :s1]]
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "DELETE FROM albums WHERE (id = 1) -- s1"]
   end 
 
   specify "should have objects retrieved from a specific shard reload from that shard" do
     @Album.server(:s1).first.reload
-    @Album.actions.should == [[:fetch, nil, :s1], [:fetch, "(id = 1)", :s1]]
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
   end 
 
   specify "should use current dataset's shard when eager loading if eagerly loaded dataset doesn't have its own shard" do
     albums = @Album.server(:s1).eager(:artist).all
-    @Album.actions.should == [[:fetch, nil, :s1]]
-    @Artist.actions.should == [[:fetch, "(artists.id IN (2))", :s1]]
-    @Artist.actions.clear
-    albums.length == 1
+    @db.sqls.should == ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s1"]
+    albums.length.should == 1
     albums.first.artist.save
-    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s1]]
+    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
   end 
 
   specify "should not use current dataset's shard when eager loading if eagerly loaded dataset has its own shard" do
     @Artist.dataset.opts[:server] = :s2
     albums = @Album.server(:s1).eager(:artist).all
-    @Album.actions.should == [[:fetch, nil, :s1]]
-    @Artist.actions.should == [[:fetch, "(artists.id IN (2))", :s2]]
-    @Artist.actions.clear
-    albums.length == 1
+    @db.sqls.should == ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s2"]
+    albums.length.should == 1
     albums.first.artist.save
-    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s2]]
+    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
   end 
 
   specify "should use current dataset's shard when eager graphing if eagerly graphed dataset doesn't have its own shard" do
     ds = @Album.server(:s1).eager_graph(:artist)
-    def ds.fetch_rows(sql)
-      super(sql)
-      yield({:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'})
-    end
+    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all
-    @Album.actions.should == [[:fetch, "( LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id))", :s1]]
-    albums.length == 1
+    @db.sqls.should == ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
+    albums.length.should == 1
     albums.first.artist.save
-    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s1]]
+    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
   end 
 
   specify "should not use current dataset's shard when eager graphing if eagerly graphed dataset has its own shard" do
     @Artist.dataset.opts[:server] = :s2
     ds = @Album.server(:s1).eager_graph(:artist)
-    def ds.fetch_rows(sql)
-      super(sql)
-      yield({:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'})
-    end
+    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all
-    @Album.actions.should == [[:fetch, "( LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id))", :s1]]
-    albums.length == 1
+    @db.sqls.should == ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
+    albums.length.should == 1
     albums.first.artist.save
-    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s2]]
+    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
   end 
 
   specify "should use eagerly graphed dataset shard for eagerly graphed objects even if current dataset does not have a shard" do
     @Artist.dataset.opts[:server] = :s2
     ds = @Album.eager_graph(:artist)
-    def ds.fetch_rows(sql)
-      super(sql)
-      yield({:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'})
-    end
+    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
     albums = ds.all
-    @Album.actions.should == [[:fetch, "( LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id))", nil]]
-    albums.length == 1
+    @db.sqls.should == ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id)"]
+    albums.length.should == 1
     albums.first.artist.save
-    @Artist.actions.should == [[:update, {:name=>"YJM"}, "(id = 2)", :s2]]
+    @db.sqls.should == ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
   end 
 
   specify "should have objects retrieved from a specific shard use associated objects from that shard, with modifications to the associated objects using that shard" do
     album = @Album.server(:s1).first
-    @Album.actions.should == [[:fetch, nil, :s1]]
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1"]
     album.artist.update(:name=>'AS')
-    @Artist.actions.should == [[:fetch, "(artists.id = 2)", :s1], [:update, {:name=>"AS"}, "(id = 2)", :s1]]
+    @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- s1", "UPDATE artists SET name = 'AS' WHERE (id = 2) -- s1"]
     album.tags.map{|a| a.update(:name=>'SR')}
-    @Tag.actions.should == [[:fetch, "( INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)))", :s1], [:update, {:name=>"SR"}, "(id = 3)", :s1]]
-    
-    @Album.actions.clear
-    @Artist.actions.clear
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) -- s1", "UPDATE tags SET name = 'SR' WHERE (id = 3) -- s1"]
     @Artist.server(:s2).first.albums.map{|a| a.update(:name=>'MO')}
-    @Artist.actions.should == [[:fetch, nil, :s2]]
-    @Album.actions.should == [[:fetch, "(albums.artist_id = 2)", :s2], [:update, {:name=>"MO"}, "(id = 1)", :s2]]
+    @db.sqls.should == ["SELECT * FROM artists LIMIT 1 -- s2", "SELECT * FROM albums WHERE (albums.artist_id = 2) -- s2", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s2"]
   end 
 
   specify "should have objects retrieved from a specific shard add associated objects to that shard" do
     album = @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @Album.actions.clear
-    @Artist.actions.clear
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.add_album(:name=>'MO')
-    @Album.actions.should == [[:insert, {:name=>"MO", :artist_id=>2}, :s2], [:fetch, "(id = 1)", :s2]]
-    @Album.actions.clear
+    sqls = @db.sqls
+    ["INSERT INTO albums (artist_id, name) VALUES (2, 'MO') -- s2", "INSERT INTO albums (name, artist_id) VALUES ('MO', 2) -- s2"].should include(sqls.shift)
+    sqls.should == ["SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
     
     album.add_tag(:name=>'SR')
-    @Tag.actions.should == [[:insert, {:name=>"SR"}, :s1], [:fetch, "(id = 1)", :s1]]
-    @Album.actions.should == [[:insert, {:album_id=>1, :tag_id=>3}, :s1]]
+    sqls = @db.sqls
+    ["INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3) -- s1", "INSERT INTO albums_tags (tag_id, album_id) VALUES (3, 1) -- s1"].should include(sqls.pop)
+    sqls.should == ["INSERT INTO tags (name) VALUES ('SR') -- s1", "SELECT * FROM tags WHERE (id = 1) LIMIT 1 -- s1", ]
   end 
 
   specify "should have objects retrieved from a specific shard remove associated objects from that shard" do
     album = @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @Album.actions.clear
-    @Artist.actions.clear
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.remove_album(1)
-    @Album.actions.should == [[:fetch, "((albums.artist_id = 2) AND (albums.id = 1))", :s2], [:update, {:name=>"RF", :artist_id=>nil}, "(id = 1)", :s2]]
-    @Album.actions.clear
+    sqls = @db.sqls
+    ["UPDATE albums SET artist_id = NULL, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = NULL WHERE (id = 1) -- s2"].should include(sqls.pop)
+    sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (albums.id = 1)) LIMIT 1 -- s2"]
     
     album.remove_tag(3)
-    @Tag.actions.should == [[:fetch, "(tags.id = 3)", :s1]]
-    @Album.actions.should == [[:delete, "((album_id = 1) AND (tag_id = 3))", :s1]]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) WHERE (tags.id = 3) LIMIT 1 -- s1", "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id = 3)) -- s1"]
   end 
 
   specify "should have objects retrieved from a specific shard remove all associated objects from that shard" do
     album = @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @Album.actions.clear
-    @Artist.actions.clear
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.remove_all_albums
-    @Album.actions.should == [[:update, {:artist_id=>nil}, "(artist_id = 2)", :s2]]
-    @Album.actions.clear
+    @db.sqls.should == ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 2) -- s2"]
     
     album.remove_all_tags
-    @Album.actions.should == [[:delete, "(album_id = 1)", :s1]]
+    @db.sqls.should == ["DELETE FROM albums_tags WHERE (album_id = 1) -- s1"]
   end 
 
   specify "should not override a server already set on an associated object" do
     album = @Album.server(:s1).first
     artist = @Artist.server(:s2).first
-    @Album.actions.clear
-    @Artist.actions.clear
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
 
     artist.add_album(@Album.load(:id=>4, :name=>'MO').set_server(:s3))
-    @Album.actions.should == [[:update, {:name=>"MO", :artist_id=>2}, "(id = 4)", :s3]]
-    @Album.actions.clear
+    ["UPDATE albums SET artist_id = 2, name = 'MO' WHERE (id = 4) -- s3", "UPDATE albums SET name = 'MO', artist_id = 2 WHERE (id = 4) -- s3"].should include(@db.sqls.pop)
 
     artist.remove_album(@Album.load(:id=>5, :name=>'T', :artist_id=>2).set_server(:s4))
     # Should select from current object's shard to check existing association, but update associated object's shard
-    @Album.actions.should == [[:fetch, "((albums.artist_id = 2) AND (id = 5))", :s2], [:update, {:name=>"T", :artist_id=>nil}, "(id = 5)", :s4]]
-    @Album.actions.clear
+    sqls = @db.sqls
+    ["UPDATE albums SET artist_id = NULL, name = 'T' WHERE (id = 5) -- s4", "UPDATE albums SET name = 'T', artist_id = NULL WHERE (id = 5) -- s4"].should include(sqls.pop)
+    sqls.should == ["SELECT 1 FROM albums WHERE ((albums.artist_id = 2) AND (id = 5)) LIMIT 1 -- s2"]
   end 
 
   specify "should be able to set a shard to use for any object using set_server" do
     @Album.server(:s1).first.set_server(:s2).reload
-    @Album.actions.should == [[:fetch, nil, :s1], [:fetch, "(id = 1)", :s2]]
+    @db.sqls.should == ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
   end 
 
   specify "should use transactions on the correct shard" do
     @Album.use_transactions = true
     @Album.server(:s2).first.save
-    @Album.actions.should == [[:fetch, nil, :s2], [:update, {:name=>"RF", :artist_id=>2}, "(id = 1)", :s2]]
-    @db.actions.should == [[:transaction, :s2]]
+    sqls = @db.sqls
+    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s2"].should include(sqls.slice!(2))
+    sqls.should == ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s2", "COMMIT -- s2"]
   end 
 
-  specify "should use not override shard given when saving" do
+  specify "should use override current shard when saving with given :server option" do
     @Album.use_transactions = true
     @Album.server(:s2).first.save(:server=>:s1)
-    @Album.actions.should == [[:fetch, nil, :s2], [:update, {:name=>"RF", :artist_id=>2}, "(id = 1)", :s2]]
-    @db.actions.should == [[:transaction, :s1]]
+    sqls = @db.sqls
+    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s1", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s1"].should include(sqls.slice!(2))
+    sqls.should == ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s1", "COMMIT -- s1"]
   end 
 end