sequel 3.23.0 → 3.24.0

data/spec/core/connection_pool_spec.rb

@@ -84,7 +84,9 @@ describe "A connection pool handling connections" do
   end
 
   specify "#make_new should not make more than max_size connections" do
-    50.times{Thread.new{@cpool.hold{sleep 0.001}}}
+    q = Queue.new
+    50.times{Thread.new{@cpool.hold{q.pop}}}
+    50.times{q.push nil}
     @cpool.created_count.should <= @max_size
   end
 
@@ -96,7 +98,8 @@ describe "A connection pool handling connections" do
 
   specify "#hold should remove the connection if a DatabaseDisconnectError is raised" do
     @cpool.created_count.should == 0
-    @cpool.hold{Thread.new{@cpool.hold{}}; sleep 0.03}
+    q, q1 = Queue.new, Queue.new
+    @cpool.hold{Thread.new{@cpool.hold{q1.pop; q.push nil}; q1.pop; q.push nil}; q1.push nil; q.pop; q1.push nil; q.pop}
     @cpool.created_count.should == 2
     proc{@cpool.hold{raise Sequel::DatabaseDisconnectError}}.should raise_error(Sequel::DatabaseDisconnectError)
     @cpool.created_count.should == 1
@@ -166,15 +169,14 @@ describe "A connection pool with a max size of 1" do
   
   specify "should let only one thread access the connection at any time" do
     cc,c1, c2 = nil
-    m = (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx') ? 30 : 1
+    q, q1 = Queue.new, Queue.new
     
-    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; while c == 'herro';sleep 0.01;end}}
-    sleep 0.02 * m
+    t1 = Thread.new {@pool.hold {|c| cc = c; c1 = c.dup; q1.push nil; q.pop}}
+    q1.pop
     cc.should == 'herro'
     c1.should == 'herro'
     
-    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; while c == 'hello';sleep 0.01;end}}
-    sleep 0.02 * m
+    t2 = Thread.new {@pool.hold {|c| c2 = c.dup; q1.push nil; q.pop;}}
     
     # connection held by t1
     t1.should be_alive
@@ -186,26 +188,22 @@ describe "A connection pool with a max size of 1" do
     
     @pool.available_connections.should be_empty
     @pool.allocated.should == {t1=>cc}
-    
+
     cc.gsub!('rr', 'll')
-    sleep 0.05 * m
-    
-    # connection held by t2
+    q.push nil
+    q1.pop
+
     t1.should_not be_alive
     t2.should be_alive
-
+    
     c2.should == 'hello'
 
     @pool.available_connections.should be_empty
     @pool.allocated.should == {t2=>cc}
     
-    cc.gsub!('ll', 'rr')
-    sleep 0.05 * m
-    
     #connection released
-    t2.should_not be_alive
-    
-    cc.should == 'herro'
+    q.push nil
+    t2.join
     
     @invoked_count.should == 1
     @pool.size.should == 1
@@ -236,34 +234,36 @@ describe "A connection pool with a max size of 1" do
 end
 
 shared_examples_for "A threaded connection pool" do  
+  specify "should raise a PoolTimeout error if a connection couldn't be acquired before timeout" do
+    x = nil
+    q, q1 = Queue.new, Queue.new
+    pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:max_connections=>1, :pool_timeout=>0)) {@invoked_count += 1}
+    t = Thread.new{pool.hold{|c| q1.push nil; q.pop}}
+    q1.pop
+    proc{pool.hold{|c|}}.should raise_error(Sequel::PoolTimeout)
+    q.push nil
+    t.join
+  end
+  
   specify "should let five threads simultaneously access separate connections" do
     cc = {}
     threads = []
-    stop = nil
+    q, q1, q2 = Queue.new, Queue.new, Queue.new
     
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.02;end}}; sleep 0.02}
-    sleep 0.04
+    5.times{|i| threads << Thread.new{@pool.hold{|c| q.pop; cc[i] = c; q1.push nil; q2.pop}}; q.push nil; q1.pop}
     threads.each {|t| t.should be_alive}
     cc.size.should == 5
     @invoked_count.should == 5
     @pool.size.should == 5
     @pool.available_connections.should be_empty
-    i = 0
+
     h = {}
+    i = 0
     threads.each{|t| h[t] = (i+=1)}
     @pool.allocated.should == h
-    
-    threads[0].raise "your'e dead"
-    sleep 0.02
-    threads[3].raise "your'e dead too"
-    
-    sleep 0.02
-    
-    @pool.available_connections.should == [1, 4]
-    @pool.allocated.should == {threads[1]=>2, threads[2]=>3, threads[4]=>5}
-    
-    stop = true
-    sleep 0.04
+    @pool.available_connections.should == []
+    5.times{q2.push nil}
+    threads.each{|t| t.join}
     
     @pool.available_connections.size.should == 5
     @pool.allocated.should be_empty
@@ -272,16 +272,15 @@ shared_examples_for "A threaded connection pool" do
   specify "should block threads until a connection becomes available" do
     cc = {}
     threads = []
-    stop = nil
+    q, q1 = Queue.new, Queue.new
     
-    5.times {|i| threads << Thread.new {@pool.hold {|c| cc[i] = c; while !stop;sleep 0.01;end}}; sleep 0.01}
-    sleep 0.02
+    5.times{|i| threads << Thread.new{@pool.hold{|c| cc[i] = c; q1.push nil; q.pop}}}
+    5.times{q1.pop}
     threads.each {|t| t.should be_alive}
     @pool.available_connections.should be_empty
 
-    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c}}}
+    3.times {|i| threads << Thread.new {@pool.hold {|c| cc[i + 5] = c; q1.push nil}}}
     
-    sleep 0.02
     threads[5].should be_alive
     threads[6].should be_alive
     threads[7].should be_alive
@@ -290,8 +289,10 @@ shared_examples_for "A threaded connection pool" do
     cc[6].should be_nil
     cc[7].should be_nil
     
-    stop = true
-    sleep 0.1
+    5.times{q.push nil}
+    5.times{|i| threads[i].join}
+    3.times{q1.pop}
+    3.times{|i| threads[i+5].join}
     
     threads.each {|t| t.should_not be_alive}
     
@@ -305,7 +306,8 @@ end
 describe "Threaded Unsharded Connection Pool" do
   before do
     @invoked_count = 0
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)) {@invoked_count += 1}
+    @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5)
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts) {@invoked_count += 1}
   end
   
   it_should_behave_like "A threaded connection pool"
@@ -314,7 +316,8 @@ end
 describe "Threaded Sharded Connection Pool" do
   before do
     @invoked_count = 0
-    @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {@invoked_count += 1}
+    @cp_opts = CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts) {@invoked_count += 1}
   end
 
   it_should_behave_like "A threaded connection pool"
@@ -324,19 +327,15 @@ describe "ConnectionPool#disconnect" do
   before do
     @count = 0
     @pool = Sequel::ConnectionPool.get_pool(CONNECTION_POOL_DEFAULTS.merge(:max_connections=>5, :servers=>{})) {{:id => @count += 1}}
+    threads = []
+    q, q1 = Queue.new, Queue.new
+    5.times {|i| threads << Thread.new {@pool.hold {|c| q1.push nil; q.pop}}}
+    5.times{q1.pop}
+    5.times{q.push nil}
+    threads.each {|t| t.join}
   end
   
   specify "should invoke the given block for each available connection" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
-    while @pool.size < 5
-      sleep 0.02
-    end
-    stop = true
-    sleep 0.1
-    threads.each {|t| t.join}
-    
     @pool.size.should == 5
     @pool.available_connections.size.should == 5
     @pool.available_connections.each {|c| c[:id].should_not be_nil}
@@ -346,34 +345,13 @@ describe "ConnectionPool#disconnect" do
   end
   
   specify "should remove all available connections" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
-    while @pool.size < 5
-      sleep 0.02
-    end
-    stop = true
-    sleep 0.1
-    threads.each {|t| t.join}
-    
     @pool.size.should == 5
     @pool.disconnect
     @pool.size.should == 0
   end
 
   specify "should disconnect connections in use as soon as they are no longer in use" do
-    threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new {@pool.hold {|c| while !stop;sleep 0.01;end}}; sleep 0.01}
-    while @pool.size < 5
-      sleep 0.02
-    end
-    stop = true
-    sleep 0.1
-    threads.each {|t| t.join}
-    
     @pool.size.should == 5
-    
     @pool.hold do |conn|
       @pool.available_connections.size.should == 4
       @pool.available_connections.each {|c| c.should_not be(conn)}
@@ -556,9 +534,10 @@ describe "A connection pool with multiple servers" do
   specify "#remove_servers should disconnect available connections immediately" do
     pool = Sequel::ConnectionPool.get_pool(:max_connections=>5, :servers=>{:server1=>{}}){|s| s}
     threads = []
-    stop = nil
-    5.times {|i| threads << Thread.new{pool.hold(:server1){|c| sleep 0.05}}}
-    sleep 0.1
+    q, q1 = Queue.new, Queue.new
+    5.times {|i| threads << Thread.new {pool.hold(:server1){|c| q1.push nil; q.pop}}}
+    5.times{q1.pop}
+    5.times{q.push nil}
     threads.each {|t| t.join}
     
     pool.size(:server1).should == 5

data/spec/core/database_spec.rb

@@ -397,6 +397,12 @@ describe "Database#tables" do
   end
 end
 
+describe "Database#views" do
+  specify "should raise Sequel::NotImplemented" do
+    proc {Sequel::Database.new.views}.should raise_error(Sequel::NotImplemented)
+  end
+end
+
 describe "Database#indexes" do
   specify "should raise Sequel::NotImplemented" do
     proc {Sequel::Database.new.indexes(:table)}.should raise_error(Sequel::NotImplemented)
@@ -803,6 +809,25 @@ describe "Database#transaction" do
     t.join
     @db.transactions.should be_empty
   end
+
+  if (!defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or RUBY_ENGINE == 'rbx') and RUBY_VERSION < '1.9'
+    specify "should handle Thread#kill for transactions inside threads" do
+      q = Queue.new
+      q1 = Queue.new
+      t = Thread.new do
+        @db.transaction do
+          @db.execute 'DROP TABLE test'
+          q1.push nil
+          q.pop
+          @db.execute 'DROP TABLE test2'
+        end
+      end
+      q1.pop
+      t.kill
+      t.join
+      @db.sql.should == ['BEGIN', 'DROP TABLE test', 'ROLLBACK']
+    end
+  end
 end
 
 describe "Database#transaction with savepoints" do

data/spec/core/dataset_spec.rb

@@ -538,34 +538,55 @@ describe "Dataset#where" do
 
   specify "should handle IN/NOT IN queries with multiple columns and a dataset where the database doesn't support it" do
     @dataset.meta_def(:supports_multiple_column_in?){false}
-    d1 = @d1.select(:id1, :id2)
+    db = MockDatabase.new()
+    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia')
+    d1.instance_variable_set(:@columns, [:id1, :id2])
     def d1.fetch_rows(sql)
-      @sql_used = sql
+      db << sql
       @columns = [:id1, :id2]
       yield(:id1=>1, :id2=>2)
       yield(:id1=>3, :id2=>4)
     end
-    d1.instance_variable_get(:@sql_used).should == nil
     @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
-    d1.instance_variable_set(:@sql_used, nil)
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    db.sqls.clear
     @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (((id1 != 1) OR (id2 != 2)) AND ((id1 != 3) OR (id2 != 4)))"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
   end
   
   specify "should handle IN/NOT IN queries with multiple columns and an empty dataset where the database doesn't support it" do
     @dataset.meta_def(:supports_multiple_column_in?){false}
-    d1 = @d1.select(:id1, :id2)
+    db = MockDatabase.new()
+    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia')
+    d1.instance_variable_set(:@columns, [:id1, :id2])
     def d1.fetch_rows(sql)
-      @sql_used = sql
+      db << sql
       @columns = [:id1, :id2]
     end
-    d1.instance_variable_get(:@sql_used).should == nil
     @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE ((id1 != id1) AND (id2 != id2))"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
-    d1.instance_variable_set(:@sql_used, nil)
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    db.sqls.clear
     @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (1 = 1)"
-    d1.instance_variable_get(:@sql_used).should == "SELECT id1, id2 FROM test WHERE (region = 'Asia')"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+  end
+  
+  specify "should handle IN/NOT IN queries for datasets with row_procs" do
+    @dataset.meta_def(:supports_multiple_column_in?){false}
+    db = MockDatabase.new()
+    d1 = db[:test].select(:id1, :id2).filter(:region=>'Asia')
+    d1.row_proc = proc{|h| Object.new}
+    d1.instance_variable_set(:@columns, [:id1, :id2])
+    def d1.fetch_rows(sql)
+      db << sql
+      @columns = [:id1, :id2]
+      yield(:id1=>1, :id2=>2)
+      yield(:id1=>3, :id2=>4)
+    end
+    @dataset.filter([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (((id1 = 1) AND (id2 = 2)) OR ((id1 = 3) AND (id2 = 4)))"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
+    db.sqls.clear
+    @dataset.exclude([:id1, :id2] => d1).sql.should == "SELECT * FROM test WHERE (((id1 != 1) OR (id2 != 2)) AND ((id1 != 3) OR (id2 != 4)))"
+    db.sqls.should == ["SELECT id1, id2 FROM test WHERE (region = 'Asia')"]
   end
   
   specify "should accept a subquery for an EXISTS clause" do
@@ -3283,6 +3304,7 @@ describe "Dataset prepared statements and bound variables " do
       ds
     end
     @ds = @db[:items]
+    @ds.meta_def(:insert_sql){|*v| "#{super(*v)}#{' RETURNING *' if opts.has_key?(:returning)}" }
   end
   
   specify "#call should take a type and bind hash and interpolate it" do
@@ -3291,11 +3313,13 @@ describe "Dataset prepared statements and bound variables " do
     @ds.filter(:num=>:$n).call(:delete, :n=>1)
     @ds.filter(:num=>:$n).call(:update, {:n=>1, :n2=>2}, :num=>:$n2)
     @ds.call(:insert, {:n=>1}, :num=>:$n)
+    @ds.call(:insert_select, {:n=>1}, :num=>:$n)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
-      'INSERT INTO items (num) VALUES (1)']
+      'INSERT INTO items (num) VALUES (1)',
+      'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
   specify "#prepare should take a type and name and store it in the database for later use with call" do
@@ -3305,18 +3329,21 @@ describe "Dataset prepared statements and bound variables " do
     pss << @ds.filter(:num=>:$n).prepare(:delete, :dn)
     pss << @ds.filter(:num=>:$n).prepare(:update, :un, :num=>:$n2)
     pss << @ds.prepare(:insert, :in, :num=>:$n)
-    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :sn, :un]
-    [:sn, :fn, :dn, :un, :in].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
+    pss << @ds.prepare(:insert_select, :ins, :num=>:$n)
+    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :ins, :sn, :un]
+    [:sn, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
     @db.call(:sn, :n=>1)
     @db.call(:fn, :n=>1)
     @db.call(:dn, :n=>1)
     @db.call(:un, :n=>1, :n2=>2)
     @db.call(:in, :n=>1)
+    @db.call(:ins, :n=>1)
     @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1) LIMIT 1',
       'DELETE FROM items WHERE (num = 1)',
       'UPDATE items SET num = 2 WHERE (num = 1)',
-      'INSERT INTO items (num) VALUES (1)']
+      'INSERT INTO items (num) VALUES (1)',
+      'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
   specify "#inspect should indicate it is a prepared statement with the prepared SQL" do
@@ -3599,6 +3626,76 @@ describe "Sequel::Dataset#qualify_to_first_source" do
   end
 end
 
+describe "Sequel::Dataset#unbind" do
+  before do
+    @ds = MockDatabase.new[:t]
+    @u = proc{|ds| ds, bv = ds.unbind; [ds.sql, bv]}
+  end
+
+  specify "should unbind values assigned to equality and inequality statements" do
+    @ds.filter(:foo=>1).unbind.first.sql.should == "SELECT * FROM t WHERE (foo = $foo)"
+    @ds.exclude(:foo=>1).unbind.first.sql.should == "SELECT * FROM t WHERE (foo != $foo)"
+    @ds.filter{foo > 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo > $foo)"
+    @ds.filter{foo >= 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo >= $foo)"
+    @ds.filter{foo < 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo < $foo)"
+    @ds.filter{foo <= 1}.unbind.first.sql.should == "SELECT * FROM t WHERE (foo <= $foo)"
+  end
+
+  specify "should return variables that could be used bound to recreate the previous query" do
+    @ds.filter(:foo=>1).unbind.last.should == {:foo=>1}
+    @ds.exclude(:foo=>1).unbind.last.should == {:foo=>1}
+  end
+
+  specify "should handle numerics, strings, dates, times, and datetimes" do
+    @u[@ds.filter(:foo=>1)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>1}]
+    @u[@ds.filter(:foo=>1.0)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>1.0}]
+    @u[@ds.filter(:foo=>BigDecimal.new('1.0'))].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>BigDecimal.new('1.0')}]
+    @u[@ds.filter(:foo=>'a')].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>'a'}]
+    @u[@ds.filter(:foo=>Date.today)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>Date.today}]
+    t = Time.now
+    @u[@ds.filter(:foo=>t)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>t}]
+    dt = DateTime.now
+    @u[@ds.filter(:foo=>dt)].should == ["SELECT * FROM t WHERE (foo = $foo)", {:foo=>dt}]
+  end
+
+  specify "should not unbind literal strings" do
+    @u[@ds.filter(:foo=>'a'.lit)].should == ["SELECT * FROM t WHERE (foo = a)", {}]
+  end
+
+  specify "should not unbind Identifiers, QualifiedIdentifiers, or Symbols used as booleans" do
+    @u[@ds.filter(:foo).filter{bar}.filter{foo__bar}].should == ["SELECT * FROM t WHERE (foo AND bar AND foo.bar)", {}]
+  end
+
+  specify "should not unbind for values it doesn't understand" do
+    @u[@ds.filter(:foo=>Class.new{def sql_literal(ds) 'bar' end}.new)].should == ["SELECT * FROM t WHERE (foo = bar)", {}]
+  end
+
+  specify "should handle QualifiedIdentifiers" do
+    @u[@ds.filter{foo__bar > 1}].should == ["SELECT * FROM t WHERE (foo.bar > $foo.bar)", {:"foo.bar"=>1}]
+  end
+
+  specify "should handle deep nesting" do
+    @u[@ds.filter{foo > 1}.and{bar < 2}.or(:baz=>3).and({~{:x=>4}=>true}.case(false))].should == ["SELECT * FROM t WHERE ((((foo > $foo) AND (bar < $bar)) OR (baz = $baz)) AND (CASE WHEN (x != $x) THEN 't' ELSE 'f' END))", {:foo=>1, :bar=>2, :baz=>3, :x=>4}]
+  end
+
+  specify "should handle JOIN ON" do
+    @u[@ds.cross_join(:x).join(:a, [:u]).join(:b, [[:c, :d], [:e,1]])].should == ["SELECT * FROM t CROSS JOIN x INNER JOIN a USING (u) INNER JOIN b ON ((b.c = a.d) AND (b.e = $b.e))", {:"b.e"=>1}]
+  end
+
+  specify "should raise an UnbindDuplicate exception if same variable is used with multiple different values" do
+    proc{@ds.filter(:foo=>1).or(:foo=>2).unbind}.should raise_error(Sequel::UnbindDuplicate)
+  end
+
+  specify "should handle case where the same variable has the same value in multiple places " do
+    @u[@ds.filter(:foo=>1).or(:foo=>1)].should == ["SELECT * FROM t WHERE ((foo = $foo) OR (foo = $foo))", {:foo=>1}]
+  end
+
+  specify "should raise Error for unhandled objects inside Identifiers and QualifiedIndentifiers" do
+    proc{@ds.filter(Sequel::SQL::Identifier.new([]) > 1).unbind}.should raise_error(Sequel::Error)
+    proc{@ds.filter{foo.qualify({}) > 1}.unbind}.should raise_error(Sequel::Error)
+  end
+end
+
 describe "Sequel::Dataset #with and #with_recursive" do
   before do
     @db = MockDatabase.new
@@ -3977,3 +4074,17 @@ describe "Dataset#lock_style and for_update" do
     @ds.lock_style("FOR SHARE").sql.should == "SELECT * FROM t FOR SHARE"
   end
 end
+
+describe "Custom ASTTransformer" do
+  specify "should transform given objects" do
+    c = Class.new(Sequel::ASTTransformer) do
+      def v(s)
+        (s.is_a?(Symbol) || s.is_a?(String)) ? :"#{s}#{s}" : super
+      end
+    end.new
+    ds = MockDatabase.new[:t].cross_join(:a___g).join(:b___h, [:c]).join(:d___i, :e=>:f)
+    ds.sql.should == 'SELECT * FROM t CROSS JOIN a AS g INNER JOIN b AS h USING (c) INNER JOIN d AS i ON (i.e = h.f)'
+    ds.clone(:from=>c.transform(ds.opts[:from]), :join=>c.transform(ds.opts[:join])).sql.should ==
+      'SELECT * FROM tt CROSS JOIN aa AS gg INNER JOIN bb AS hh USING (cc) INNER JOIN dd AS ii ON (ii.ee = hh.ff)'
+  end
+end