sequel 3.35.0 → 3.36.0

data/spec/adapters/sqlite_spec.rb

@@ -13,6 +13,7 @@ describe "An SQLite database" do
   end
   after do
     @db.foreign_keys = @fk
+    @db.case_sensitive_like = true
     Sequel.datetime_class = Time
   end
 
@@ -38,6 +39,16 @@ describe "An SQLite database" do
     end
   end
   
+  specify "should respect case sensitive like false" do
+    @db.case_sensitive_like = false
+    @db.get(Sequel.like('a', 'A')).to_s.should == '1'
+  end
+  
+  specify "should respect case sensitive like true" do
+    @db.case_sensitive_like = true
+    @db.get(Sequel.like('a', 'A')).to_s.should == '0'
+  end
+  
   specify "should provide the SQLite version as an integer" do
     @db.sqlite_version.should be_a_kind_of(Integer)
   end

data/spec/core/connection_pool_spec.rb

@@ -187,7 +187,7 @@ describe "A connection pool with a max size of 1" do
     q.push nil
     q1.pop
 
-    t1.should_not be_alive
+    t1.join
     t2.should be_alive
     
     c2.should == 'hello'
@@ -340,6 +340,31 @@ shared_examples_for "A threaded connection pool" do
     @pool.available_connections.size.should == 5
     @pool.allocated.should be_empty
   end
+
+  specify "should store connections in a stack by default" do
+    c2 = nil
+    c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
+    @pool.size.should == 2
+    @pool.hold{|cc| cc.should == c}
+    @pool.hold{|cc| cc.should == c}
+    @pool.hold do |cc|
+      cc.should == c
+      Thread.new{@pool.hold{|cc2| cc2.should == c2}}
+    end
+  end
+
+  specify "should store connections in a queue if :connection_handling=>:queue" do
+    @pool = Sequel::ConnectionPool.get_pool(@cp_opts.merge(:connection_handling=>:queue)){@invoked_count += 1}
+    c2 = nil
+    c = @pool.hold{|cc| Thread.new{@pool.hold{|cc2| c2 = cc2}}.join; cc}
+    @pool.size.should == 2
+    @pool.hold{|cc| cc.should == c2}
+    @pool.hold{|cc| cc.should == c}
+    @pool.hold do |cc|
+      cc.should == c2
+      Thread.new{@pool.hold{|cc2| cc2.should == c}}
+    end
+  end
 end
 
 describe "Threaded Unsharded Connection Pool" do

data/spec/core/database_spec.rb

@@ -1996,12 +1996,31 @@ describe "Database#supports_transactional_ddl?" do
   end
 end
 
+describe "Database#global_index_namespace?" do
+  specify "should be true by default" do
+    Sequel::Database.new.global_index_namespace?.should == true
+  end
+end
+
 describe "Database#supports_savepoints?" do
   specify "should be false by default" do
     Sequel::Database.new.supports_savepoints?.should == false
   end
 end
 
+describe "Database#supports_savepoints_in_prepared_transactions?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_savepoints_in_prepared_transactions?.should == false
+  end
+
+  specify "should be true if both savepoints and prepared transactions are supported" do
+    db = Sequel::Database.new
+    db.meta_def(:supports_savepoints?){true}
+    db.meta_def(:supports_prepared_transactions?){true}
+    db.supports_savepoints_in_prepared_transactions?.should == true
+  end
+end
+
 describe "Database#supports_prepared_transactions?" do
   specify "should be false by default" do
     Sequel::Database.new.supports_prepared_transactions?.should == false

data/spec/core/dataset_spec.rb

@@ -1199,6 +1199,17 @@ describe "Dataset#from" do
     @dataset.from(@dataset.from(:a)).select_sql.should == "SELECT * FROM (SELECT * FROM a) AS t1"
   end
   
+  specify "should treat string arguments as identifiers" do
+    @dataset.quote_identifiers = true
+    @dataset.from('a').select_sql.should == "SELECT * FROM \"a\""
+  end
+  
+  specify "should not treat literal strings or blobs as identifiers" do
+    @dataset.quote_identifiers = true
+    @dataset.from('a'.lit).select_sql.should == "SELECT * FROM a"
+    @dataset.from('a'.to_sequel_blob).select_sql.should == "SELECT * FROM 'a'"
+  end
+  
   specify "should remove all FROM tables if called with no arguments" do
     @dataset.from.sql.should == 'SELECT *'
   end
@@ -1262,6 +1273,10 @@ describe "Dataset#select" do
     @d.select.sql.should == 'SELECT * FROM test'
   end
   
+  specify "should handle array condition specifiers that are aliased" do
+    @d.select(Sequel.as([[:b, :c]], :n)).sql.should == 'SELECT (b = c) AS n FROM test'
+  end
+
   specify "should accept a hash for AS values" do
     @d.select(:name => 'n', :__ggh => 'age').sql.should =~ /SELECT ((name AS n, __ggh AS age)|(__ggh AS age, name AS n)) FROM test/
   end
@@ -2647,6 +2662,11 @@ describe "Dataset#get" do
   specify "should raise an error if both a regular argument and block argument are used" do
     proc{@d.get(:name){|o| o.x__b.as(:name)}}.should raise_error(Sequel::Error)
   end
+  
+  specify "should support false and nil values" do
+    @d.get(false).should == "SELECT 'f' FROM test LIMIT 1"
+    @d.get(nil).should == "SELECT NULL FROM test LIMIT 1"
+  end
 end
 
 describe "Dataset#set_row_proc" do
@@ -3238,6 +3258,7 @@ describe "Dataset prepared statements and bound variables " do
   end
   
   specify "#call should take a type and bind hash and interpolate it" do
+    @ds.filter(:num=>:$n).call(:each, :n=>1)
     @ds.filter(:num=>:$n).call(:select, :n=>1)
     @ds.filter(:num=>:$n).call([:map, :a], :n=>1)
     @ds.filter(:num=>:$n).call([:to_hash, :a, :b], :n=>1)
@@ -3247,7 +3268,9 @@ describe "Dataset prepared statements and bound variables " do
     @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)',
+    @db.sqls.should == [
+      'SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
@@ -3260,6 +3283,7 @@ describe "Dataset prepared statements and bound variables " do
     
   specify "#prepare should take a type and name and store it in the database for later use with call" do
     pss = []
+    pss << @ds.filter(:num=>:$n).prepare(:each, :en)
     pss << @ds.filter(:num=>:$n).prepare(:select, :sn)
     pss << @ds.filter(:num=>:$n).prepare([:map, :a], :sm)
     pss << @ds.filter(:num=>:$n).prepare([:to_hash, :a, :b], :sh)
@@ -3269,8 +3293,9 @@ describe "Dataset prepared statements and bound variables " do
     pss << @ds.filter(:num=>:$n).prepare(:update, :un, :num=>:$n2)
     pss << @ds.prepare(:insert, :in, :num=>:$n)
     pss << @ds.prepare(:insert_select, :ins, :num=>:$n)
-    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :ins, :sh, :shg, :sm, :sn, :un]
-    [:sn, :sm, :sh, :shg, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
+    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :en, :fn, :in, :ins, :sh, :shg, :sm, :sn, :un]
+    [:en, :sn, :sm, :sh, :shg, :fn, :dn, :un, :in, :ins].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
+    @db.call(:en, :n=>1){}
     @db.call(:sn, :n=>1)
     @db.call(:sm, :n=>1)
     @db.call(:sh, :n=>1)
@@ -3280,7 +3305,9 @@ describe "Dataset prepared statements and bound variables " do
     @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)',
+    @db.sqls.should == [
+      'SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
       'SELECT * FROM items WHERE (num = 1)',
@@ -3291,6 +3318,11 @@ describe "Dataset prepared statements and bound variables " do
       'INSERT INTO items (num) VALUES (1) RETURNING *']
   end
     
+  specify "#call should default to using :all if an invalid type is given" do
+    @ds.filter(:num=>:$n).call(:select_all, :n=>1)
+    @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)']
+  end
+
   specify "#inspect should indicate it is a prepared statement with the prepared SQL" do
     @ds.filter(:num=>:$n).prepare(:select, :sn).inspect.should == \
       '<Sequel::Mock::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = $n)">'
@@ -3361,7 +3393,7 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
     @ps.first.inspect.should == '<Sequel::Mock::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = ?)">'
   end
   
-  specify "should submitted the SQL to the database with placeholders and bind variables" do
+  specify "should submit the SQL to the database with placeholders and bind variables" do
     @ps.each{|p| p.prepared_sql; p.call(:n=>1)}
     @db.sqls.should == ["SELECT * FROM items WHERE (num = ?) -- args: [1]",
       "SELECT * FROM items WHERE (num = ?) -- args: [1]",
@@ -3370,6 +3402,14 @@ describe Sequel::Dataset::UnnumberedArgumentMapper do
       "INSERT INTO items (num) VALUES (?) -- args: [1]",
       "UPDATE items SET num = ? WHERE (num = ?) -- args: [1, 1]"]
   end
+
+  specify "should handle unrecognized statement types as :all" do
+    ps = @ds.prepare(:select_all, :s)
+    ps.extend(Sequel::Dataset::UnnumberedArgumentMapper)
+    ps.prepared_sql
+    ps.call(:n=>1)
+    @db.sqls.should == ["SELECT * FROM items WHERE (num = ?) -- args: [1]"]
+  end
 end
 
 describe "Sequel::Dataset#server" do

data/spec/core/expression_filters_spec.rb

@@ -212,8 +212,6 @@ describe "Blockless Ruby Filters" do
     @d.l(:x.sql_boolean & :y).should == '(x AND y)'
     @d.l(:x & :y & :z).should == '(x AND y AND z)'
     @d.l(:x & {:y => :z}).should == '(x AND (y = z))'
-    @d.l({:y => :z} & :x).should == '((y = z) AND x)'
-    @d.l({:x => :a} & {:y => :z}).should == '((x = a) AND (y = z))'
     @d.l((:x + 200 < 0) & (:y - 200 < 0)).should == '(((x + 200) < 0) AND ((y - 200) < 0))'
     @d.l(:x & ~:y).should == '(x AND NOT y)'
     @d.l(~:x & :y).should == '(NOT x AND y)'
@@ -225,8 +223,6 @@ describe "Blockless Ruby Filters" do
     @d.l(:x.sql_boolean | :y).should == '(x OR y)'
     @d.l(:x | :y | :z).should == '(x OR y OR z)'
     @d.l(:x | {:y => :z}).should == '(x OR (y = z))'
-    @d.l({:y => :z} | :x).should == '((y = z) OR x)'
-    @d.l({:x => :a} | {:y => :z}).should == '((x = a) OR (y = z))'
     @d.l((:x.sql_number > 200) | (:y.sql_number < 200)).should == '((x > 200) OR (y < 200))'
   end
   
@@ -267,60 +263,12 @@ describe "Blockless Ruby Filters" do
     @d.l(:x => nil, :y => [1,2,3])[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
   end
   
-  it "should support sql_expr on hashes" do
-    @d.l({:x => 100, :y => 'a'}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x = 100)', '(y = \'a\')']
-    @d.l({:x => true, :y => false}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
-    @d.l({:x => nil, :y => [1,2,3]}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
-  end
-  
-  it "should support sql_negate on hashes" do
-    @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != 100)', '(y != \'a\')']
-    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
-    @d.l({:x => nil, :y => [1,2,3]}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
-  end
-  
-  it "should support ~ on hashes" do
-    @d.l(~{:x => 100, :y => 'a'})[1...-1].split(' OR ').sort.should == ['(x != 100)', '(y != \'a\')']
-    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
-    @d.l(~{:x => nil, :y => [1,2,3]})[1...-1].split(' OR ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
-  end
-  
-  it "should support sql_or on hashes" do
-    @d.l({:x => 100, :y => 'a'}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = 100)', '(y = \'a\')']
-    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
-    @d.l({:x => nil, :y => [1,2,3]}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
-  end
-  
   it "should support arrays with all two pairs the same as hashes" do
     @d.l([[:x, 100],[:y, 'a']]).should == '((x = 100) AND (y = \'a\'))'
     @d.l([[:x, true], [:y, false]]).should == '((x IS TRUE) AND (y IS FALSE))'
     @d.l([[:x, nil], [:y, [1,2,3]]]).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
   end
   
-  it "should support sql_expr on arrays with all two pairs" do
-    @d.l([[:x, 100],[:y, 'a']].sql_expr).should == '((x = 100) AND (y = \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_expr).should == '((x IS TRUE) AND (y IS FALSE))'
-    @d.l([[:x, nil], [:y, [1,2,3]]].sql_expr).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
-  end
-  
-  it "should support sql_negate on arrays with all two pairs" do
-    @d.l([[:x, 100],[:y, 'a']].sql_negate).should == '((x != 100) AND (y != \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_negate).should == '((x IS NOT TRUE) AND (y IS NOT FALSE))'
-    @d.l([[:x, nil], [:y, [1,2,3]]].sql_negate).should == '((x IS NOT NULL) AND (y NOT IN (1, 2, 3)))'
-  end
-  
-  it "should support ~ on arrays with all two pairs" do
-    @d.l(~[[:x, 100],[:y, 'a']]).should == '((x != 100) OR (y != \'a\'))'
-    @d.l(~[[:x, true], [:y, false]]).should == '((x IS NOT TRUE) OR (y IS NOT FALSE))'
-    @d.l(~[[:x, nil], [:y, [1,2,3]]]).should == '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
-  end
-  
-  it "should support sql_or on arrays with all two pairs" do
-    @d.l([[:x, 100],[:y, 'a']].sql_or).should == '((x = 100) OR (y = \'a\'))'
-    @d.l([[:x, true], [:y, false]].sql_or).should == '((x IS TRUE) OR (y IS FALSE))'
-    @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).should == '((x IS NULL) OR (y IN (1, 2, 3)))'
-  end
-  
   it "should emulate columns for array values" do
     @d.l([:x, :y]=>[[1,2], [3,4]].sql_array).should == '((x, y) IN ((1, 2), (3, 4)))'
     @d.l([:x, :y, :z]=>[[1,2,5], [3,4,6]]).should == '((x, y, z) IN ((1, 2, 5), (3, 4, 6)))'
@@ -332,21 +280,6 @@ describe "Blockless Ruby Filters" do
     @d.l([:x, :y, :z]=>[[1,2,5], [3,4,6]]).should == '(((x = 1) AND (y = 2) AND (z = 5)) OR ((x = 3) AND (y = 4) AND (z = 6)))'
   end
   
-  it "should support Array#sql_string_join for concatenation of SQL strings" do
-    @d.lit([:x].sql_string_join).should == '(x)'
-    @d.lit([:x].sql_string_join(', ')).should == '(x)'
-    @d.lit([:x, :y].sql_string_join).should == '(x || y)'
-    @d.lit([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
-    @d.lit([:x.sql_function(1), :y.sql_subscript(1)].sql_string_join).should == '(x(1) || y[1])'
-    @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
-    @d.lit([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
-    @d.lit([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"
-    @d.lit([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
-    @d.lit([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
-    @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
-    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "(x || y || a || b)"
-  end
-
   it "should support StringExpression#+ for concatenation of SQL strings" do
     @d.lit(:x.sql_string + :y).should == '(x || y)'
     @d.lit([:x].sql_string_join + :y).should == '(x || y)'
@@ -762,6 +695,11 @@ describe "Sequel core extension replacements" do
     l(Sequel.expr([[:a, 1], [:b, 2]]) & nil, "((a = 1) AND (b = 2) AND NULL)")
   end
 
+  it "Sequel.expr should handle arrays that are not condition specifiers" do
+    l(Sequel.expr([1]), "(1)")
+    l(Sequel.expr([1, 2]), "(1, 2)")
+  end
+
   it "Sequel.expr should treat blocks/procs as virtual rows and wrap the output" do
     l(Sequel.expr{1} + 1, "(1 + 1)")
     l(Sequel.expr{o__a} + 1, "(o.a + 1)")
@@ -1078,3 +1016,29 @@ describe "Sequel::SQL::Wrapper" do
     @ds.literal(s.sql_string + '1').should == "(foo || '1')"
   end
 end
+
+describe "Sequel::SQL::Blob#to_sequel_blob" do
+  specify "should return self" do
+    c = Sequel::SQL::Blob.new('a')
+    c.to_sequel_blob.should equal(c)
+  end
+end
+
+describe Sequel::SQL::Subscript do
+  before do
+    @s = Sequel::SQL::Subscript.new(:a, [1])
+    @ds = Sequel::Dataset.new(nil)
+  end
+
+  specify "should have | return a new non-nested subscript" do
+    s = (@s | 2)
+    s.should_not equal(@s)
+    @ds.literal(s).should == 'a[1, 2]'
+  end
+
+  specify "should have [] return a new nested subscript" do
+    s = @s[2]
+    s.should_not equal(@s)
+    @ds.literal(s).should == 'a[1][2]'
+  end
+end

data/spec/core/mock_adapter_spec.rb

@@ -442,4 +442,8 @@ describe "Sequel Mock Adapter" do
   specify "should automatically set version for postgres" do
     Sequel.mock(:host=>'postgres').server_version.should == 90103
   end
+
+  specify "should stub out the primary_key method for postgres" do
+    Sequel.mock(:host=>'postgres').primary_key(:t).should == :id
+  end
 end

data/spec/extensions/core_extensions_spec.rb

@@ -18,6 +18,89 @@ describe "Sequel core extensions" do
   end
 end
 
+describe "Array and Hash extensions" do
+  before do
+    db = Sequel::Database.new
+    @d = db[:items]
+    def @d.l(*args, &block)
+      literal(filter_expr(*args, &block))
+    end
+    def @d.lit(*args)
+      literal(*args)
+    end
+  end
+  
+  it "should support sql_expr on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_expr).should == '((x = 100) AND (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_expr).should == '((x IS TRUE) AND (y IS FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_expr).should == '((x IS NULL) AND (y IN (1, 2, 3)))'
+  end
+  
+  it "should support sql_negate on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_negate).should == '((x != 100) AND (y != \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_negate).should == '((x IS NOT TRUE) AND (y IS NOT FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_negate).should == '((x IS NOT NULL) AND (y NOT IN (1, 2, 3)))'
+  end
+  
+  it "should support ~ on arrays with all two pairs" do
+    @d.l(~[[:x, 100],[:y, 'a']]).should == '((x != 100) OR (y != \'a\'))'
+    @d.l(~[[:x, true], [:y, false]]).should == '((x IS NOT TRUE) OR (y IS NOT FALSE))'
+    @d.l(~[[:x, nil], [:y, [1,2,3]]]).should == '((x IS NOT NULL) OR (y NOT IN (1, 2, 3)))'
+  end
+  
+  it "should support sql_or on arrays with all two pairs" do
+    @d.l([[:x, 100],[:y, 'a']].sql_or).should == '((x = 100) OR (y = \'a\'))'
+    @d.l([[:x, true], [:y, false]].sql_or).should == '((x IS TRUE) OR (y IS FALSE))'
+    @d.l([[:x, nil], [:y, [1,2,3]]].sql_or).should == '((x IS NULL) OR (y IN (1, 2, 3)))'
+  end
+  
+  it "should support Array#sql_string_join for concatenation of SQL strings" do
+    @d.lit([:x].sql_string_join).should == '(x)'
+    @d.lit([:x].sql_string_join(', ')).should == '(x)'
+    @d.lit([:x, :y].sql_string_join).should == '(x || y)'
+    @d.lit([:x, :y].sql_string_join(', ')).should == "(x || ', ' || y)"
+    @d.lit([:x.sql_function(1), :y.sql_subscript(1)].sql_string_join).should == '(x(1) || y[1])'
+    @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
+    @d.lit([:x, 1, :y].sql_string_join).should == "(x || '1' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(', ')).should == "(x || ', ' || '1' || ', ' || y)"
+    @d.lit([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
+    @d.lit([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
+    @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
+    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "(x || y || a || b)"
+  end
+
+  it "should support sql_expr on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_expr)[1...-1].split(' AND ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+  end
+  
+  it "should support sql_negate on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x != 100)', '(y != \'a\')']
+    @d.l({:x => true, :y => false}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_negate)[1...-1].split(' AND ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+  end
+  
+  it "should support ~ on hashes" do
+    @d.l(~{:x => 100, :y => 'a'})[1...-1].split(' OR ').sort.should == ['(x != 100)', '(y != \'a\')']
+    @d.l(~{:x => true, :y => false})[1...-1].split(' OR ').sort.should == ['(x IS NOT TRUE)', '(y IS NOT FALSE)']
+    @d.l(~{:x => nil, :y => [1,2,3]})[1...-1].split(' OR ').sort.should == ['(x IS NOT NULL)', '(y NOT IN (1, 2, 3))']
+  end
+  
+  it "should support sql_or on hashes" do
+    @d.l({:x => 100, :y => 'a'}.sql_or)[1...-1].split(' OR ').sort.should == ['(x = 100)', '(y = \'a\')']
+    @d.l({:x => true, :y => false}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS TRUE)', '(y IS FALSE)']
+    @d.l({:x => nil, :y => [1,2,3]}.sql_or)[1...-1].split(' OR ').sort.should == ['(x IS NULL)', '(y IN (1, 2, 3))']
+  end
+  
+  it "should Hash#& and Hash#|" do
+    @d.l({:y => :z} & :x).should == '((y = z) AND x)'
+    @d.l({:x => :a} & {:y => :z}).should == '((x = a) AND (y = z))'
+    @d.l({:y => :z} | :x).should == '((y = z) OR x)'
+    @d.l({:x => :a} | {:y => :z}).should == '((x = a) OR (y = z))'
+  end
+end
+
 describe "Array#case and Hash#case" do
   before do
     @d = Sequel::Dataset.new(nil)