sequel 3.21.0 → 3.41.0

data/spec/extensions/split_array_nil_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
+
+describe "split_array_nil extension" do
+  before do
+    @ds = Sequel.mock[:table].extension(:split_array_nil)
+  end
+
+  specify "should split IN with nil in array into separate OR IS NULL clause" do
+    @ds.filter(:a=>[1, nil]).sql.should == "SELECT * FROM table WHERE ((a IN (1)) OR (a IS NULL))"
+  end
+
+  specify "should split NOT IN with nil in array into separate AND IS NOT NULL clause" do
+    @ds.exclude(:a=>[1, nil]).sql.should == "SELECT * FROM table WHERE ((a NOT IN (1)) AND (a IS NOT NULL))"
+  end
+
+  specify "should not affect other IN/NOT in clauses" do
+    @ds.filter(:a=>[1, 2]).sql.should == "SELECT * FROM table WHERE (a IN (1, 2))"
+    @ds.exclude(:a=>[1, 2]).sql.should == "SELECT * FROM table WHERE (a NOT IN (1, 2))"
+  end
+
+  specify "should not affect other types of filters clauses" do
+    @ds.filter(:a=>1).sql.should == "SELECT * FROM table WHERE (a = 1)"
+  end
+end

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/subclasses_spec.rb

@@ -49,4 +49,18 @@ describe Sequel::Model, "Subclasses plugin" do
     ssc1.descendents.should == [sssc1]
     sssc1.descendents.should == []
   end
+
+  specify "plugin block should be called with each subclass created" do
+    c = Class.new(Sequel::Model)
+    a = []
+    c.plugin(:subclasses){|sc| a << sc}
+    sc1 = Class.new(c)
+    a.should == [sc1]
+    sc2 = Class.new(c)
+    a.should == [sc1, sc2]
+    sc3 = Class.new(sc1)
+    a.should == [sc1, sc2, sc3]
+    sc4 = Class.new(sc3)
+    a.should == [sc1, sc2, sc3, sc4]
+  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
@@ -103,19 +100,19 @@ END
   end
 
   it "should handle SQL::OrderedExpressions" do
-    dot(@ds.order(:a.desc(:nulls=>:last))).should == ["1 -> 2 [label=\"order\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"OrderedExpression: DESC NULLS LAST\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];"]
+    dot(@ds.order(Sequel.desc(:a, :nulls=>:last))).should == ["1 -> 2 [label=\"order\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"OrderedExpression: DESC NULLS LAST\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];"]
   end
 
   it "should handle SQL::AliasedExpressions" do
-    dot(@ds.from(:a.as(:b))).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];"]
+    dot(@ds.from(Sequel.as(:a, :b))).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"AliasedExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"alias\"];", "5 [label=\":b\"];"]
   end
 
   it "should handle SQL::CaseExpressions" do
-    dot(@ds.select({:a=>:b}.case(:c, :d))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"CaseExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":d\"];", "3 -> 5 [label=\"conditions\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":a\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"default\"];", "9 [label=\":c\"];"]
+    dot(@ds.select(Sequel.case({:a=>:b}, :c, :d))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"CaseExpression\"];", "3 -> 4 [label=\"expression\"];", "4 [label=\":d\"];", "3 -> 5 [label=\"conditions\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"Array\"];", "6 -> 7 [label=\"0\"];", "7 [label=\":a\"];", "6 -> 8 [label=\"1\"];", "8 [label=\":b\"];", "3 -> 9 [label=\"default\"];", "9 [label=\":c\"];"]
   end
 
   it "should handle SQL::Cast" do
-    dot(@ds.select(:a.cast(Integer))).should ==  ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Cast\"];", "3 -> 4 [label=\"expr\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"type\"];", "5 [label=\"Integer\"];"]
+    dot(@ds.select(Sequel.cast(:a, Integer))).should ==  ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Cast\"];", "3 -> 4 [label=\"expr\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"type\"];", "5 [label=\"Integer\"];"]
   end
 
   it "should handle SQL::Function" 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(Sequel.subscript(:a, 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,11 +104,52 @@ 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
 
+  specify "should be able to touch many_to_one associations" do
+    @Album.plugin :touch, :associations=>:artist
+    @Album.load(:id=>3, :artist_id=>4).touch
+    MODEL_DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)",
+      "UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (artists.id = 4)"]
+  end
+
+  specify "should be able to touch many_to_one associations" do
+    @Artist.one_to_one :album, :class=>@Album, :key=>:artist_id
+    @Artist.plugin :touch, :associations=>:album
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should be able to touch many_to_many associations" do
+    @Artist.many_to_many :albums, :class=>@Album, :left_key=>:artist_id, :join_table=>:aa
+    @Artist.plugin :touch, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should be able to touch many_through_many associations" do
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :albums, [[:aa, :artist_id, :album_id]], :class=>@Album
+    @Artist.plugin :touch, :associations=>:albums
+    @a.touch
+    MODEL_DB.sqls.should == ["UPDATE artists SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)",
+      "SELECT albums.* FROM albums INNER JOIN aa ON ((aa.album_id = albums.id) AND (aa.artist_id = 1))",
+      "UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 1)"]
+  end
+
+  specify "should handle touching many_to_one associations with no associated object" do
+    @Album.plugin :touch, :associations=>:artist
+    @Album.load(:id=>3, :artist_id=>nil).touch
+    MODEL_DB.sqls.should == ["UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE (id = 3)"]
+  end
+
   specify "should not update a column that doesn't exist" do
     @Album.plugin :touch, :column=>:x
     a = @Album.load(:id=>1)
@@ -133,18 +175,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)