sequel 3.46.0 → 3.47.0

data/spec/extensions/constraint_validations_spec.rb

@@ -66,7 +66,7 @@ describe "constraint_validations extension" do
     @db.sqls.should == ["DELETE FROM cv WHERE (table = 'foo')"]
   end
 
-  it "should raise an error without deleting if attempting to drop validations with table, column, or constraint" do
+  it "should raise an error without deleting if attempting to drop validations without table, column, or constraint" do
     proc{@db.drop_constraint_validations_for({})}.should raise_error(Sequel::Error)
     @db.sqls.should == []
   end
@@ -97,7 +97,7 @@ describe "constraint_validations extension" do
     @db.create_table(:foo){String :name; validate{presence :name, :allow_nil=>true}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).should == {:validation_type=>"presence", :column=>"name", :table=>"foo", :allow_nil=>'t'}
-    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK (trim(name) != ''))"]
+    sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name varchar(255), CHECK ((name IS NULL) OR (trim(name) != '')))"]
   end
 
   it "should handle :name option when adding validations" do
@@ -193,7 +193,7 @@ describe "constraint_validations extension" do
   it "should support :format constraint validation" do
     @db = Sequel.mock(:host=>'postgres')
     @db.extension(:constraint_validations)
-    @db.create_table(:foo){String :name; validate{format /^foo.*/, :name}}
+    @db.create_table(:foo){String :name; validate{format(/^foo.*/, :name)}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).should == {:validation_type=>"format", :column=>"name", :table=>"foo", :argument=>'^foo.*'}
     sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~ '^foo.*')))"]
@@ -202,7 +202,7 @@ describe "constraint_validations extension" do
   it "should support :format constraint validation with case insensitive format" do
     @db = Sequel.mock(:host=>'postgres')
     @db.extension(:constraint_validations)
-    @db.create_table(:foo){String :name; validate{format /^foo.*/i, :name}}
+    @db.create_table(:foo){String :name; validate{format(/^foo.*/i, :name)}}
     sqls = @db.sqls
     parse_insert(sqls.slice!(1)).should == {:validation_type=>"iformat", :column=>"name", :table=>"foo", :argument=>'^foo.*'}
     sqls.should == ["BEGIN", "COMMIT", "CREATE TABLE foo (name text, CHECK ((name IS NOT NULL) AND (name ~* '^foo.*')))"]

data/spec/extensions/core_refinements_spec.rb

@@ -16,45 +16,6 @@ describe "Core refinements" do
     end
   end
   
-  if RUBY_VERSION < '1.9.0'
-    it "should not allow inequality operations on true, false, or nil" do
-      @d.lit(:x > 1).should == "(x > 1)"
-      @d.lit(:x < true).should == "(x < 't')"
-      @d.lit(:x >= false).should == "(x >= 'f')"
-      @d.lit(:x <= nil).should == "(x <= NULL)"
-    end
-
-    it "should not allow inequality operations on boolean complex expressions" do
-      @d.lit(:x > (:y > 5)).should == "(x > (y > 5))"
-      @d.lit(:x < (:y < 5)).should == "(x < (y < 5))"
-      @d.lit(:x >= (:y >= 5)).should == "(x >= (y >= 5))"
-      @d.lit(:x <= (:y <= 5)).should == "(x <= (y <= 5))"
-      @d.lit(:x > {:y => nil}).should == "(x > (y IS NULL))"
-      @d.lit(:x < ~{:y => nil}).should == "(x < (y IS NOT NULL))"
-      @d.lit(:x >= {:y => 5}).should == "(x >= (y = 5))"
-      @d.lit(:x <= ~{:y => 5}).should == "(x <= (y != 5))"
-      @d.lit(:x >= {:y => [1,2,3]}).should == "(x >= (y IN (1, 2, 3)))"
-      @d.lit(:x <= ~{:y => [1,2,3]}).should == "(x <= (y NOT IN (1, 2, 3)))"
-    end
-    
-    it "should support >, <, >=, and <= via Symbol#>,<,>=,<=" do
-      @d.l(:x > 100).should == '(x > 100)'
-      @d.l(:x < 100.01).should == '(x < 100.01)'
-      @d.l(:x >= 100000000000000000000000000000000000).should == '(x >= 100000000000000000000000000000000000)'
-      @d.l(:x <= 100).should == '(x <= 100)'
-    end
-    
-    it "should support negation of >, <, >=, and <= via Symbol#~" do
-      @d.l(~(:x > 100)).should == '(x <= 100)'
-      @d.l(~(:x < 100.01)).should == '(x >= 100.01)'
-      @d.l(~(:x >= 100000000000000000000000000000000000)).should == '(x < 100000000000000000000000000000000000)'
-      @d.l(~(:x <= 100)).should == '(x > 100)'
-    end
-    
-    it "should support double negation via ~" do
-      @d.l(~~(:x > 100)).should == '(x > 100)'
-    end
-  end
   it "should support NOT via Symbol#~" do
     @d.l(~:x).should == 'NOT x'
     @d.l(~:x__y).should == 'NOT x.y'
@@ -221,7 +182,7 @@ end
 
 describe "String#lit" do
   before do
-    @ds = ds = Sequel::Database.new[:t]
+    @ds = Sequel::Database.new[:t]
   end
 
   specify "should return an LiteralString object" do
@@ -274,13 +235,13 @@ describe "#desc" do
   end
   
   specify "should format a DESC clause for a column ref" do
-    :test.desc.to_s(@ds).should == 'test DESC'
+    @ds.literal(:test.desc).should == 'test DESC'
     
-    :items__price.desc.to_s(@ds).should == 'items.price DESC'
+    @ds.literal(:items__price.desc).should == 'items.price DESC'
   end
 
   specify "should format a DESC clause for a function" do
-    :avg.sql_function(:test).desc.to_s(@ds).should == 'avg(test) DESC'
+    @ds.literal(:avg.sql_function(:test).desc).should == 'avg(test) DESC'
   end
 end
 
@@ -290,13 +251,13 @@ describe "#asc" do
   end
   
   specify "should format a ASC clause for a column ref" do
-    :test.asc.to_s(@ds).should == 'test ASC'
+    @ds.literal(:test.asc).should == 'test ASC'
     
-    :items__price.asc.to_s(@ds).should == 'items.price ASC'
+    @ds.literal(:items__price.asc).should == 'items.price ASC'
   end
 
   specify "should format a ASC clause for a function" do
-    :avg.sql_function(:test).asc.to_s(@ds).should == 'avg(test) ASC'
+    @ds.literal(:avg.sql_function(:test).asc).should == 'avg(test) ASC'
   end
 end
 
@@ -306,17 +267,17 @@ describe "#as" do
   end
   
   specify "should format a AS clause for a column ref" do
-    :test.as(:t).to_s(@ds).should == 'test AS t'
+    @ds.literal(:test.as(:t)).should == 'test AS t'
     
-    :items__price.as(:p).to_s(@ds).should == 'items.price AS p'
+    @ds.literal(:items__price.as(:p)).should == 'items.price AS p'
   end
 
   specify "should format a AS clause for a function" do
-    :avg.sql_function(:test).as(:avg).to_s(@ds).should == 'avg(test) AS avg'
+    @ds.literal(:avg.sql_function(:test).as(:avg)).should == 'avg(test) AS avg'
   end
   
   specify "should format a AS clause for a literal value" do
-    'abc'.as(:abc).to_s(@ds).should == "'abc' AS abc"
+    @ds.literal('abc'.as(:abc)).should == "'abc' AS abc"
   end
 end
 
@@ -364,34 +325,23 @@ describe "Blob" do
   end
 end
 
-if RUBY_VERSION < '1.9.0'
-  describe "Symbol#[]" do
-    specify "should format an SQL Function" do
-      ds = Sequel::Dataset.new(nil)
-      ds.literal(:xyz[]).should == 'xyz()'
-      ds.literal(:xyz[1]).should == 'xyz(1)'
-      ds.literal(:xyz[1, 2, :abc[3]]).should == 'xyz(1, 2, abc(3))'
-    end
-  end
-end
-
 describe "Symbol#*" do
   before do
     @ds = Sequel::Dataset.new(nil)
   end
   
   specify "should format a qualified wildcard if no argument" do
-    :xyz.*.to_s(@ds).should == 'xyz.*'
-    :abc.*.to_s(@ds).should == 'abc.*'
+    @ds.literal(:xyz.*).should == 'xyz.*'
+    @ds.literal(:abc.*).should == 'abc.*'
   end
 
   specify "should format a filter expression if an argument" do
-    :xyz.*(3).to_s(@ds).should == '(xyz * 3)'
-    :abc.*(5).to_s(@ds).should == '(abc * 5)'
+    @ds.literal(:xyz.*(3)).should == '(xyz * 3)'
+    @ds.literal(:abc.*(5)).should == '(abc * 5)'
   end
 
   specify "should support qualified symbols if no argument" do
-    :xyz__abc.*.to_s(@ds).should == 'xyz.abc.*'
+    @ds.literal(:xyz__abc.*).should == 'xyz.abc.*'
   end
 end
 
@@ -445,12 +395,12 @@ describe "Symbol" do
   end
   
   specify "should support sql_function method" do
-    :COUNT.sql_function('1').to_s(@ds).should == "COUNT('1')"
+    @ds.literal(:COUNT.sql_function('1')).should == "COUNT('1')"
     @ds.select(:COUNT.sql_function('1')).sql.should == "SELECT COUNT('1')"
   end
   
   specify "should support cast method" do
-    :abc.cast(:integer).to_s(@ds).should == "CAST(abc AS integer)"
+    @ds.literal(:abc.cast(:integer)).should == "CAST(abc AS integer)"
   end
 
   specify "should support sql array accesses via sql_subscript" do
@@ -463,19 +413,19 @@ describe "Symbol" do
   specify "should support cast_numeric and cast_string" do
     x = :abc.cast_numeric
     x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    x.to_s(@ds).should == "CAST(abc AS integer)"
+    @ds.literal(x).should == "CAST(abc AS integer)"
 
     x = :abc.cast_numeric(:real)
     x.should be_a_kind_of(Sequel::SQL::NumericExpression)
-    x.to_s(@ds).should == "CAST(abc AS real)"
+    @ds.literal(x).should == "CAST(abc AS real)"
 
     x = :abc.cast_string
     x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    x.to_s(@ds).should == "CAST(abc AS varchar(255))"
+    @ds.literal(x).should == "CAST(abc AS varchar(255))"
 
     x = :abc.cast_string(:varchar)
     x.should be_a_kind_of(Sequel::SQL::StringExpression)
-    x.to_s(@ds).should == "CAST(abc AS varchar(255))"
+    @ds.literal(x).should == "CAST(abc AS varchar(255))"
   end
   
   specify "should allow database independent types when casting" do
@@ -485,16 +435,16 @@ describe "Symbol" do
       return :bar if type == String
       type
     end
-    :abc.cast(String).to_s(@ds).should == "CAST(abc AS bar)"
-    :abc.cast(String).to_s(@ds).should == "CAST(abc AS bar)"
-    :abc.cast_string.to_s(@ds).should == "CAST(abc AS bar)"
-    :abc.cast_string(Integer).to_s(@ds).should == "CAST(abc AS foo)"
-    :abc.cast_numeric.to_s(@ds).should == "CAST(abc AS foo)"
-    :abc.cast_numeric(String).to_s(@ds).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast(String)).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast(String)).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast_string).should == "CAST(abc AS bar)"
+    @ds.literal(:abc.cast_string(Integer)).should == "CAST(abc AS foo)"
+    @ds.literal(:abc.cast_numeric).should == "CAST(abc AS foo)"
+    @ds.literal(:abc.cast_numeric(String)).should == "CAST(abc AS bar)"
   end
 
   specify "should support SQL EXTRACT function via #extract " do
-    :abc.extract(:year).to_s(@ds).should == "extract(year FROM abc)"
+    @ds.literal(:abc.extract(:year)).should == "extract(year FROM abc)"
   end
 end
 

data/spec/extensions/dirty_spec.rb

@@ -121,6 +121,12 @@ describe "Sequel::Plugins::Dirty" do
         o.column_change(:initial).should == [v, 'a']
       end
     end
+
+    it "should work when freezing objects" do
+      @o.freeze
+      @o.initial_value(:initial).should == 'i'
+      proc{@o.initial = 'b'}.should raise_error
+    end
   end
 
   describe "with new instance" do
@@ -158,5 +164,13 @@ describe "Sequel::Plugins::Dirty" do
       @o.save
       @o.previous_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
     end
+
+    it "should work when freezing objects after saving" do
+      @o.initial = 'a'
+      @o.save
+      @o.freeze
+      @o.previous_changes[:initial].should == ['i', 'a']
+      proc{@o.initial = 'b'}.should raise_error
+    end
   end
 end

data/spec/extensions/error_splitter_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::ErrorSplitter" do
+  before do
+    @c = Class.new(Sequel::Model)
+    @c.plugin :error_splitter
+    @m = @c.new
+    def @m.validate
+      errors.add([:a, :b], 'is bad')
+    end
+  end
+
+  it "should split errors for multiple columns and assign them to each column" do
+    @m.valid?.should be_false
+    @m.errors.should == {:a=>['is bad'], :b=>['is bad']}
+  end
+end
+

data/spec/extensions/identity_map_spec.rb

@@ -183,7 +183,6 @@ describe "Sequel::Plugins::IdentityMap" do
   end
 
   it "should not use the identity map as a lookup cache for a one_to_one association" do
-    c = @c2
     @c2.one_to_one :artist, :class=>@c1, :key=>:artist_id
     @c.with_identity_map do
       MODEL_DB.sqls.length.should == 0

data/spec/extensions/input_transformer_spec.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::InputTransformer" do
+  before do
+    @c = Class.new(Sequel::Model)
+    @c.columns :name, :b
+    @c.plugin(:input_transformer, :reverser){|v| v.is_a?(String) ? v.reverse : v}
+    @o = @c.new
+  end
+
+  it "should apply transformation to input" do
+    @o.name = ' name '
+    @o.name.should == ' eman '
+    @o.name = [1, 2, 3]
+    @o.name.should == [1, 2, 3]
+  end
+
+  it "should not apply any transformers by default" do
+    c = Class.new(Sequel::Model)
+    c.columns :name, :b
+    c.plugin :input_transformer
+    c.new(:name => ' name ').name.should == ' name '
+  end
+
+  it "should allow skipping of columns using .skip_input_transformer" do
+    @c.skip_input_transformer :reverser, :name
+    v = ' name '
+    @o.name = v
+    @o.name.should equal(v)
+  end
+
+  it "should work correctly in subclasses" do
+    o = Class.new(@c).new
+    o.name = ' name '
+    o.name.should == ' eman '
+  end
+
+  it "should raise an error if adding input filter without name" do
+    proc{@c.add_input_transformer(nil){}}.should raise_error(Sequel::Error)
+    proc{@c.plugin(:input_transformer){}}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if adding input filter without block" do
+    proc{@c.add_input_transformer(:foo)}.should raise_error(Sequel::Error)
+    proc{@c.plugin(:input_transformer, :foo)}.should raise_error(Sequel::Error)
+  end
+
+  it "should apply multiple input transformers in reverse order of their call" do
+    @c.add_input_transformer(:add_bar){|v| v << 'bar'}
+    @c.add_input_transformer(:add_foo){|v| v << 'foo'}
+    @o.name = ' name '
+    @o.name.should == 'raboof eman '
+  end
+end

data/spec/extensions/instance_filters_spec.rb

@@ -42,4 +42,10 @@ describe "instance_filters plugin" do
     @p.update(:name=>'Bob')
     MODEL_DB.sqls.should == ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
   end
+
+  specify "shouldn't allow instance filters on frozen objects" do
+    @p.instance_filter(:name=>'Joe')
+    @p.freeze
+    proc{@p.instance_filter(:name=>'Jim')}.should raise_error
+  end 
 end

data/spec/extensions/instance_hooks_spec.rb

@@ -176,12 +176,23 @@ describe "InstanceHooks plugin" do
     @x.save.should_not == nil
     @r.should == [2, 1, 4, 3]
   end
+
+  it "should not allow addition of instance hooks to frozen instances" do
+    @x.after_destroy_hook{r 1}
+    @x.before_destroy_hook{r 2}
+    @x.before_update_hook{r 3}
+    @x.before_save_hook{r 4}
+    @x.freeze
+    proc{@x.after_destroy_hook{r 1}}.should raise_error(Sequel::Error)
+    proc{@x.before_destroy_hook{r 2}}.should raise_error(Sequel::Error)
+    proc{@x.before_update_hook{r 3}}.should raise_error(Sequel::Error)
+    proc{@x.before_save_hook{r 4}}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "InstanceHooks plugin with transactions" do
   before do
     @db = Sequel.mock(:numrows=>1)
-    pr = proc{|x| r(x)}
     @c = Class.new(Sequel::Model(@db[:items])) do
       attr_accessor :rb
       def after_save

data/spec/extensions/json_serializer_spec.rb

@@ -182,7 +182,6 @@ describe "Sequel::Plugins::JsonSerializer" do
   end
 
   it "should have dataset to_json method work with naked datasets" do
-    album = @album
     ds = Album.dataset.naked
     ds._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
     Sequel.parse_json(ds.to_json).should == [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]

data/spec/extensions/lazy_attributes_spec.rb

@@ -68,17 +68,13 @@ describe "Sequel::Plugins::LazyAttributes" do
     m.name.should == '1'
   end
 
-  it "should lazily load the attribute for a single model object if there is an active identity map" do
-    @c.with_identity_map do
-      m = @c.first
-      m.values.should == {:id=>1}
-      m.name.should == '1'
-      m.values.should == {:id=>1, :name=>'1'}
-      @db.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
-    end
+  it "should raise error if the model has no primary key" do
+    m = @c.first
+    @c.no_primary_key
+    proc{m.name}.should raise_error(Sequel::Error)
   end
 
-  it "should lazily load the attribute for a single model object if there is no active identity map" do
+  it "should lazily load the attribute for a single model object" do
     m = @c.first
     m.values.should == {:id=>1}
     m.name.should == '1'
@@ -86,34 +82,47 @@ describe "Sequel::Plugins::LazyAttributes" do
     @db.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
   end
 
+  it "should lazily load the attribute for a frozen model object" do
+    m = @c.first
+    m.freeze
+    m.name.should == '1'
+    @db.sqls.should == ['SELECT id FROM la LIMIT 1', 'SELECT name FROM la WHERE (id = 1) LIMIT 1']
+    m.name.should == '1'
+    @db.sqls.should == ['SELECT name FROM la WHERE (id = 1) LIMIT 1']
+  end
+
   it "should not lazily load the attribute for a single model object if the value already exists" do
-    @c.with_identity_map do
-      m = @c.first
-      m.values.should == {:id=>1}
-      m[:name] = '1'
-      m.name.should == '1'
-      m.values.should == {:id=>1, :name=>'1'}
-      @db.sqls.should == ['SELECT id FROM la LIMIT 1']
-    end
+    m = @c.first
+    m.values.should == {:id=>1}
+    m[:name] = '1'
+    m.name.should == '1'
+    m.values.should == {:id=>1, :name=>'1'}
+    @db.sqls.should == ['SELECT id FROM la LIMIT 1']
   end
 
   it "should not lazily load the attribute for a single model object if it is a new record" do
-    @c.with_identity_map do
-      m = @c.new
-      m.values.should == {}
-      m.name.should == nil
-      @db.sqls.should == []
-    end
+    m = @c.new
+    m.values.should == {}
+    m.name.should == nil
+    @db.sqls.should == []
   end
 
   it "should eagerly load the attribute for all model objects reteived with it" do
-    @c.with_identity_map do
-      ms = @c.all
-      ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
-      ms.map{|m| m.name}.should == %w'1 2'
-      ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
-      @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
-    end
+    ms = @c.all
+    ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
+    ms.map{|m| m.name}.should == %w'1 2'
+    ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
+    sqls = @db.sqls
+    ['SELECT id, name FROM la WHERE (id IN (1, 2))',
+     'SELECT id, name FROM la WHERE (id IN (2, 1))'].should include(sqls.pop)
+    sqls.should == ['SELECT id FROM la']
+  end
+
+  it "should not eagerly load the attribute if model instance is frozen, and deal with other frozen instances if not frozen" do
+    ms = @c.all
+    ms.first.freeze
+    ms.map{|m| m.name}.should == %w'1 2'
+    @db.sqls.should == ['SELECT id FROM la', 'SELECT name FROM la WHERE (id = 1) LIMIT 1', 'SELECT id, name FROM la WHERE (id IN (2))']
   end
 
   it "should add the accessors to a module included in the class, so they can be easily overridden" do
@@ -122,35 +131,35 @@ describe "Sequel::Plugins::LazyAttributes" do
         "#{super}-blah"
       end
     end
-    @c.with_identity_map do
-      ms = @c.all
-      ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
-      ms.map{|m| m.name}.should == %w'1-blah 2-blah'
-      ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
-      @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
-    end
+    ms = @c.all
+    ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
+    ms.map{|m| m.name}.should == %w'1-blah 2-blah'
+    ms.map{|m| m.values}.should == [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
+    sqls = @db.sqls
+    ['SELECT id, name FROM la WHERE (id IN (1, 2))',
+     'SELECT id, name FROM la WHERE (id IN (2, 1))'].should include(sqls.pop)
+    sqls.should == ['SELECT id FROM la']
   end
 
   it "should work with the serialization plugin" do
     @c.plugin :serialization, :yaml, :name
     @c.instance_dataset._fetch = @ds._fetch = [[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]]
-    @c.with_identity_map do
-      ms = @ds.all
-      ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
-      ms.map{|m| m.name}.should == [3,6]
-      ms.map{|m| m.values}.should == [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}]
-      ms.map{|m| m.deserialized_values}.should == [{:name=>3}, {:name=>6}]
-      ms.map{|m| m.name}.should == [3,6]
-      @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
-    end
-    @c.with_identity_map do
-      m = @ds.first
-      m.values.should == {:id=>1}
-      m.name.should == 3
-      m.values.should == {:id=>1, :name=>"--- 3\n"}
-      m.deserialized_values.should == {:name=>3}
-      m.name.should == 3
-      @db.sqls.should == ["SELECT id FROM la LIMIT 1", "SELECT name FROM la WHERE (id = 1) LIMIT 1"]
-    end
+    ms = @ds.all
+    ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
+    ms.map{|m| m.name}.should == [3,6]
+    ms.map{|m| m.values}.should == [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}]
+    ms.map{|m| m.deserialized_values}.should == [{:name=>3}, {:name=>6}]
+    ms.map{|m| m.name}.should == [3,6]
+    sqls = @db.sqls
+    ['SELECT id, name FROM la WHERE (id IN (1, 2))',
+     'SELECT id, name FROM la WHERE (id IN (2, 1))'].should include(sqls.pop)
+    sqls.should == ['SELECT id FROM la']
+    m = @ds.first
+    m.values.should == {:id=>1}
+    m.name.should == 3
+    m.values.should == {:id=>1, :name=>"--- 3\n"}
+    m.deserialized_values.should == {:name=>3}
+    m.name.should == 3
+    @db.sqls.should == ["SELECT id FROM la LIMIT 1", "SELECT name FROM la WHERE (id = 1) LIMIT 1"]
   end
 end