sequel 3.29.0 → 3.30.0

data/lib/sequel/model/associations.rb

@@ -718,6 +718,10 @@ module Sequel
         # :eager_loader_key :: A symbol for the key column to use to populate the key hash
         #                      for the eager loader.
         # :extend :: A module or array of modules to extend the dataset with.
+        # :graph_alias_base :: The base name to use for the table alias when eager graphing.  Defaults to the name
+        #                      of the association.  If the alias name has already been used in the query, Sequel will create
+        #                      a unique alias by appending a numeric suffix (e.g. alias_0, alias_1, ...) until the alias is
+        #                      unique.
         # :graph_block :: The block to pass to join_table when eagerly loading
         #                 the association via +eager_graph+.
         # :graph_conditions :: The additional conditions to use on the SQL join when eagerly loading
@@ -822,6 +826,7 @@ module Sequel
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
           conds = opts[:conditions]
+          opts[:graph_alias_base] ||= name
           opts[:graph_conditions] = conds if !opts.include?(:graph_conditions) and Sequel.condition_specifier?(conds)
           opts[:graph_conditions] = opts.fetch(:graph_conditions, []).to_a
           opts[:graph_select] = Array(opts[:graph_select]) if opts[:graph_select]
@@ -1618,7 +1623,7 @@ module Sequel
         # association and the values of the foreign/primary keys of +y+.  For most association
         # types, this is a simple transformation, but for +many_to_many+ associations this 
         # creates a subquery to the join table.
-        def complex_expression_sql(op, args)
+        def complex_expression_sql_append(sql, op, args)
           r = args.at(1)
           if (((op == :'=' || op == :'!=') and r.is_a?(Sequel::Model)) ||
               (multiple = ((op == :IN || op == :'NOT IN') and ((is_ds = r.is_a?(Sequel::Dataset)) or r.all?{|x| x.is_a?(Sequel::Model)}))))
@@ -1646,7 +1651,7 @@ module Sequel
               end
 
               if exp = association_filter_expression(op, ar, r)
-                literal(exp)
+                literal_append(sql, exp)
               else
                 raise Sequel::Error, "invalid association type #{ar[:type].inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}"
               end
@@ -1725,8 +1730,10 @@ module Sequel
         # Like +eager+, you need to call +all+ on the dataset for the eager loading to work.  If you just
         # call +each+, it will yield plain hashes, each containing all columns from all the tables.
         def eager_graph(*associations)
-          ds = if @opts[:eager_graph]
-            self
+          ds = if eg = @opts[:eager_graph]
+            eg = eg.dup
+            [:requirements, :reflections, :reciprocals].each{|k| eg[k] = eg[k].dup}
+            clone(:eager_graph=>eg)
           else
             # Each of the following have a symbol key for the table alias, with the following values: 
             # :reciprocals - the reciprocal instance variable to use for this association
@@ -1761,7 +1768,7 @@ module Sequel
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
           assoc_name = r[:name]
-          assoc_table_alias = ds.unused_table_alias(assoc_name)
+          assoc_table_alias = ds.unused_table_alias(r[:graph_alias_base])
           loader = r[:eager_grapher]
           if !associations.empty?
             if associations.first.respond_to?(:call)

data/lib/sequel/model/base.rb

@@ -1139,13 +1139,16 @@ module Sequel
       # Takes the following options:
       #
       # :changed :: save all changed columns, instead of all columns or the columns given
+      # :raise_on_failure :: set to true or false to override the current
+      #                      +raise_on_save_failure+ setting
+      # :server :: set the server/shard on the object before saving, and use that
+      #            server/shard in any transaction.
       # :transaction :: set to true or false to override the current
       #                 +use_transactions+ setting
       # :validate :: set to false to skip validation
-      # :raise_on_failure :: set to true or false to override the current
-      #                      +raise_on_save_failure+ setting
       def save(*columns)
         opts = columns.last.is_a?(Hash) ? columns.pop : {}
+        set_server(opts[:server]) if opts[:server] 
         if opts[:validate] != false
           unless checked_save_failure(opts){_valid?(true, opts)}
             raise(ValidationFailed.new(errors)) if raise_on_failure?(opts)
@@ -1225,6 +1228,13 @@ module Sequel
         set_restricted(hash, only.flatten, false)
       end
   
+      # Set the shard that this object is tied to.  Returns self.
+      def set_server(s)
+        @server = s
+        @this.opts[:server] = s if @this
+        self
+      end
+
       # Replace the current values with hash.  Should definitely not be
       # used with untrusted input, and should probably not be called
       # directly by user code.
@@ -1243,7 +1253,7 @@ module Sequel
       #   Artist[1].this
       #   # SELECT * FROM artists WHERE (id = 1) LIMIT 1
       def this
-        @this ||= model.dataset.filter(pk_hash).limit(1).naked
+        @this ||= use_server(model.dataset.filter(pk_hash).limit(1).naked)
       end
       
       # Runs #set with the passed hash and then runs save_changes.
@@ -1382,7 +1392,7 @@ module Sequel
       # The dataset to use when inserting a new object.   The same as the model's
       # dataset by default.
       def _insert_dataset
-        model.dataset
+        use_server(model.dataset)
       end
   
       # Insert into the given dataset and return the primary key created (if any).
@@ -1676,6 +1686,11 @@ module Sequel
         set_restricted(hash, only, except)
         save_changes
       end
+
+      # Set the given dataset to use the current object's shard.
+      def use_server(ds)
+        @server ? ds.server(@server) : ds
+      end
       
       # Whether to use a transaction for this action.  If the :transaction
       # option is present in the hash, use that, otherwise, fallback to the
@@ -1716,7 +1731,7 @@ module Sequel
       #   # ...
       def destroy
         pr = proc{all{|r| r.destroy}.length}
-        model.use_transactions ? @db.transaction(&pr) : pr.call
+        model.use_transactions ? @db.transaction(:server=>opts[:server], &pr) : pr.call
       end
 
       # This allows you to call +to_hash+ without any arguments, which will

data/lib/sequel/plugins/sharding.rb

@@ -1,13 +1,14 @@
 module Sequel
   module Plugins
-    # The sharding plugin makes it easy to use Sequel's sharding features
-    # with models.  It lets you create model objects on specific shards,
-    # and any models retrieved from specific shards are automatically
-    # saved back to those shards.  It also works with associations,
-    # so that model objects retrieved from specific shards will only
-    # return associated objects from that shard, and using the
-    # add/remove/remove_all association methods will only affect
-    # that shard.
+    # The sharding plugin augments Sequel's default model sharding support
+    # in the following ways:
+    #
+    # 1) It automatically sets model instances to be saved back to the
+    #    shard they were retreived from.
+    # 2) It makes model associations use the same shard as the model
+    #    object.
+    # 3) It adds a slightly nicer API for creating model instances on
+    #    specific shards.
     # 
     # Usage:
     #
@@ -55,12 +56,6 @@ module Sequel
       end
 
       module InstanceMethods
-        # Set the shard that this object is tied to.  Returns self.
-        def set_server(s)
-          @server = s
-          self
-        end
-
         # Set the server that this object is tied to, unless it has
         # already been set.  Returns self.
         def set_server?(s)
@@ -68,11 +63,6 @@ module Sequel
           self
         end
 
-        # Ensure that the instance dataset is tied to the correct shard.
-        def this
-          use_server(super)
-        end
-
         private
 
         # Ensure that association datasets are tied to the correct shard.
@@ -80,11 +70,6 @@ module Sequel
           use_server(super)
         end
 
-        # Ensure that the object is inserted into the correct shard.
-        def _insert_dataset
-          use_server(super)
-        end
-
         # Ensure that the join table for many_to_many associations uses the correct shard.
         def _join_table_dataset(opts)
           use_server(super)
@@ -97,11 +82,6 @@ module Sequel
           o.set_server?(@server) if o.respond_to?(:set_server?)
           super
         end
-
-        # Set the given dataset to use the current object's shard.
-        def use_server(ds)
-          @server ? ds.server(@server) : ds
-        end
       end
 
       module DatasetMethods

data/lib/sequel/sql.rb

@@ -79,7 +79,8 @@ module Sequel
       # the method provided on the dataset with args as the argument (self by default).
       # Used to DRY up some code.
       def self.to_s_method(meth, args=:self) # :nodoc:
-        class_eval("def to_s(ds); ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+        class_eval("def to_s(ds) ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+        class_eval("def to_s_append(ds, sql) ds.#{meth}_append(sql, #{args}) end", __FILE__, __LINE__)
       end
       private_class_method :to_s_method
 

data/lib/sequel/timezones.rb

@@ -145,14 +145,24 @@ module Sequel
           v2
         end
       when Array
-        y, mo, d, h, mi, s = v
+        y, mo, d, h, mi, s, ns, off = v
         if datetime_class == DateTime
-          convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s, 0), input_timezone)
+          s += (defined?(Rational) ? Rational(ns, 1000000000) : ns/1000000000.0) if ns
+          if off
+            DateTime.civil(y, mo, d, h, mi, s, off)
+          else
+            convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s), input_timezone)
+          end
         else
-          Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s)
+          Time.send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
         end
       when Hash
-        convert_input_timestamp([:year, :month, :day, :hour, :minute, :second].map{|x| (v[x] || v[x.to_s]).to_i}, input_timezone)
+        ary = [:year, :month, :day, :hour, :minute, :second, :nanos].map{|x| (v[x] || v[x.to_s]).to_i}
+        if (offset = (v[:offset] || v['offset']))
+          ary << offset
+        end
+        convert_input_timestamp(ary, input_timezone)
+        convert_input_timestamp(ary, input_timezone)
       when Time
         if datetime_class == DateTime
           v.respond_to?(:to_datetime) ? v.to_datetime : string_to_datetime(v.iso8601)

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 29
+  MINOR = 30
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mysql_spec.rb

@@ -247,6 +247,16 @@ describe "A MySQL dataset" do
     
     @d.first[:name].should == ':\\'
   end
+  
+  specify "should handle prepared statements with on_duplicate_key_update" do
+    @d.db.add_index :items, :value, :unique=>true
+    ds = @d.on_duplicate_key_update
+    ps = ds.prepare(:insert, :insert_user_id_feature_name, :value => :$v, :name => :$n)
+    ps.call(:v => 1, :n => 'a')
+    ds.all.should == [{:value=>1, :name=>'a'}]
+    ps.call(:v => 1, :n => 'b')
+    ds.all.should == [{:value=>1, :name=>'b'}]
+  end
 end
 
 describe "MySQL datasets" do

data/spec/adapters/oracle_spec.rb

@@ -187,7 +187,7 @@ describe "An Oracle dataset" do
     @d << {:name => 'def', :value => 789}
     @d.filter('value > 500').update(:date_created => "to_timestamp('2009-09-09', 'YYYY-MM-DD')".lit)
     
-    @d[:name => 'def'][:date_created].should == Time.parse('2009-09-09')
+    @d[:name => 'def'][:date_created].strftime('%F').should == '2009-09-09'
   end
   
   specify "should delete records correctly" do

data/spec/core/core_sql_spec.rb

@@ -177,7 +177,9 @@ end
 describe "Column references" do
   before do
     @ds = Sequel::Database.new.dataset
-    def @ds.quoted_identifier(c); "`#{c}`"; end
+    def @ds.quoted_identifier_append(sql, c)
+      sql << "`#{c}`"
+    end
     @ds.quote_identifiers = true
   end
   

data/spec/core/database_spec.rb

@@ -739,6 +739,13 @@ describe "Database#transaction" do
     proc{@db.after_rollback}.should raise_error(Sequel::Error)
   end
 
+  specify "should have after_commit and after_rollback respect :server option" do
+    @db.transaction(:server=>:test){@db.after_commit(:server=>:test){@db.execute('foo', :server=>:test)}}
+    @db.sqls.should == ['BEGIN -- test', 'COMMIT -- test', 'foo -- test']
+    @db.transaction(:server=>:test){@db.after_rollback(:server=>:test){@db.execute('foo', :server=>:test)}; raise Sequel::Rollback}
+    @db.sqls.should == ['BEGIN -- test', 'ROLLBACK -- test', 'foo -- test']
+  end
+
   specify "should execute after_commit outside transactions" do
     @db.after_commit{@db.execute('foo')}
     @db.sqls.should == ['foo']
@@ -1774,6 +1781,41 @@ describe "Database#typecast_value" do
     end
   end
 
+  specify "should handle arrays when typecasting timestamps" do
+    begin
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).should == Time.local(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
+
+      Sequel.datetime_class = DateTime
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14]).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000]).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
+      @db.typecast_value(:datetime, [2011, 10, 11, 12, 13, 14, 500000000, (defined?(Rational) ? Rational(1, 2) : 0.5)]).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
+    ensure
+      Sequel.datetime_class = Time
+    end
+  end
+
+  specify "should handle hashes when typecasting timestamps" do
+    begin
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).should == Time.local(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).should == Time.local(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).should == Time.local(2011, 10, 11, 12, 13, 14, 500000)
+
+      Sequel.datetime_class = DateTime
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14).should == DateTime.civil(2011, 10, 11, 12, 13, 14)
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5))
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :offset=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, 14, (defined?(Rational) ? Rational(1, 2) : 0.5))
+      @db.typecast_value(:datetime, :year=>2011, :month=>10, :day=>11, :hour=>12, :minute=>13, :second=>14, :nanos=>500000000, :offset=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'offset'=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, 14, (defined?(Rational) ? Rational(1, 2) : 0.5))
+      @db.typecast_value(:datetime, 'year'=>2011, 'month'=>10, 'day'=>11, 'hour'=>12, 'minute'=>13, 'second'=>14, 'nanos'=>500000000, 'offset'=>(defined?(Rational) ? Rational(1, 2) : 0.5)).should == DateTime.civil(2011, 10, 11, 12, 13, (defined?(Rational) ? Rational(29, 2) : 14.5), (defined?(Rational) ? Rational(1, 2) : 0.5))
+    ensure
+      Sequel.datetime_class = Time
+    end
+  end
+
   specify "should typecast decimal values to BigDecimal" do
     [1.0, 1, '1.0', BigDecimal('1.0')].each do |i|
       v = @db.typecast_value(:decimal, i)

data/spec/core/dataset_spec.rb

@@ -3066,6 +3066,13 @@ describe "Dataset prepared statements and bound variables " do
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)']
   end
     
+  specify "should handle columns on prepared statements correctly" do
+    @db.columns = [:num]
+    @ds.meta_def(:select_where_sql){|sql| super(sql); sql << " OR #{columns.first} = 1" if opts[:where]}
+    @ds.filter(:num=>:$n).prepare(:select, :sn).sql.should == 'SELECT * FROM items WHERE (num = $n) OR num = 1'
+    @db.sqls.should == ['SELECT * FROM items LIMIT 1']
+  end
+    
   specify "should handle datasets using static sql and placeholders" do
     @db["SELECT * FROM items WHERE (num = ?)", :$n].call(:select, :n=>1)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)']
@@ -3412,7 +3419,7 @@ describe "Sequel::Dataset #with and #with_recursive" do
 
   specify "#with should work on insert, update, and delete statements if they support it" do
     [:insert, :update, :delete].each do |m|
-      @ds.meta_def(:"#{m}_clause_methods"){super() + [:"#{m}_with_sql"]}
+      @ds.meta_def(:"#{m}_clause_methods"){[:"#{m}_with_sql"] + super()}
     end
     @ds.with(:t, @db[:x]).insert_sql(1).should == 'WITH t AS (SELECT * FROM x) INSERT INTO t VALUES (1)'
     @ds.with(:t, @db[:x]).update_sql(:foo=>1).should == 'WITH t AS (SELECT * FROM x) UPDATE t SET foo = 1'
@@ -3888,8 +3895,8 @@ describe "Dataset emulating bitwise operator support" do
   before do
     @ds = Sequel::Database.new.dataset
     @ds.quote_identifiers = true
-    def @ds.complex_expression_sql(op, args)
-      complex_expression_arg_pairs(args){|a, b| "bitand(#{literal(a)}, #{literal(b)})"}
+    def @ds.complex_expression_sql_append(sql, op, args)
+      sql << complex_expression_arg_pairs(args){|a, b| "bitand(#{literal(a)}, #{literal(b)})"}
     end
   end
 

data/spec/core/mock_adapter_spec.rb

@@ -7,6 +7,10 @@ describe "Sequel Mock Adapter" do
     db.adapter_scheme.should == :mock
   end
 
+  specify "should have constructor accept no arguments" do
+    Sequel::Mock::Database.new.should be_a_kind_of(Sequel::Mock::Database)
+  end
+
   specify "should each not return any rows by default" do
     called = false
     Sequel.mock[:t].each{|r| called = true}

data/spec/core/object_graph_spec.rb

@@ -28,11 +28,49 @@ describe Sequel::Dataset, " graphing" do
     ds1.opts.should_not == o1
   end
 
+  it "#graph should not modify the current dataset's opts if current dataset is already graphed" do
+    ds2 = @ds1.graph(@ds2)
+    proc{@ds1.graph(@ds2)}.should_not raise_error
+    proc{ds2.graph(@ds3)}.should_not raise_error
+    proc{ds2.graph(@ds3)}.should_not raise_error
+  end
+
   it "#graph should accept a simple dataset and pass the table to join" do
     ds = @ds1.graph(@ds2, :x=>:id)
     ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
   end
 
+  it "#graph should use currently selected columns as the basis for the selected columns in a new graph" do
+    ds = @ds1.select(:id).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, lines.id AS lines_id, lines.x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :lines_id=>2, :x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id, :x).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x, lines.id AS lines_id, lines.x AS lines_x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id.identifier, :x.qualify(:points)).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x, lines.id AS lines_id, lines.x AS lines_x, lines.y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :x=>-1, :lines_id=>2, :lines_x=>3, :y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :x=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id.identifier.qualify(:points), :x.identifier.as(:y)).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+
+    ds = @ds1.select(:id, :x.identifier.qualify(:points.identifier).as(:y.identifier)).graph(@ds2, :x=>:id)
+    ds.sql.should == 'SELECT points.id, points.x AS y, lines.id AS lines_id, lines.x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
+    ds._fetch = {:id=>1, :y=>-1, :lines_id=>2, :x=>3, :lines_y=>4, :graph_id=>5}
+    ds.all.should == [{:points=>{:id=>1, :y=>-1}, :lines=>{:id=>2, :x=>3, :y=>4, :graph_id=>5}}]
+  end
+
+  it "#graph should raise error if currently selected expressions cannot be handled" do
+    proc{@ds1.select(1).graph(@ds2, :x=>:id)}.should raise_error(Sequel::Error)
+  end
+
   it "#graph should accept a complex dataset and pass it directly to join" do
     ds = @ds1.graph(@ds2.filter(:x=>1), {:x=>:id})
     ds.sql.should == 'SELECT points.id, points.x, points.y, t1.id AS t1_id, t1.x AS t1_x, t1.y AS t1_y, t1.graph_id FROM points LEFT OUTER JOIN (SELECT * FROM lines WHERE (x = 1)) AS t1 ON (t1.x = points.id)'

data/spec/extensions/association_autoreloading_spec.rb

@@ -5,11 +5,7 @@ describe "AssociationAutoreloading plugin" do
     @c = Class.new(Sequel::Model)
     @c.plugin :association_autoreloading
     @Artist = Class.new(@c).set_dataset(:artists)
-    ds1 = @Artist.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>2, :name=>'Ar'})
-    end
+    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
     @Album = Class.new(@c).set_dataset(:albums)
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
@@ -22,7 +18,6 @@ describe "AssociationAutoreloading plugin" do
     album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 1
     album.artist
@@ -33,7 +28,6 @@ describe "AssociationAutoreloading plugin" do
     album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 2
     album.artist
@@ -54,7 +48,6 @@ describe "AssociationAutoreloading plugin" do
     album.artist_id = 1
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
-    MODEL_DB.reset
 
     album.other_artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
@@ -69,7 +62,6 @@ describe "AssociationAutoreloading plugin" do
     album.artist_id = 1
     album.composite_artist
     MODEL_DB.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 1) AND (artists.name = 'Al')) LIMIT 1"]
-    MODEL_DB.reset
 
     album.name = 'Al2'
     album.composite_artist
@@ -84,7 +76,6 @@ describe "AssociationAutoreloading plugin" do
     album = salbum.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 1
     album.artist