sequel 3.21.0 → 3.28.0

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
@@ -601,10 +622,18 @@ describe "Dataset#where" do
   end
 
   specify "should accept true and false as arguments" do
-    @dataset.filter(true).sql.should ==
-      "SELECT * FROM test WHERE 't'"
-    @dataset.filter(false).sql.should ==
-      "SELECT * FROM test WHERE 'f'"
+    @dataset.filter(true).sql.should == "SELECT * FROM test WHERE 't'"
+    @dataset.filter(Sequel::SQLTRUE).sql.should == "SELECT * FROM test WHERE 't'"
+    @dataset.filter(false).sql.should == "SELECT * FROM test WHERE 'f'"
+    @dataset.filter(Sequel::SQLFALSE).sql.should == "SELECT * FROM test WHERE 'f'"
+  end
+
+  specify "should use boolean expression if dataset does not support where true/false" do
+    def @dataset.supports_where_true?() false end
+    @dataset.filter(true).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+    @dataset.filter(Sequel::SQLTRUE).sql.should == "SELECT * FROM test WHERE (1 = 1)"
+    @dataset.filter(false).sql.should == "SELECT * FROM test WHERE (1 = 0)"
+    @dataset.filter(Sequel::SQLFALSE).sql.should == "SELECT * FROM test WHERE (1 = 0)"
   end
 
   specify "should allow the use of multiple arguments" do
@@ -738,6 +767,11 @@ describe "Dataset#exclude" do
       "SELECT * FROM test WHERE (region != 'Asia')"
   end
 
+  specify "should affect the having clause if having clause is already used" do
+    @dataset.group_and_count(:name).having{count > 2}.exclude{count > 5}.sql.should ==
+      "SELECT name, count(*) AS count FROM test GROUP BY name HAVING ((count > 2) AND (count <= 5))"
+  end
+
   specify "should take multiple conditions as a hash and express the logic correctly in SQL" do
     @dataset.exclude(:region => 'Asia', :name => 'Japan').select_sql.
       should match(Regexp.union(/WHERE \(\(region != 'Asia'\) OR \(name != 'Japan'\)\)/,
@@ -772,6 +806,28 @@ describe "Dataset#exclude" do
   end
 end
 
+describe "Dataset#exclude_where" do
+  before do
+    @dataset = Sequel::Dataset.new(nil).from(:test)
+  end
+
+  specify "should correctly negate the expression and add it to the where clause" do
+    @dataset.exclude_where(:region=>'Asia').sql.should == "SELECT * FROM test WHERE (region != 'Asia')"
+    @dataset.exclude_where(:region=>'Asia').exclude_where(:region=>'NA').sql.should == "SELECT * FROM test WHERE ((region != 'Asia') AND (region != 'NA'))"
+  end
+
+  specify "should affect the where clause even if having clause is already used" do
+    @dataset.group_and_count(:name).having{count > 2}.exclude_where(:region=>'Asia').sql.should ==
+      "SELECT name, count(*) AS count FROM test WHERE (region != 'Asia') GROUP BY name HAVING (count > 2)"
+  end
+end
+
+describe "Dataset#exclude_having" do
+  specify "should correctly negate the expression and add it to the having clause" do
+    Sequel::Dataset.new(nil).from(:test).exclude_having{count > 2}.exclude_having{count < 0}.sql.should == "SELECT * FROM test HAVING ((count <= 2) AND (count >= 0))"
+  end
+end
+
 describe "Dataset#invert" do
   before do
     @d = Sequel::Dataset.new(nil).from(:test)
@@ -876,7 +932,7 @@ describe "Dataset#group_by" do
       "SELECT * FROM test GROUP BY (type_id IS NULL)"
   end
 
-  specify "should ungroup when passed nil, empty, or no arguments" do
+  specify "should ungroup when passed nil or no arguments" do
     @dataset.group_by.select_sql.should ==
       "SELECT * FROM test"
     @dataset.group_by(nil).select_sql.should ==
@@ -894,6 +950,13 @@ describe "Dataset#group_by" do
     @dataset.group(:type_id=>nil).select_sql.should ==
       "SELECT * FROM test GROUP BY (type_id IS NULL)"
   end
+
+  specify "should take a virtual row block" do
+    @dataset.group{type_id > 1}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1)"
+    @dataset.group_by{type_id > 1}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1)"
+    @dataset.group{[type_id > 1, type_id < 2]}.sql.should == "SELECT * FROM test GROUP BY (type_id > 1), (type_id < 2)"
+    @dataset.group(:foo){type_id > 1}.sql.should == "SELECT * FROM test GROUP BY foo, (type_id > 1)"
+  end
 end
 
 describe "Dataset#as" do
@@ -965,6 +1028,12 @@ describe "Dataset#literal" do
     d.literal(d).should == "(#{d.sql})"
   end
   
+  specify "should literalize Sequel::SQLTime properly" do
+    t = Sequel::SQLTime.now
+    s = t.strftime("'%H:%M:%S")
+    @dataset.literal(t).should == "#{s}.#{sprintf('%06i', t.usec)}'"
+  end
+  
   specify "should literalize Time properly" do
     t = Time.now
     s = t.strftime("'%Y-%m-%d %H:%M:%S")
@@ -1198,6 +1267,27 @@ describe "Dataset#select" do
   end
 end
 
+describe "Dataset#select_group" do
+  before do
+    @d = Sequel::Dataset.new(nil).from(:test)
+  end
+
+  specify "should set both SELECT and GROUP" do
+    @d.select_group(:name).sql.should == 'SELECT name FROM test GROUP BY name'
+    @d.select_group(:a, :b__c, :d___e).sql.should == 'SELECT a, b.c, d AS e FROM test GROUP BY a, b.c, d'
+  end
+
+  specify "should remove from both SELECT and GROUP if no arguments" do
+    @d.select_group(:name).select_group.sql.should == 'SELECT * FROM test'
+  end
+
+  specify "should accept virtual row blocks" do
+    @d.select_group{name}.sql.should == 'SELECT name FROM test GROUP BY name'
+    @d.select_group{[name, f(v).as(a)]}.sql.should == 'SELECT name, f(v) AS a FROM test GROUP BY name, f(v)'
+    @d.select_group(:name){f(v).as(a)}.sql.should == 'SELECT name, f(v) AS a FROM test GROUP BY name, f(v)'
+  end
+end
+  
 describe "Dataset#select_all" do
   before do
     @d = Sequel::Dataset.new(nil).from(:test)
@@ -1210,6 +1300,40 @@ describe "Dataset#select_all" do
   specify "should overrun the previous select option" do
     @d.select!(:a, :b, :c).select_all.sql.should == 'SELECT * FROM test'
   end
+
+  specify "should select all columns in a table if given an argument" do
+    @d.select_all(:test).sql.should == 'SELECT test.* FROM test'
+  end
+  
+  specify "should select all columns all tables if given a multiple arguments" do
+    @d.select_all(:test, :foo).sql.should == 'SELECT test.*, foo.* FROM test'
+  end
+  
+  specify "should work correctly with qualified symbols" do
+    @d.select_all(:sch__test).sql.should == 'SELECT sch.test.* FROM test'
+  end
+  
+  specify "should work correctly with aliased symbols" do
+    @d.select_all(:test___al).sql.should == 'SELECT al.* FROM test'
+    @d.select_all(:sch__test___al).sql.should == 'SELECT al.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::Identifiers" do
+    @d.select_all(:test.identifier).sql.should == 'SELECT test.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::QualifiedIdentifier" do
+    @d.select_all(:test.qualify(:sch)).sql.should == 'SELECT sch.test.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::AliasedExpressions" do
+    @d.select_all(:test.as(:al)).sql.should == 'SELECT al.* FROM test'
+  end
+  
+  specify "should work correctly with SQL::JoinClauses" do
+    d = @d.cross_join(:foo).cross_join(:test___al)
+    @d.select_all(*d.opts[:join]).sql.should == 'SELECT foo.*, al.* FROM test'
+  end
 end
 
 describe "Dataset#select_more" do
@@ -1254,6 +1378,14 @@ describe "Dataset#select_append" do
     @d.select(:a).select_append{|o| o.b}.sql.should == 'SELECT a, b FROM test'
     @d.select(:a.*).select_append(:b.*){b(1)}.sql.should == 'SELECT a.*, b.*, b(1) FROM test'
   end
+
+  specify "should select from all from and join tables if SELECT *, column not supported" do
+    @d.meta_def(:supports_select_all_and_column?){false}
+    @d.select_append(:b).sql.should == 'SELECT test.*, b FROM test'
+    @d.from(:test, :c).select_append(:b).sql.should == 'SELECT test.*, c.*, b FROM test, c'
+    @d.cross_join(:c).select_append(:b).sql.should == 'SELECT test.*, c.*, b FROM test CROSS JOIN c'
+    @d.cross_join(:c).cross_join(:d).select_append(:b).sql.should == 'SELECT test.*, c.*, d.*, b FROM test CROSS JOIN c CROSS JOIN d'
+  end
 end
 
 describe "Dataset#order" do
@@ -1355,6 +1487,13 @@ describe "Dataset#with_sql" do
   specify "should keep row_proc" do
     @dataset.with_sql('SELECT 1 FROM test').row_proc.should == @dataset.row_proc
   end
+
+  specify "should work with method symbols and arguments" do
+    @dataset.with_sql(:delete_sql).sql.should == 'DELETE FROM test'
+    @dataset.with_sql(:insert_sql, :b=>1).sql.should == 'INSERT INTO test (b) VALUES (1)'
+    @dataset.with_sql(:update_sql, :b=>1).sql.should == 'UPDATE test SET b = 1'
+  end
+  
 end
 
 describe "Dataset#order_by" do
@@ -1571,17 +1710,6 @@ describe "Dataset#qualified_column_name" do
   end
 end
 
-class DummyDataset < Sequel::Dataset
-  VALUES = [
-    {:a => 1, :b => 2},
-    {:a => 3, :b => 4},
-    {:a => 5, :b => 6}
-  ]
-  def fetch_rows(sql, &block)
-    VALUES.each(&block)
-  end
-end
-
 describe "Dataset#map" do
   before do
     @d = DummyDataset.new(nil).from(:items)
@@ -1595,6 +1723,10 @@ describe "Dataset#map" do
     @d.map(:a).should == [1, 3, 5]
   end
   
+  specify "should support multiple column names if an array of column names is given" do
+    @d.map([:a, :b]).should == [[1, 2], [3, 4], [5, 6]]
+  end
+  
   specify "should return the complete dataset values if nothing is given" do
     @d.map.to_a.should == DummyDataset::VALUES
   end
@@ -1614,6 +1746,13 @@ describe "Dataset#to_hash" do
     @d.to_hash(:a).should == {1 => {:a => 1, :b => 2}, 3 => {:a => 3, :b => 4}, 5 => {:a => 5, :b => 6}}
     @d.to_hash(:b).should == {2 => {:a => 1, :b => 2}, 4 => {:a => 3, :b => 4}, 6 => {:a => 5, :b => 6}}
   end
+
+  specify "should support using an array of columns as either the key or the value" do
+    @d.to_hash([:a, :b], :b).should == {[1, 2] => 2, [3, 4] => 4, [5, 6] => 6}
+    @d.to_hash(:b, [:a, :b]).should == {2 => [1, 2], 4 => [3, 4], 6 => [5, 6]}
+    @d.to_hash([:b, :a], [:a, :b]).should == {[2, 1] => [1, 2], [4, 3] => [3, 4], [6, 5] => [5, 6]}
+    @d.to_hash([:a, :b]).should == {[1, 2] => {:a => 1, :b => 2}, [3, 4] => {:a => 3, :b => 4}, [5, 6] => {:a => 5, :b => 6}}
+  end
 end
 
 describe "Dataset#distinct" do
@@ -1753,6 +1892,12 @@ describe "Dataset#group_and_count" do
     @ds.group_and_count(:name.identifier.as(:n)).sql.should ==
       "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
   end
+
+  specify "should take a virtual row block" do
+    @ds.group_and_count{(type_id > 1).as(t)}.sql.should == "SELECT (type_id > 1) AS t, count(*) AS count FROM test GROUP BY (type_id > 1)"
+    @ds.group_and_count{[(type_id > 1).as(t), type_id < 2]}.sql.should == "SELECT (type_id > 1) AS t, (type_id < 2), count(*) AS count FROM test GROUP BY (type_id > 1), (type_id < 2)"
+    @ds.group_and_count(:foo){type_id > 1}.sql.should == "SELECT foo, (type_id > 1), count(*) AS count FROM test GROUP BY foo, (type_id > 1)"
+  end
 end
 
 describe "Dataset#empty?" do
@@ -2081,6 +2226,12 @@ describe "Dataset#join_table" do
     @d.join(:categories, [:id]).sql.should == 'SELECT * FROM "items" INNER JOIN "categories" ON ("categories"."id" = "items"."id")'
   end
 
+  specify "should hoist WITH clauses from subqueries if the dataset doesn't support CTEs in subselects" do
+    @d.meta_def(:supports_cte?){true}
+    @d.meta_def(:supports_cte_in_subselect?){false}
+    @d.join(Sequel::Dataset.new(nil).from(:categories).with(:a, Sequel::Dataset.new(nil).from(:b)), [:id]).sql.should == 'WITH "a" AS (SELECT * FROM b) SELECT * FROM "items" INNER JOIN (SELECT * FROM categories) AS "t1" USING ("id")'
+  end
+
   specify "should raise an error if using an array of symbols with a block" do
     proc{@d.join(:categories, [:id]){|j,lj,js|}}.should raise_error(Sequel::Error)
   end
@@ -2155,7 +2306,6 @@ describe "Dataset#join_table" do
       'SELECT * FROM "items" AS "i" INNER JOIN "categories" AS "c2" ON ("c2"."category_id" = "i2"."id")'
   end
   
-  
   specify "should not allow insert, update, delete, or truncate" do
     proc{@d.join(:categories, :a=>:d).insert_sql}.should raise_error(Sequel::InvalidOperation)
     proc{@d.join(:categories, :a=>:d).update_sql(:a=>1)}.should raise_error(Sequel::InvalidOperation)
@@ -3283,6 +3433,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 +3442,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 +3458,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 +3755,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
@@ -3633,6 +3859,15 @@ describe "Sequel::Dataset #with and #with_recursive" do
     proc{@ds.with(:t, @db[:x], :args=>[:b])}.should raise_error(Sequel::Error)
     proc{@ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c])}.should raise_error(Sequel::Error)
   end
+
+  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"]}
+    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'
+    @ds.with(:t, @db[:x]).delete_sql.should == 'WITH t AS (SELECT * FROM x) DELETE FROM t'
+  end
 end
 
 describe Sequel::SQL::Constants do
@@ -3860,6 +4095,14 @@ describe "Sequel::Dataset#select_map" do
     @ds.select_map{a(t__c)}.should == [1, 2]
     @ds.db.sqls.should == ['SELECT a(t.c) FROM t']
   end
+
+  specify "should handle an array of columns" do
+    @ds.select_map([:c, :c]).should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, c FROM t']
+    @ds.db.reset
+    @ds.select_order_map([:d.as(:c), :c.qualify(:b), :c.identifier, :c.identifier.qualify(:b), :a__c, :a__d___c]).should == [[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2]]
+    @ds.db.sqls.should == ['SELECT d AS c, b.c, c, b.c, a.c, a.d AS c FROM t ORDER BY d, b.c, c, b.c, a.c, a.d']
+  end
 end
 
 describe "Sequel::Dataset#select_order_map" do
@@ -3898,10 +4141,23 @@ describe "Sequel::Dataset#select_order_map" do
     @ds.db.sqls.should == ['SELECT a AS b FROM t ORDER BY a']
   end
   
+  specify "should handle OrderedExpressions" do
+    @ds.select_order_map(:a.desc).should == [1, 2]
+    @ds.db.sqls.should == ['SELECT a FROM t ORDER BY a DESC']
+  end
+  
   specify "should accept a block" do
     @ds.select_order_map{a(t__c)}.should == [1, 2]
     @ds.db.sqls.should == ['SELECT a(t.c) FROM t ORDER BY a(t.c)']
   end
+
+  specify "should handle an array of columns" do
+    @ds.select_order_map([:c, :c]).should == [[1, 1], [2, 2]]
+    @ds.db.sqls.should == ['SELECT c, c FROM t ORDER BY c, c']
+    @ds.db.reset
+    @ds.select_order_map([:d.as(:c), :c.qualify(:b), :c.identifier, :c.identifier.qualify(:b), :c.identifier.qualify(:b).desc, :a__c, :a__d___c.desc]).should == [[1, 1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2, 2]]
+    @ds.db.sqls.should == ['SELECT d AS c, b.c, c, b.c, b.c, a.c, a.d AS c FROM t ORDER BY d, b.c, c, b.c, b.c DESC, a.c, a.d DESC']
+  end
 end
 
 describe "Sequel::Dataset#select_hash" do
@@ -3917,7 +4173,7 @@ describe "Sequel::Dataset#select_hash" do
     @ds.db.reset
   end
 
-  specify "should do select and map in one step" do
+  specify "should do select and to_hash in one step" do
     @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
     @ds.select_hash(:a, :b).should == {1=>2, 3=>4}
     @ds.db.sqls.should == ['SELECT a, b FROM t']
@@ -3940,6 +4196,36 @@ describe "Sequel::Dataset#select_hash" do
     @ds.select_hash(:t__c___a, :t__d___b).should == {1=>2, 3=>4}
     @ds.db.sqls.should == ['SELECT t.c AS a, t.d AS b FROM t']
   end
+
+  specify "should handle SQL::Identifiers in arguments" do
+    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds.select_hash(:a.identifier, :b.identifier).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT a, b FROM t']
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers in arguments" do
+    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds.select_hash(:a.qualify(:t), :b.identifier.qualify(:t)).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT t.a, t.b FROM t']
+  end
+
+  specify "should handle SQL::AliasedExpressions in arguments" do
+    @ds.set_fr_yield([{:a=>1, :b=>2}, {:a=>3, :b=>4}])
+    @ds.select_hash(:c.as(:a), :t.as(:b)).should == {1=>2, 3=>4}
+    @ds.db.sqls.should == ['SELECT c AS a, t AS b FROM t']
+  end
+
+  specify "should work with arrays of columns" do
+    @ds.set_fr_yield([{:a=>1, :b=>2, :c=>3}, {:a=>4, :b=>5, :c=>6}])
+    @ds.select_hash([:a, :c], :b).should == {[1, 3]=>2, [4, 6]=>5}
+    @ds.db.sqls.should == ['SELECT a, c, b FROM t']
+    @ds.select_hash(:a, [:b, :c]).should == {1=>[2, 3], 4=>[5, 6]}
+    @ds.select_hash([:a, :b], [:b, :c]).should == {[1, 2]=>[2, 3], [4, 5]=>[5, 6]}
+  end
+
+  specify "should raise an error if the resulting symbol cannot be determined" do
+    proc{@ds.select_hash(:c.as(:a), 'foo')}.should raise_error(Sequel::Error)
+  end
 end
 
 describe "Modifying joined datasets" do
@@ -3977,3 +4263,66 @@ 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
+
+describe "Dataset#returning" do
+  before do
+    @ds = Sequel::Database.new[:t].returning(:foo)
+    @pr = proc do
+      [:insert, :update, :delete].each do |m|
+        @ds.meta_def(:"#{m}_clause_methods"){super() + [:"#{m}_returning_sql"]}
+      end
+    end
+  end
+  
+  specify "should use RETURNING clause in the SQL if the dataset supports it" do
+    @pr.call
+    @ds.delete_sql.should == "DELETE FROM t RETURNING foo"
+    @ds.insert_sql(1).should == "INSERT INTO t VALUES (1) RETURNING foo"
+    @ds.update_sql(:foo=>1).should == "UPDATE t SET foo = 1 RETURNING foo"
+  end
+  
+  specify "should not use RETURNING clause in the SQL if the dataset does not support it" do
+    @ds.delete_sql.should == "DELETE FROM t"
+    @ds.insert_sql(1).should == "INSERT INTO t VALUES (1)"
+    @ds.update_sql(:foo=>1).should == "UPDATE t SET foo = 1"
+  end
+
+  specify "should have insert, update, and delete yield to blocks if RETURNING is used" do
+    @pr.call
+    def @ds.fetch_rows(sql)
+      yield(:foo=>sql)
+    end
+    h = {}
+    @ds.delete{|r| h = r}
+    h.should == {:foo=>"DELETE FROM t RETURNING foo"}
+    @ds.insert(1){|r| h = r}
+    h.should == {:foo=>"INSERT INTO t VALUES (1) RETURNING foo"}
+    @ds.update(:foo=>1){|r| h = r}
+    h.should == {:foo=>"UPDATE t SET foo = 1 RETURNING foo"}
+  end
+
+  specify "should have insert, update, and delete return arrays of hashes if RETURNING is used and a block is not given" do
+    @pr.call
+    def @ds.fetch_rows(sql)
+      yield(:foo=>sql)
+    end
+    h = {}
+    @ds.delete.should == [{:foo=>"DELETE FROM t RETURNING foo"}]
+    @ds.insert(1).should == [{:foo=>"INSERT INTO t VALUES (1) RETURNING foo"}]
+    @ds.update(:foo=>1).should == [{:foo=>"UPDATE t SET foo = 1 RETURNING foo"}]
+  end
+end