From 8accebbe006e4397fb498ab48506b8f3e37be66a Mon Sep 17 00:00:00 2001 From: Jeremy Evans Date: Mon, 26 Mar 2012 13:36:20 -0700 Subject: [PATCH] Increase speed of Model#this by about 85% Previously, this was doing 3 dataset clones. Add a Model.instance_dataset method that returns a cached intermediate dataset, so that Model#this only has to do one dataset clone. Quite a bit of spec fallout since the specs assumed that you could modify Model.dataset when you now need to modify Model.instance_dataset. --- CHANGELOG | 2 ++ lib/sequel/model.rb | 3 ++- lib/sequel/model/base.rb | 11 ++++++++--- spec/extensions/class_table_inheritance_spec.rb | 4 ++-- spec/extensions/force_encoding_spec.rb | 6 ++++-- spec/extensions/lazy_attributes_spec.rb | 4 ++-- spec/extensions/list_spec.rb | 8 ++++---- spec/extensions/optimistic_locking_spec.rb | 4 ++-- spec/extensions/prepared_statements_spec.rb | 4 ++++ spec/extensions/sharding_spec.rb | 12 ++++++------ spec/extensions/skip_create_refresh_spec.rb | 2 +- spec/model/associations_spec.rb | 16 ++++++++-------- spec/model/base_spec.rb | 8 ++++---- spec/model/model_spec.rb | 12 ++++++------ spec/model/record_spec.rb | 12 ++++++------ 15 files changed, 61 insertions(+), 47 deletions(-) diff --git a/CHANGELOG b/CHANGELOG index 403a1e126f..6c3495706b 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -1,5 +1,7 @@ === HEAD +* Increase speed of Model#this by about 85% (jeremyevans) + * Increase speed of Model#delete and #destroy by about 75% for models with simple datasets (jeremyevans) * Make nested_attributes plugin work when destroying/removing associated objects when strict_param_setting is true (r-stu31) (#455) diff --git a/lib/sequel/model.rb b/lib/sequel/model.rb index bcf2c053e8..7ecab050f0 100644 --- a/lib/sequel/model.rb +++ b/lib/sequel/model.rb @@ -113,7 +113,8 @@ class Model :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil, :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil, :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil, - :@use_after_commit_rollback=>nil} + :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil, + :@fast_instance_delete_sql=>nil} # Regular expression that determines if a method name is normal in the sense that # it could be used literally in ruby code without using send. Used to diff --git a/lib/sequel/model/base.rb b/lib/sequel/model/base.rb index 27e7ea48e5..d96a7ba0ee 100644 --- a/lib/sequel/model/base.rb +++ b/lib/sequel/model/base.rb @@ -30,9 +30,13 @@ module ClassMethods attr_reader :dataset_methods # SQL string fragment used for faster DELETE statement creation when deleting/destroying - # model instances, or nil if the optimization should not be used. + # model instances, or nil if the optimization should not be used. For internal use only. attr_reader :fast_instance_delete_sql + # The dataset that instance datasets (#this) are based on. Generally a naked version of + # the model's dataset limited to one row. For internal use only. + attr_reader :instance_dataset + # Array of plugin modules loaded by this class # # Sequel::Model.plugins @@ -531,6 +535,7 @@ def set_dataset(ds, opts={}) end @dataset.model = self if @dataset.respond_to?(:model=) check_non_connection_error{@db_schema = (inherited ? superclass.db_schema : get_db_schema)} + @instance_dataset = @dataset.limit(1).naked self end @@ -1372,7 +1377,7 @@ def singleton_method_added(meth) # Artist[1].this # # SELECT * FROM artists WHERE (id = 1) LIMIT 1 def this - @this ||= use_server(model.dataset.filter(pk_hash).limit(1).naked) + @this ||= use_server(model.instance_dataset.filter(pk_hash)) end # Runs #set with the passed hash and then runs save_changes. @@ -1517,7 +1522,7 @@ def _insert # The dataset to use when inserting a new object. The same as the model's # dataset by default. def _insert_dataset - use_server(model.dataset) + use_server(model.instance_dataset) end # Insert into the given dataset and return the primary key created (if any). diff --git a/spec/extensions/class_table_inheritance_spec.rb b/spec/extensions/class_table_inheritance_spec.rb index e2c546cea0..e78ef405f7 100644 --- a/spec/extensions/class_table_inheritance_spec.rb +++ b/spec/extensions/class_table_inheritance_spec.rb @@ -130,10 +130,10 @@ class ::Executive < Manager; end end it "should lazily load attributes for columns in subclass tables" do - Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2} + Manager.instance_dataset._fetch = 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'] - Executive.dataset._fetch = {:num_managers=>3} + Executive.instance_dataset._fetch = 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} diff --git a/spec/extensions/force_encoding_spec.rb b/spec/extensions/force_encoding_spec.rb index bbdf60f2b9..1af2823159 100644 --- a/spec/extensions/force_encoding_spec.rb +++ b/spec/extensions/force_encoding_spec.rb @@ -74,12 +74,13 @@ specify "should work when saving new model instances" do o = @c.new - @c.dataset = ds = MODEL_DB[:a] + ds = MODEL_DB[:a] def ds.first s = 'blah' s.force_encoding('US-ASCII') {:id=>1, :x=>s} end + @c.dataset = ds o.save o.x.should == 'blah' o.x.encoding.should == @e1 @@ -87,12 +88,13 @@ def ds.first specify "should work when refreshing model instances" do o = @c.load(:id=>1, :x=>'as') - @c.dataset = ds = MODEL_DB[:a] + ds = MODEL_DB[:a] def ds.first s = 'blah' s.force_encoding('US-ASCII') {:id=>1, :x=>s} end + @c.dataset = ds o.refresh o.x.should == 'blah' o.x.encoding.should == @e1 diff --git a/spec/extensions/lazy_attributes_spec.rb b/spec/extensions/lazy_attributes_spec.rb index dcece71e3e..4de414099e 100644 --- a/spec/extensions/lazy_attributes_spec.rb +++ b/spec/extensions/lazy_attributes_spec.rb @@ -11,7 +11,7 @@ class ::LazyAttributesModel < Sequel::Model(@db[:la]) meta_def(:columns){[:id, :name]} lazy_attributes :name meta_def(:columns){[:id]} - dataset._fetch = proc do |sql| + instance_dataset._fetch = dataset._fetch = proc do |sql| if sql !~ /WHERE/ if sql =~ /name/ [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}] @@ -133,7 +133,7 @@ def name it "should work with the serialization plugin" do @c.plugin :serialization, :yaml, :name - @ds._fetch = [[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]] + @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}] diff --git a/spec/extensions/list_spec.rb b/spec/extensions/list_spec.rb index 6bfd48360f..8a01d77983 100644 --- a/spec/extensions/list_spec.rb +++ b/spec/extensions/list_spec.rb @@ -76,8 +76,8 @@ def klass(opts={}) end it "should have position field set to max+1 when creating if not already set" do - @c.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]] - @c.dataset.autoid = 1 + @c.instance_dataset._fetch = @c.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]] + @c.instance_dataset.autoid = @c.dataset.autoid = 1 @c.create.values.should == {:id=>1, :position=>1} @c.create.values.should == {:id=>2, :position=>2} @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1", @@ -89,8 +89,8 @@ def klass(opts={}) end it "should have position field set to max+1 in scope when creating if not already set" do - @sc.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]] - @sc.dataset.autoid = 1 + @sc.instance_dataset._fetch = @sc.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]] + @sc.instance_dataset.autoid = @sc.dataset.autoid = 1 @sc.create(:scope_id=>1).values.should == {:id=>1, :scope_id=>1, :position=>1} @sc.create(:scope_id=>1).values.should == {:id=>2, :scope_id=>1, :position=>2} @sc.create(:scope_id=>2).values.should == {:id=>3, :scope_id=>2, :position=>1} diff --git a/spec/extensions/optimistic_locking_spec.rb b/spec/extensions/optimistic_locking_spec.rb index c0f3040318..1dfcb4aa3d 100644 --- a/spec/extensions/optimistic_locking_spec.rb +++ b/spec/extensions/optimistic_locking_spec.rb @@ -6,7 +6,7 @@ end h = {1=>{:id=>1, :name=>'John', :lock_version=>2}} lv = @lv = "lock_version" - @c.dataset.numrows = proc do |sql| + @c.instance_dataset.numrows = @c.dataset.numrows = proc do |sql| case sql when /UPDATE people SET (name|#{lv}) = ('Jim'|'Bob'|\d+), (?:name|#{lv}) = ('Jim'|'Bob'|\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/ name, nlv = $1 == 'name' ? [$2, $3] : [$3, $2] @@ -104,7 +104,7 @@ end specify "should not increment the lock column when the update fails" do - @c.dataset.meta_def(:update) { raise Exception } + @c.instance_dataset.meta_def(:update) { raise Exception } p1 = @c[1] p1.modified! lv = p1.lock_version diff --git a/spec/extensions/prepared_statements_spec.rb b/spec/extensions/prepared_statements_spec.rb index 9f48d39438..a252de0284 100644 --- a/spec/extensions/prepared_statements_spec.rb +++ b/spec/extensions/prepared_statements_spec.rb @@ -32,6 +32,10 @@ end specify "should correctly create instance if dataset supports insert_select" do + ds = @c.instance_dataset + def ds.supports_insert_select? + true + end def @ds.supports_insert_select? true end diff --git a/spec/extensions/sharding_spec.rb b/spec/extensions/sharding_spec.rb index 8de50494d3..5aeaf65ac1 100644 --- a/spec/extensions/sharding_spec.rb +++ b/spec/extensions/sharding_spec.rb @@ -5,19 +5,19 @@ @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'} + instance_dataset._fetch = dataset._fetch = {:id=>2, :name=>'YJM'} columns :id, :name plugin :sharding end @Album = Class.new(Sequel::Model(@db[:albums])) @Album.class_eval do - dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2} + instance_dataset._fetch = dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2} columns :id, :artist_id, :name plugin :sharding end @Tag = Class.new(Sequel::Model(@db[:tags])) @Tag.class_eval do - dataset._fetch = {:id=>3, :name=>'M'} + instance_dataset._fetch = dataset._fetch = {:id=>3, :name=>'M'} columns :id, :name plugin :sharding end @@ -67,7 +67,7 @@ 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 + @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2 albums = @Album.server(:s1).eager(:artist).all @db.sqls.should == ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s2"] albums.length.should == 1 @@ -86,7 +86,7 @@ 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 + @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2 ds = @Album.server(:s1).eager_graph(:artist) ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'} albums = ds.all @@ -97,7 +97,7 @@ 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 + @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2 ds = @Album.eager_graph(:artist) ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'} albums = ds.all diff --git a/spec/extensions/skip_create_refresh_spec.rb b/spec/extensions/skip_create_refresh_spec.rb index e8e49f37fa..8190993012 100644 --- a/spec/extensions/skip_create_refresh_spec.rb +++ b/spec/extensions/skip_create_refresh_spec.rb @@ -5,7 +5,7 @@ c = Class.new(Sequel::Model(:a)) c.columns :id, :x c.db.reset - c.dataset.meta_def(:insert){|*a| super(*a); 2} + c.instance_dataset.meta_def(:insert){|*a| super(*a); 2} c.create(:x=>1) c.db.sqls.should == ['INSERT INTO a (x) VALUES (1)', 'SELECT * FROM a WHERE (id = 2) LIMIT 1'] diff --git a/spec/model/associations_spec.rb b/spec/model/associations_spec.rb index 437b154d16..0c14b6bcc8 100644 --- a/spec/model/associations_spec.rb +++ b/spec/model/associations_spec.rb @@ -653,7 +653,7 @@ def self.to_s; 'Node'; end it "should add a setter method" do @c2.one_to_one :attribute, :class => @c1 attrib = @c1.new(:id=>3) - @c1.dataset._fetch = {:id=>3} + @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>3} @c2.new(:id => 1234).attribute = attrib sqls = MODEL_DB.sqls ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)', @@ -692,7 +692,7 @@ def self.to_s; 'Node'; end it "should have the setter method respect the :primary_key option" do @c2.one_to_one :attribute, :class => @c1, :primary_key=>:xxx attrib = @c1.new(:id=>3) - @c1.dataset._fetch = {:id=>3} + @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>3} @c2.new(:id => 1234, :xxx=>5).attribute = attrib sqls = MODEL_DB.sqls ['INSERT INTO attributes (node_id, id) VALUES (5, 3)', @@ -836,7 +836,7 @@ class Parent < Sequel::Model; end d = @c2.new(:id => 1) f = @c2.new(:id => 3, :node_id=> 4321) - @c2.dataset._fetch = {:id => 3, :node_id=>1} + @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 3, :node_id=>1} d.parent = f f.values.should == {:id => 3, :node_id=>1} d.parent.should == f @@ -854,7 +854,7 @@ class Parent < Sequel::Model; end @c2.one_to_one :parent, :class => @c2, :primary_key=>:blah d = @c2.new(:id => 1, :blah => 3) e = @c2.new(:id => 4321, :node_id=>444) - @c2.dataset._fetch = {:id => 4321, :node_id => 3} + @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 4321, :node_id => 3} d.parent = e e.values.should == {:id => 4321, :node_id => 3} sqls = MODEL_DB.sqls @@ -867,7 +867,7 @@ class Parent < Sequel::Model; end @c2.one_to_one :parent, :class => @c2, :key=>:blah d = @c2.new(:id => 3) e = @c2.new(:id => 4321, :blah=>444) - @c2.dataset._fetch = {:id => 4321, :blah => 3} + @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 4321, :blah => 3} d.parent = e e.values.should == {:id => 4321, :blah => 3} sqls = MODEL_DB.sqls @@ -1181,7 +1181,7 @@ class Value < Sequel::Model; end n = @c2.load(:id => 1234) a = @c1.new(:id => 234) - @c1.dataset._fetch = {:node_id => 1234, :id => 234} + @c1.dataset._fetch = @c1.instance_dataset._fetch = {:node_id => 1234, :id => 234} a.should == n.add_attribute(a) sqls = MODEL_DB.sqls sqls.shift.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/ @@ -1213,7 +1213,7 @@ class Value < Sequel::Model; end @c2.one_to_many :attributes, :class => @c1 n = @c2.new(:id => 1234) MODEL_DB.reset - @c1.dataset._fetch = {:node_id => 1234, :id => 234} + @c1.dataset._fetch = @c1.instance_dataset._fetch = {:node_id => 1234, :id => 234} n.add_attribute(:id => 234).should == @c1.load(:node_id => 1234, :id => 234) sqls = MODEL_DB.sqls sqls.shift.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/ @@ -1969,7 +1969,7 @@ class Tag < Sequel::Model; end @c2.many_to_many :attributes, :class => @c1 n = @c2.load(:id => 1234) - @c1.dataset._fetch = {:id=>1} + @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>1} n.add_attribute(:id => 1).should == @c1.load(:id => 1) sqls = MODEL_DB.sqls ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 1)', diff --git a/spec/model/base_spec.rb b/spec/model/base_spec.rb index 97a362c2a0..a8c5bc94ab 100644 --- a/spec/model/base_spec.rb +++ b/spec/model/base_spec.rb @@ -407,7 +407,7 @@ class ::Leopard < Feline; end i.set(:x => 4, :y => 5, :z => 6) i.values.should == {:x => 4, :y => 5} - @c.dataset._fetch = {:x => 7} + @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7} i = @c.new i.update(:x => 7, :z => 9) i.values.should == {:x => 7} @@ -421,7 +421,7 @@ class ::Leopard < Feline; end i.set(:x => 4, :y => 5, :z => 6) i.values.should == {:x => 4, :y => 5} - @c.dataset._fetch = {:x => 7} + @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7} i = @c.new i.update(:x => 7, :z => 9) i.values.should == {:x => 7} @@ -436,7 +436,7 @@ class ::Leopard < Feline; end i.set(:x => 4, :y => 5, :z => 6) i.values.should == {:x => 4, :y => 5} - @c.dataset._fetch = {:y => 7} + @c.instance_dataset._fetch = @c.dataset._fetch = {:y => 7} i = @c.new i.update(:y => 7, :z => 9) i.values.should == {:y => 7} @@ -610,7 +610,7 @@ class ::Leopard < Feline; end it "should use Dataset#with_sql if simple_table and simple_pk are true" do @c.set_dataset :a - @c.dataset._fetch = {:id => 1} + @c.instance_dataset._fetch = @c.dataset._fetch = {:id => 1} @c[1].should == @c.load(:id=>1) @db.sqls.should == ['SELECT * FROM "a" WHERE "id" = 1'] end diff --git a/spec/model/model_spec.rb b/spec/model/model_spec.rb index 70bc6c07e2..90a33ffe96 100644 --- a/spec/model/model_spec.rb +++ b/spec/model/model_spec.rb @@ -339,8 +339,8 @@ class ::Album < Sequel::Model(@db[:table.identifier]); end end it "should use the last inserted id as primary key if not in values" do - @m.dataset._fetch = {:x => 1, :id => 1234} - @m.dataset.autoid = 1234 + @m.instance_dataset._fetch = @m.dataset._fetch = {:x => 1, :id => 1234} + @m.instance_dataset.autoid = @m.dataset.autoid = 1234 o = @m.new(:x => 1) o.save @@ -438,8 +438,8 @@ class ::Album < Sequel::Model(@db[:table.identifier]); end end it "should create the record if not found" do - @c.dataset._fetch = [[], {:x=>1, :id=>1}] - @c.dataset.autoid = 1 + @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}] + @c.instance_dataset.autoid = @c.dataset.autoid = 1 @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1) MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1", "INSERT INTO items (x) VALUES (1)", @@ -447,8 +447,8 @@ class ::Album < Sequel::Model(@db[:table.identifier]); end end it "should pass the new record to be created to the block if no record is found" do - @c.dataset._fetch = [[], {:x=>1, :id=>1}] - @c.dataset.autoid = 1 + @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}] + @c.instance_dataset.autoid = @c.dataset.autoid = 1 @c.find_or_create(:x => 1){|x| x[:y] = 2}.should == @c.load(:x=>1, :id=>1) sqls = MODEL_DB.sqls sqls.first.should == "SELECT * FROM items WHERE (x = 1) LIMIT 1" diff --git a/spec/model/record_spec.rb b/spec/model/record_spec.rb index 3edae4f402..86fd3e302f 100644 --- a/spec/model/record_spec.rb +++ b/spec/model/record_spec.rb @@ -26,7 +26,7 @@ @c = Class.new(Sequel::Model(:items)) do columns :id, :x, :y end - @c.dataset.autoid = 13 + @c.instance_dataset.autoid = @c.dataset.autoid = 13 MODEL_DB.reset end @@ -37,7 +37,7 @@ end it "should use dataset's insert_select method if present" do - ds = @c.dataset = @c.dataset.clone + ds = @c.instance_dataset ds._fetch = {:y=>2} def ds.supports_insert_select?() true end def ds.insert_select(hash) @@ -1146,7 +1146,7 @@ def z=(v) describe Sequel::Model, "#exists?" do before do @model = Class.new(Sequel::Model(:items)) - @model.dataset._fetch = proc{|sql| {:x=>1} if sql =~ /id = 1/} + @model.instance_dataset._fetch = @model.dataset._fetch = proc{|sql| {:x=>1} if sql =~ /id = 1/} MODEL_DB.reset end @@ -1454,7 +1454,7 @@ def z=(v) specify "should reload the instance values from the database" do @m = @c.new(:id => 555) @m[:x] = 'blah' - @c.dataset._fetch = {:x => 'kaboom', :id => 555} + @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 'kaboom', :id => 555} @m.refresh @m[:x].should == 'kaboom' MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id = 555) LIMIT 1"] @@ -1462,14 +1462,14 @@ def z=(v) specify "should raise if the instance is not found" do @m = @c.new(:id => 555) - @c.dataset._fetch = [] + @c.instance_dataset._fetch =@c.dataset._fetch = [] proc {@m.refresh}.should raise_error(Sequel::Error) MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id = 555) LIMIT 1"] end specify "should be aliased by #reload" do @m = @c.new(:id => 555) - @c.dataset._fetch = {:x => 'kaboom', :id => 555} + @c.instance_dataset._fetch =@c.dataset._fetch = {:x => 'kaboom', :id => 555} @m.reload @m[:x].should == 'kaboom' MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id = 555) LIMIT 1"]