sequel 3.27.0 → 3.28.0

data/spec/adapters/postgres_spec.rb

@@ -514,11 +514,6 @@ describe "Postgres::Dataset#insert" do
     @db.sqls.last.should == 'INSERT INTO test5 (value) VALUES (10) RETURNING xid'
   end
 
-  specify "should have insert_returning_sql use the RETURNING keyword" do
-    @ds.insert_returning_sql(:xid, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING xid"
-    @ds.insert_returning_sql('*'.lit, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING *"
-  end
-
   specify "should have insert_select return nil if server_version < 80200" do
     @ds.meta_def(:server_version){80100}
     @ds.insert_select(:value=>10).should == nil
@@ -976,7 +971,7 @@ if POSTGRES_DB.adapter_scheme == :postgres
       @db.transaction{1001.times{|i| @ds.insert(i)}}
     end
     after(:all) do
-      @db.drop_table(:test) rescue nil
+      @db.drop_table(:test_cursor) rescue nil
     end
   
     specify "should return the same results as the non-cursor use" do
@@ -1026,3 +1021,76 @@ if POSTGRES_DB.adapter_scheme == :postgres
     end
   end
 end
+
+if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRES_DB.server_version >= 90000
+  describe "Postgres::Database#copy_table" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_copy){Integer :x; Integer :y}
+      ds = @db[:test_copy]
+      ds.insert(1, 2)
+      ds.insert(3, 4)
+    end
+    after(:all) do
+      @db.drop_table(:test_copy) rescue nil
+    end
+  
+    specify "without a block or options should return a text version of the table as a single string" do
+      @db.copy_table(:test_copy).should == "1\t2\n3\t4\n"
+    end
+
+    specify "without a block and with :format=>:csv should return a csv version of the table as a single string" do
+      @db.copy_table(:test_copy, :format=>:csv).should == "1,2\n3,4\n"
+    end
+  
+    specify "should treat string as SQL code" do
+      @db.copy_table('COPY "test_copy" TO STDOUT').should == "1\t2\n3\t4\n"
+    end
+  
+    specify "should respect given :options options" do
+      @db.copy_table(:test_copy, :options=>"FORMAT csv, HEADER TRUE").should == "x,y\n1,2\n3,4\n"
+    end
+  
+    specify "should respect given :options options when :format is used" do
+      @db.copy_table(:test_copy, :format=>:csv, :options=>"QUOTE '''', FORCE_QUOTE *").should == "'1','2'\n'3','4'\n"
+    end
+  
+    specify "should accept dataset as first argument" do
+      @db.copy_table(@db[:test_copy].cross_join(:test_copy___tc).order(1, 2, 3, 4)).should == "1\t2\t1\t2\n1\t2\t3\t4\n3\t4\t1\t2\n3\t4\t3\t4\n"
+    end
+  
+    specify "with a block and no options should yield each row as a string in text format" do
+      buf = []
+      @db.copy_table(:test_copy){|b| buf << b}
+      buf.should == ["1\t2\n", "3\t4\n"]
+    end
+  
+    specify "with a block and :format=>:csv should yield each row as a string in csv format" do
+      buf = []
+      @db.copy_table(:test_copy, :format=>:csv){|b| buf << b}
+      buf.should == ["1,2\n", "3,4\n"]
+    end
+  
+    specify "should work fine when using a block that is terminated early with a following copy_table" do
+      buf = []
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; raise ArgumentError}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      @db.copy_table(:test_copy){|b| buf << b}
+      buf.should == ["1\t2\n", "3\t4\n"]
+    end
+  
+    specify "should work fine when using a block that is terminated early with a following regular query" do
+      buf = []
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; raise ArgumentError}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      @db[:test_copy].select_order_map(:x).should == [1, 3]
+    end
+  end  
+end

data/spec/adapters/spec_helper.rb

@@ -36,6 +36,7 @@ end
   end
 
   def self.cspecify(message, *checked, &block)
+    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
     pending = false
     checked.each do |c|
       case c

data/spec/adapters/sqlite_spec.rb

@@ -66,6 +66,17 @@ describe "An SQLite database" do
     @db[:fk].all.should == [{:id=>1, :parent_id=>2}]
   end
   
+  specify "should support a use_timestamp_timezones setting" do
+    @db.create_table!(:time){Time :time}
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_string).should =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = false
+    @db[:time].delete
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_string).should_not =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = true
+  end
+  
   specify "should provide a list of existing tables" do
     @db.drop_table(:testing) rescue nil
     @db.tables.should be_a_kind_of(Array)

data/spec/core/database_spec.rb

@@ -1544,6 +1544,13 @@ describe "Database#typecast_value" do
     end
   end
 
+  specify "should correctly handle time value conversion to SQLTime with fractional seconds" do
+    t = Time.now
+    st = Sequel::SQLTime.local(t.year, t.month, t.day, 1, 2, 3, 500000)
+    t = Time.local(t.year, t.month, t.day, 1, 2, 3, 500000)
+    @db.typecast_value(:time, t).should == st
+  end
+
   specify "should have an underlying exception class available at wrapped_exception" do
     begin
       @db.typecast_value(:date, 'a')

data/spec/core/dataset_spec.rb

@@ -622,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
@@ -1300,6 +1308,32 @@ describe "Dataset#select_all" do
   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
@@ -1344,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
@@ -1445,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
@@ -1661,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)
@@ -1685,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
@@ -1704,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
@@ -2177,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
@@ -2251,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)
@@ -3805,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
@@ -4032,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
@@ -4070,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
@@ -4089,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']
@@ -4112,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
@@ -4163,3 +4277,52 @@ describe "Custom ASTTransformer" do
       '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

data/spec/core/expression_filters_spec.rb

@@ -186,31 +186,26 @@ describe "Blockless Ruby Filters" do
     @d.l(~((((:x - :y)/(:x + :y))*:z) <= 100)).should == '((((x - y) / (x + y)) * z) > 100)'
   end
   
-  it "should not allow negation of string expressions" do
-    proc{~:x.sql_string}.should raise_error
-    proc{~([:x, :y].sql_string_join)}.should raise_error
+  it "should not add ~ method to string expressions" do
+    proc{~:x.sql_string}.should raise_error(NoMethodError) 
   end
 
-  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, nil].sql_string_join}.should raise_error(Sequel::Error)
+  it "should allow mathematical or string operations on true, false, or nil" do
+    @d.lit(:x + 1).should == '(x + 1)'
+    @d.lit(:x - true).should == "(x - 't')"
+    @d.lit(:x / false).should == "(x / 'f')"
+    @d.lit(:x * nil).should == '(x * NULL)'
+    @d.lit([:x, nil].sql_string_join).should == '(x || NULL)'
   end
 
-  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.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)
-    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)
-    proc{[:x, ~:y.like(/a/i)].sql_string_join}.should raise_error(Sequel::Error)
+  it "should allow mathematical or string operations on boolean complex expressions" do
+    @d.lit(:x + (:y + 1)).should == '(x + y + 1)'
+    @d.lit(:x - ~:y).should == '(x - NOT y)'
+    @d.lit(:x / (:y & :z)).should == '(x / (y AND z))'
+    @d.lit(:x * (:y | :z)).should == '(x * (y OR z))'
+    @d.lit(:x + :y.like('a')).should == "(x + (y LIKE 'a'))"
+    @d.lit(:x - ~:y.like('a')).should == "(x - (y NOT LIKE 'a'))"
+    @d.lit([:x, ~:y.like('a')].sql_string_join).should == "(x || (y NOT LIKE 'a'))"
   end
 
   it "should support AND conditions via &" do
@@ -382,12 +377,12 @@ describe "Blockless Ruby Filters" do
     @d.l((:x + 1) & (:x + 2) > 100).should == '(((x + 1) & (x + 2)) > 100)'
   end
 
-  it "should raise an error if use a Bitwise method on a ComplexExpression that isn't a NumericExpression" do
-    proc{(:x + 1) & (:x & 2)}.should raise_error(Sequel::Error)
+  it "should allow using a Bitwise method on a ComplexExpression that isn't a NumericExpression" do
+    @d.lit((:x + 1) & (:x + '2')).should == "((x + 1) & (x || '2'))"
   end
 
-  it "should raise an error if use a Boolean method on a ComplexExpression that isn't a BooleanExpression" do
-    proc{:x & (:x + 2)}.should raise_error(Sequel::Error)
+  it "should allow using a Boolean method on a ComplexExpression that isn't a BooleanExpression" do
+    @d.l(:x & (:x + '2')).should == "(x AND (x || '2'))"
   end
 
   it "should raise an error if attempting to invert a ComplexExpression that isn't a BooleanExpression" do
@@ -441,6 +436,77 @@ describe "Blockless Ruby Filters" do
     proc{Sequel::SQL::ComplexExpression.new(:BANG, 1, 2)}.should raise_error(Sequel::Error)
   end
 
+  it "should use a string concatentation for + if given a string" do
+    @d.lit(:x + '1').should == "(x || '1')"
+    @d.lit(:x + '1' + '1').should == "(x || '1' || '1')"
+  end
+
+  it "should use an addition for + if given a literal string" do
+    @d.lit(:x + '1'.lit).should == "(x + 1)"
+    @d.lit(:x + '1'.lit + '1'.lit).should == "(x + 1 + 1)"
+  end
+
+  it "should use a bitwise operator for & and | if given an integer" do
+    @d.lit(:x & 1).should == "(x & 1)"
+    @d.lit(:x | 1).should == "(x | 1)"
+    @d.lit(:x & 1 & 1).should == "(x & 1 & 1)"
+    @d.lit(:x | 1 | 1).should == "(x | 1 | 1)"
+  end
+  
+  it "should allow adding a string to an integer expression" do
+    @d.lit(:x + 1 + 'a').should == "(x + 1 + 'a')"
+  end
+
+  it "should allow adding an integer to an string expression" do
+    @d.lit(:x + 'a' + 1).should == "(x || 'a' || 1)"
+  end
+
+  it "should allow adding a boolean to an integer expression" do
+    @d.lit(:x + 1 + true).should == "(x + 1 + 't')"
+  end
+
+  it "should allow adding a boolean to an string expression" do
+    @d.lit(:x + 'a' + true).should == "(x || 'a' || 't')"
+  end
+
+  it "should allow using a boolean operation with an integer on an boolean expression" do
+    @d.lit(:x & :a & 1).should == "(x AND a AND 1)"
+  end
+
+  it "should allow using a boolean operation with a string on an boolean expression" do
+    @d.lit(:x & :a & 'a').should == "(x AND a AND 'a')"
+  end
+
+  it "should allowing AND of boolean expression and literal string" do
+   @d.lit(:x & :a & 'a'.lit).should == "(x AND a AND a)"
+  end
+
+  it "should allowing + of integer expression and literal string" do
+   @d.lit(:x + :a + 'a'.lit).should == "(x + a + a)"
+  end
+
+  it "should allowing + of string expression and literal string" do
+   @d.lit(:x + 'a' + 'a'.lit).should == "(x || 'a' || a)"
+  end
+
+  it "should allow sql_{string,boolean,number} methods on numeric expressions" do
+   @d.lit((:x + 1).sql_string + 'a').should == "((x + 1) || 'a')"
+   @d.lit((:x + 1).sql_boolean & 1).should == "((x + 1) AND 1)"
+   @d.lit((:x + 1).sql_number + 'a').should == "(x + 1 + 'a')"
+  end
+
+  it "should allow sql_{string,boolean,number} methods on string expressions" do
+   @d.lit((:x + 'a').sql_string + 'a').should == "(x || 'a' || 'a')"
+   @d.lit((:x + 'a').sql_boolean & 1).should == "((x || 'a') AND 1)"
+   @d.lit((:x + 'a').sql_number + 'a').should == "((x || 'a') + 'a')"
+  end
+
+  it "should allow sql_{string,boolean,number} methods on boolean expressions" do
+   @d.lit((:x & :y).sql_string + 'a').should == "((x AND y) || 'a')"
+   @d.lit((:x & :y).sql_boolean & 1).should == "(x AND y AND 1)"
+   @d.lit((:x & :y).sql_number + 'a').should == "((x AND y) + 'a')"
+  end
+
   it "should raise an error if trying to literalize an invalid complex expression" do
     ce = :x + 1
     ce.instance_variable_set(:@op, :BANG)
@@ -494,23 +560,23 @@ describe "Blockless Ruby Filters" do
   
   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)
+      @d.lit(:x > 1).should == "(x > 1)"
+      @d.lit(:x < true).should == "(x < 't')"
+      @d.lit(:x >= false).should == "(x >= 'f')"
+      @d.lit(:x <= nil).should == "(x <= NULL)"
     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)
+      @d.lit(:x > (:y > 5)).should == "(x > (y > 5))"
+      @d.lit(:x < (:y < 5)).should == "(x < (y < 5))"
+      @d.lit(:x >= (:y >= 5)).should == "(x >= (y >= 5))"
+      @d.lit(:x <= (:y <= 5)).should == "(x <= (y <= 5))"
+      @d.lit(:x > {:y => nil}).should == "(x > (y IS NULL))"
+      @d.lit(:x < ~{:y => nil}).should == "(x < (y IS NOT NULL))"
+      @d.lit(:x >= {:y => 5}).should == "(x >= (y = 5))"
+      @d.lit(:x <= ~{:y => 5}).should == "(x <= (y != 5))"
+      @d.lit(:x >= {:y => [1,2,3]}).should == "(x >= (y IN (1, 2, 3)))"
+      @d.lit(:x <= ~{:y => [1,2,3]}).should == "(x <= (y NOT IN (1, 2, 3)))"
     end
     
     it "should support >, <, >=, and <= via Symbol#>,<,>=,<=" do
@@ -605,7 +671,7 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should support :frame=>:rows option for window function calls" do
-    @d.l{rank(:over, :frame=>:rows){}}.should == 'rank() OVER (ROWS UNBOUNDED PRECEDING)'
+    @d.l{rank(:over, :frame=>:rows){}}.should == 'rank() OVER (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
   it "should support :frame=>'some string' option for window function calls" do
@@ -617,7 +683,7 @@ describe Sequel::SQL::VirtualRow do
   end
 
   it "should support all these options together" do
-    @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.should == 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS UNBOUNDED PRECEDING)'
+    @d.l{count(:over, :* =>true, :partition=>a, :order=>b, :window=>:win, :frame=>:rows){}}.should == 'count(*) OVER ("win" PARTITION BY "a" ORDER BY "b" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)'
   end
 
   it "should raise an error if window functions are not supported" do