sequel 2.9.0 → 2.10.0

data/spec/sequel_core/dataset_spec.rb

@@ -39,6 +39,66 @@ context "Dataset" do
   specify "should include Enumerable" do
     Sequel::Dataset.included_modules.should include(Enumerable)
   end
+  
+  specify "should get quote_identifiers default from database" do
+    db = Sequel::Database.new(:quote_identifiers=>true)
+    db[:a].quote_identifiers?.should == true
+    db = Sequel::Database.new(:quote_identifiers=>false)
+    db[:a].quote_identifiers?.should == false
+  end
+
+  specify "should get identifier_input_method default from database" do
+    db = Sequel::Database.new(:identifier_input_method=>:upcase)
+    db[:a].identifier_input_method.should == :upcase
+    db = Sequel::Database.new(:identifier_input_method=>:downcase)
+    db[:a].identifier_input_method.should == :downcase
+  end
+
+  specify "should get identifier_output_method default from database" do
+    db = Sequel::Database.new(:identifier_output_method=>:upcase)
+    db[:a].identifier_output_method.should == :upcase
+    db = Sequel::Database.new(:identifier_output_method=>:downcase)
+    db[:a].identifier_output_method.should == :downcase
+  end
+end
+
+context "Dataset" do
+  setup do
+    @dataset = Sequel::Dataset.new("db")
+  end
+  
+  specify "should have quote_identifiers= method which changes literalization of identifiers" do
+    @dataset.quote_identifiers = true
+    @dataset.literal(:a).should == '"a"'
+    @dataset.quote_identifiers = false
+    @dataset.literal(:a).should == 'a'
+  end
+  
+  specify "should have upcase_identifiers= method which changes literalization of identifiers" do
+    @dataset.upcase_identifiers = true
+    @dataset.literal(:a).should == 'A'
+    @dataset.upcase_identifiers = false
+    @dataset.literal(:a).should == 'a'
+  end
+
+  specify "should have identifier_input_method= method which changes literalization of identifiers" do
+    @dataset.identifier_input_method = :upcase
+    @dataset.literal(:a).should == 'A'
+    @dataset.identifier_input_method = :downcase
+    @dataset.literal(:A).should == 'a'
+    @dataset.identifier_input_method = :reverse
+    @dataset.literal(:at_b).should == 'b_ta'
+  end
+  
+  specify "should have identifier_output_method= method which changes identifiers returned from the database" do
+    @dataset.send(:output_identifier, "at_b_C").should == :at_b_C
+    @dataset.identifier_output_method = :upcase
+    @dataset.send(:output_identifier, "at_b_C").should == :AT_B_C
+    @dataset.identifier_output_method = :downcase
+    @dataset.send(:output_identifier, "at_b_C").should == :at_b_c
+    @dataset.identifier_output_method = :reverse
+    @dataset.send(:output_identifier, "at_b_C").should == :C_b_ta
+  end
 end
 
 context "Dataset#clone" do
@@ -194,8 +254,8 @@ end
 context "Dataset#exists" do
   setup do
     @ds1 = Sequel::Dataset.new(nil).from(:test)
-    @ds2 = @ds1.filter(:price < 100)
-    @ds3 = @ds1.filter(:price > 50)
+    @ds2 = @ds1.filter(:price.sql_number < 100)
+    @ds3 = @ds1.filter(:price.sql_number > 50)
   end
   
   specify "should work in filters" do
@@ -290,7 +350,7 @@ context "Dataset#where" do
   end
       
   specify "should be composable using AND operator (for scoping) with block" do
-    @d3.where{:e < 5}.select_sql.should ==
+    @d3.where{:e.sql_number < 5}.select_sql.should ==
       "SELECT * FROM test WHERE ((a = 1) AND (e < 5))"
   end
   
@@ -318,7 +378,7 @@ context "Dataset#where" do
   end
 
   specify "should accept a subquery" do
-    @dataset.filter('gdp > ?', @d1.select(:avg[:gdp])).sql.should ==
+    @dataset.filter('gdp > ?', @d1.select(:avg.sql_function(:gdp))).sql.should ==
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
 
     @dataset.filter(:id => @d1.select(:id)).sql.should ==
@@ -326,20 +386,20 @@ context "Dataset#where" do
   end
   
   specify "should accept a subquery for an EXISTS clause" do
-    a = @dataset.filter(:price < 100)
+    a = @dataset.filter(:price.sql_number < 100)
     @dataset.filter(a.exists).sql.should ==
       'SELECT * FROM test WHERE (EXISTS (SELECT * FROM test WHERE (price < 100)))'
   end
   
   specify "should accept proc expressions" do
-    d = @d1.select(:avg[:gdp])
-    @dataset.filter {:gdp > d}.sql.should ==
+    d = @d1.select(:avg.sql_function(:gdp))
+    @dataset.filter {:gdp.sql_number > d}.sql.should ==
       "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
     
-    @dataset.filter {:a < 1}.sql.should ==
+    @dataset.filter {:a.sql_number < 1}.sql.should ==
       'SELECT * FROM test WHERE (a < 1)'
 
-    @dataset.filter {(:a >= 1) & (:b <= 2)}.sql.should ==
+    @dataset.filter {(:a.sql_number >= 1) & (:b.sql_number <= 2)}.sql.should ==
       'SELECT * FROM test WHERE ((a >= 1) AND (b <= 2))'
       
     @dataset.filter {:c.like 'ABC%'}.sql.should ==
@@ -365,7 +425,7 @@ context "Dataset#where" do
   end
 
   specify "should allow the use of blocks and arguments simultaneously" do
-    @dataset.filter(:zz < 3){:yy > 3}.sql.should ==
+    @dataset.filter(:zz.sql_number < 3){:yy.sql_number > 3}.sql.should ==
       'SELECT * FROM test WHERE ((zz < 3) AND (yy > 3))'
   end
 
@@ -405,12 +465,12 @@ context "Dataset#or" do
   specify "should accept all forms of filters" do
     @d1.or('y > ?', 2).sql.should ==
       'SELECT * FROM test WHERE ((x = 1) OR (y > 2))'
-    @d1.or(:yy > 3).sql.should ==
+    @d1.or(:yy.sql_number > 3).sql.should ==
       'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
   end    
 
   specify "should accept blocks passed to filter" do
-    @d1.or{:yy > 3}.sql.should ==
+    @d1.or{:yy.sql_number > 3}.sql.should ==
       'SELECT * FROM test WHERE ((x = 1) OR (yy > 3))'
   end
   
@@ -423,7 +483,7 @@ context "Dataset#or" do
   end
 
   specify "should allow the use of blocks and arguments simultaneously" do
-    @d1.or(:zz < 3){:yy > 3}.sql.should ==
+    @d1.or(:zz.sql_number < 3){:yy.sql_number > 3}.sql.should ==
       'SELECT * FROM test WHERE ((x = 1) OR ((zz < 3) AND (yy > 3)))'
   end
 end
@@ -450,12 +510,12 @@ context "Dataset#and" do
     # probably not exhaustive, but good enough
     @d1.and('y > ?', 2).sql.should ==
       'SELECT * FROM test WHERE ((x = 1) AND (y > 2))'
-    @d1.and(:yy > 3).sql.should ==
+    @d1.and(:yy.sql_number > 3).sql.should ==
       'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
       
   specify "should accept blocks passed to filter" do
-    @d1.and {:yy > 3}.sql.should ==
+    @d1.and {:yy.sql_number > 3}.sql.should ==
       'SELECT * FROM test WHERE ((x = 1) AND (yy > 3))'
   end
   
@@ -500,12 +560,12 @@ context "Dataset#exclude" do
   end
   
   specify "should support proc expressions" do
-    @dataset.exclude{:id < 6}.sql.should == 
+    @dataset.exclude{:id.sql_number < 6}.sql.should == 
       'SELECT * FROM test WHERE (id >= 6)'
   end
   
   specify "should allow the use of blocks and arguments simultaneously" do
-    @dataset.exclude(:id => (7..11)){:id < 6}.sql.should == 
+    @dataset.exclude(:id => (7..11)){:id.sql_number < 6}.sql.should == 
       'SELECT * FROM test WHERE (((id < 7) OR (id > 11)) OR (id >= 6))'
   end
 end
@@ -531,7 +591,7 @@ end
 context "Dataset#having" do
   setup do
     @dataset = Sequel::Dataset.new(nil).from(:test)
-    @grouped = @dataset.group(:region).select(:region, :sum[:population], :avg[:gdp])
+    @grouped = @dataset.group(:region).select(:region, :sum.sql_function(:population), :avg.sql_function(:gdp))
     @d1 = @grouped.having('sum(population) > 10')
     @d2 = @grouped.having(:region => 'Asia')
     @columns = "region, sum(population), avg(gdp)"
@@ -547,12 +607,12 @@ context "Dataset#having" do
   end
 
   specify "should support proc expressions" do
-    @grouped.having {:sum[:population] > 10}.sql.should == 
+    @grouped.having {:sum.sql_function(:population) > 10}.sql.should == 
       "SELECT #{@columns} FROM test GROUP BY region HAVING (sum(population) > 10)"
   end
 
   specify "should work with and on the having clause" do
-    @grouped.having( :a > 1 ).and( :b < 2 ).sql.should ==
+    @grouped.having( :a.sql_number > 1 ).and( :b.sql_number < 2 ).sql.should ==
       "SELECT #{@columns} FROM test GROUP BY region HAVING ((a > 1) AND (b < 2))"
   end
 end
@@ -742,10 +802,10 @@ context "Dataset#from" do
   end
   
   specify "should accept sql functions" do
-    @dataset.from(:abc[:def]).select_sql.should ==
+    @dataset.from(:abc.sql_function(:def)).select_sql.should ==
       "SELECT * FROM abc(def)"
     
-    @dataset.from(:a[:i]).select_sql.should ==
+    @dataset.from(:a.sql_function(:i)).select_sql.should ==
       "SELECT * FROM a(i)"
   end
 
@@ -803,7 +863,7 @@ context "Dataset#select" do
   specify "should accept arbitrary objects and literalize them correctly" do
     @d.select(1, :a, 't').sql.should == "SELECT 1, a, 't' FROM test"
 
-    @d.select(nil, :sum[:t], :x___y).sql.should == "SELECT NULL, sum(t), x AS y FROM test"
+    @d.select(nil, :sum.sql_function(:t), :x___y).sql.should == "SELECT NULL, sum(t), x AS y FROM test"
 
     @d.select(nil, 1, :x => :y).sql.should == "SELECT NULL, 1, x AS y FROM test"
   end
@@ -1161,7 +1221,7 @@ context "Dataset#count" do
   end
   
   specify "should include the where clause if it's there" do
-    @dataset.filter(:abc < 30).count.should == 1
+    @dataset.filter(:abc.sql_number < 30).count.should == 1
     @c.sql.should == 'SELECT COUNT(*) FROM test WHERE (abc < 30) LIMIT 1'
   end
   
@@ -1268,7 +1328,7 @@ context "Dataset#join_table" do
   end
   
   specify "should include WHERE clause if applicable" do
-    @d.filter(:price < 100).join_table(:right_outer, :categories, :category_id => :id).sql.should ==
+    @d.filter(:price.sql_number < 100).join_table(:right_outer, :categories, :category_id => :id).sql.should ==
       'SELECT * FROM "items" RIGHT OUTER JOIN "categories" ON ("categories"."category_id" = "items"."id") WHERE ("price" < 100)'
   end
   
@@ -1428,7 +1488,7 @@ context "Dataset#join_table" do
   end
 
   specify "should support using an expression as the join condition" do
-    @d.join(:categories, :number > 10).sql.should ==
+    @d.join(:categories, :number.sql_number > 10).sql.should ==
       'SELECT * FROM "items" INNER JOIN "categories" ON ("number" > 10)'
   end
 
@@ -1634,7 +1694,7 @@ context "Dataset#range" do
     @d.range(:stamp)
     @d.last_sql.should == "SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test LIMIT 1"
 
-    @d.filter(:price > 100).range(:stamp)
+    @d.filter(:price.sql_number > 100).range(:stamp)
     @d.last_sql.should == "SELECT min(stamp) AS v1, max(stamp) AS v2 FROM test WHERE (price > 100) LIMIT 1"
   end
   
@@ -1662,7 +1722,7 @@ context "Dataset#interval" do
     @d.interval(:stamp)
     @d.last_sql.should == "SELECT (max(stamp) - min(stamp)) FROM test LIMIT 1"
 
-    @d.filter(:price > 100).interval(:stamp)
+    @d.filter(:price.sql_number > 100).interval(:stamp)
     @d.last_sql.should == "SELECT (max(stamp) - min(stamp)) FROM test WHERE (price > 100) LIMIT 1"
   end
   
@@ -1703,20 +1763,20 @@ context "Dataset #first and #last" do
   end
   
   specify "should return the first matching record if a block is given without an argument" do
-    @d.first{:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) LIMIT 1']
-    @d.order(:name).last{:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) ORDER BY name DESC LIMIT 1']
+    @d.first{:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) LIMIT 1']
+    @d.order(:name).last{:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE (z > 26) ORDER BY name DESC LIMIT 1']
   end
   
   specify "should combine block and standard argument filters if argument is not an Integer" do
-    @d.first(:y=>25){:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1']
-    @d.order(:name).last('y = ?', 16){:z > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 16)) ORDER BY name DESC LIMIT 1']
+    @d.first(:y=>25){:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 25)) LIMIT 1']
+    @d.order(:name).last('y = ?', 16){:z.sql_number > 26}.should == [:a,1,:b,2, 'SELECT * FROM test WHERE ((z > 26) AND (y = 16)) ORDER BY name DESC LIMIT 1']
   end
   
   specify "should filter and return an array of records if an Integer argument is provided and a block is given" do
     i = rand(10) + 10
-    r = @d.order(:a).first(i){:z > 26}.should == [[:a,1,:b,2, "SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"]] * i
+    r = @d.order(:a).first(i){:z.sql_number > 26}.should == [[:a,1,:b,2, "SELECT * FROM test WHERE (z > 26) ORDER BY a LIMIT #{i}"]] * i
     i = rand(10) + 10
-    r = @d.order(:a).last(i){:z > 26}.should == [[:a,1,:b,2, "SELECT * FROM test WHERE (z > 26) ORDER BY a DESC LIMIT #{i}"]] * i
+    r = @d.order(:a).last(i){:z.sql_number > 26}.should == [[:a,1,:b,2, "SELECT * FROM test WHERE (z > 26) ORDER BY a DESC LIMIT #{i}"]] * i
   end
   
   specify "#last should raise if no order is given" do
@@ -2537,7 +2597,7 @@ context "Dataset#query" do
     q.sql.should == "SELECT * FROM zzz WHERE ((x + 2) > (y + 3))"
 
     q = @d.from(:zzz).query do
-      where((:x > 1) & (:y > 2))
+      where((:x.sql_number > 1) & (:y.sql_number > 2))
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM zzz WHERE ((x > 1) AND (y > 2))"
@@ -2553,7 +2613,7 @@ context "Dataset#query" do
     q = @d.query do
       from :abc
       group_by :id
-      having(:x >= 2)
+      having(:x.sql_number >= 2)
     end
     q.class.should == @d.class
     q.sql.should == "SELECT * FROM abc GROUP BY id HAVING (x >= 2)"
@@ -2606,7 +2666,7 @@ context "Dataset" do
   end
 
   specify "should support self-changing filter! with block" do
-    @d.filter!{:y < 2}
+    @d.filter!{:y.sql_number < 2}
     @d.sql.should == "SELECT * FROM x WHERE (y < 2)"
   end
   

data/spec/sequel_core/expression_filters_spec.rb

@@ -27,34 +27,19 @@ context "Blockless Ruby Filters" do
   end
 
   it "should support NOT with SQL functions" do
-    @d.l(~:is_blah[]).should == 'NOT is_blah()'
-    @d.l(~:is_blah[:x]).should == 'NOT is_blah(x)'
-    @d.l(~:is_blah[:x__y]).should == 'NOT is_blah(x.y)'
-    @d.l(~:is_blah[:x, :x__y]).should == 'NOT is_blah(x, x.y)'
+    @d.l(~:is_blah.sql_function).should == 'NOT is_blah()'
+    @d.l(~:is_blah.sql_function(:x)).should == 'NOT is_blah(x)'
+    @d.l(~:is_blah.sql_function(:x__y)).should == 'NOT is_blah(x.y)'
+    @d.l(~:is_blah.sql_function(:x, :x__y)).should == 'NOT is_blah(x, x.y)'
   end
 
   it "should handle multiple ~" do
     @d.l(~~:x).should == 'x'
     @d.l(~~~:x).should == 'NOT x'
-    @d.l(~~(:x > 100)).should == '(x > 100)'
     @d.l(~~(:x & :y)).should == '(x AND y)'
     @d.l(~~(:x | :y)).should == '(x OR y)'
   end
 
-  it "should support >, <, >=, and <= via Symbol#>,<,>=,<=" do
-    @d.l(:x > 100).should == '(x > 100)'
-    @d.l(:x < 100.01).should == '(x < 100.01)'
-    @d.l(:x >= 100000000000000000000000000000000000).should == '(x >= 100000000000000000000000000000000000)'
-    @d.l(:x <= 100).should == '(x <= 100)'
-  end
-  
-  it "should support negation of >, <, >=, and <= via Symbol#~" do
-    @d.l(~(:x > 100)).should == '(x <= 100)'
-    @d.l(~(:x < 100.01)).should == '(x >= 100.01)'
-    @d.l(~(:x >= 100000000000000000000000000000000000)).should == '(x < 100000000000000000000000000000000000)'
-    @d.l(~(:x <= 100)).should == '(x > 100)'
-  end
-
   it "should support = via Hash" do
     @d.l(:x => 100).should == '(x = 100)'
     @d.l(:x => 'a').should == '(x = \'a\')'
@@ -135,33 +120,19 @@ context "Blockless Ruby Filters" do
     proc{~([:x, :y].sql_string_join)}.should raise_error
   end
 
-  it "should not allow mathematical, inequality, or string operations on true, false, or nil" do
+  it "should not allow mathematical or string operations on true, false, or nil" do
     proc{:x + 1}.should_not raise_error
     proc{:x - true}.should raise_error(Sequel::Error)
     proc{:x / false}.should raise_error(Sequel::Error)
     proc{:x * nil}.should raise_error(Sequel::Error)
-    proc{:x > 1}.should_not raise_error
-    proc{:x < true}.should raise_error(Sequel::Error)
-    proc{:x >= false}.should raise_error(Sequel::Error)
-    proc{:x <= nil}.should raise_error(Sequel::Error)
     proc{[:x, nil].sql_string_join}.should raise_error(Sequel::Error)
   end
 
-  it "should not allow mathematical, inequality, or string operations on boolean complex expressions" do
+  it "should not allow mathematical or string operations on boolean complex expressions" do
     proc{:x + (:y + 1)}.should_not raise_error
     proc{:x - (~:y)}.should raise_error(Sequel::Error)
     proc{:x / (:y & :z)}.should raise_error(Sequel::Error)
     proc{:x * (:y | :z)}.should raise_error(Sequel::Error)
-    proc{:x > (:y > 5)}.should raise_error(Sequel::Error)
-    proc{:x < (:y < 5)}.should raise_error(Sequel::Error)
-    proc{:x >= (:y >= 5)}.should raise_error(Sequel::Error)
-    proc{:x <= (:y <= 5)}.should raise_error(Sequel::Error)
-    proc{:x > {:y => nil}}.should raise_error(Sequel::Error)
-    proc{:x < ~{:y => nil}}.should raise_error(Sequel::Error)
-    proc{:x >= {:y => 5}}.should raise_error(Sequel::Error)
-    proc{:x <= ~{:y => 5}}.should raise_error(Sequel::Error)
-    proc{:x >= {:y => [1,2,3]}}.should raise_error(Sequel::Error)
-    proc{:x <= ~{:y => [1,2,3]}}.should raise_error(Sequel::Error)
     proc{:x + :y.like('a')}.should raise_error(Sequel::Error)
     proc{:x - :y.like(/a/)}.should raise_error(Sequel::Error)
     proc{:x * :y.like(/a/i)}.should raise_error(Sequel::Error)
@@ -178,7 +149,7 @@ context "Blockless Ruby Filters" do
     @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) & (:y < 200)).should == '((x > 200) AND (y < 200))'
+    @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)'
     @d.l(~:x & ~:y).should == '(NOT x AND NOT y)'
@@ -191,7 +162,7 @@ context "Blockless Ruby Filters" do
     @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 > 200) | (:y < 200)).should == '((x > 200) OR (y < 200))'
+    @d.l((:x.sql_number > 200) | (:y.sql_number < 200)).should == '((x > 200) OR (y < 200))'
   end
   
   it "should support & | combinations" do
@@ -204,7 +175,7 @@ context "Blockless Ruby Filters" do
     @d.l(~((:x | :y) & :z)).should == '((NOT x AND NOT y) OR NOT z)'
     @d.l(~(:x | (:y & :z))).should == '(NOT x AND (NOT y OR NOT z))'
     @d.l(~((:x & :w) | (:y & :z))).should == '((NOT x OR NOT w) AND (NOT y OR NOT z))'
-    @d.l(~((:x > 200) | (:y & :z))).should == '((x <= 200) AND (NOT y OR NOT z))'
+    @d.l(~((:x.sql_number > 200) | (:y & :z))).should == '((x <= 200) AND (NOT y OR NOT z))'
   end
   
   it "should support LiteralString" do
@@ -278,8 +249,8 @@ context "Blockless Ruby Filters" do
     @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[1], :y|1].sql_string_join).should == '(x(1) || y[1])'
-    @d.lit([:x[1], 'y.z'.lit].sql_string_join(', ')).should == "(x(1) || ', ' || y.z)"
+    @d.lit([:x.sql_function(1), :y|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)"
@@ -349,4 +320,44 @@ context "Blockless Ruby Filters" do
     e2 = ~:comment.like('%:hidden:%')
     e1.should == e2
   end
+  
+  if RUBY_VERSION < '1.9.0'
+    it "should not allow inequality operations on true, false, or nil" do
+      proc{:x > 1}.should_not raise_error
+      proc{:x < true}.should raise_error(Sequel::Error)
+      proc{:x >= false}.should raise_error(Sequel::Error)
+      proc{:x <= nil}.should raise_error(Sequel::Error)
+    end
+
+    it "should not allow inequality operations on boolean complex expressions" do
+      proc{:x > (:y > 5)}.should raise_error(Sequel::Error)
+      proc{:x < (:y < 5)}.should raise_error(Sequel::Error)
+      proc{:x >= (:y >= 5)}.should raise_error(Sequel::Error)
+      proc{:x <= (:y <= 5)}.should raise_error(Sequel::Error)
+      proc{:x > {:y => nil}}.should raise_error(Sequel::Error)
+      proc{:x < ~{:y => nil}}.should raise_error(Sequel::Error)
+      proc{:x >= {:y => 5}}.should raise_error(Sequel::Error)
+      proc{:x <= ~{:y => 5}}.should raise_error(Sequel::Error)
+      proc{:x >= {:y => [1,2,3]}}.should raise_error(Sequel::Error)
+      proc{:x <= ~{:y => [1,2,3]}}.should raise_error(Sequel::Error)
+    end
+    
+    it "should support >, <, >=, and <= via Symbol#>,<,>=,<=" do
+      @d.l(:x > 100).should == '(x > 100)'
+      @d.l(:x < 100.01).should == '(x < 100.01)'
+      @d.l(:x >= 100000000000000000000000000000000000).should == '(x >= 100000000000000000000000000000000000)'
+      @d.l(:x <= 100).should == '(x <= 100)'
+    end
+    
+    it "should support negation of >, <, >=, and <= via Symbol#~" do
+      @d.l(~(:x > 100)).should == '(x <= 100)'
+      @d.l(~(:x < 100.01)).should == '(x >= 100.01)'
+      @d.l(~(:x >= 100000000000000000000000000000000000)).should == '(x < 100000000000000000000000000000000000)'
+      @d.l(~(:x <= 100)).should == '(x > 100)'
+    end
+    
+    it "should support double negation via ~" do
+      @d.l(~~(:x > 100)).should == '(x > 100)'
+    end
+  end
 end