sequel 3.44.0 → 3.45.0

data/spec/adapters/spec_helper.rb

@@ -1,5 +1,11 @@
 require 'rubygems'
 require 'logger'
+
+if ENV['COVERAGE']
+  require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")
+  SimpleCov.sequel_coverage(:group=>%r{lib/sequel/adapters})
+end
+
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel/no_core_ext'

data/spec/core/connection_pool_spec.rb

@@ -256,6 +256,22 @@ shared_examples_for "A threaded connection pool" do
     t.join
   end
 
+  specify "should wait until a connection is available if all are checked out" do
+    pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>1, :pool_timeout=>0.1, :pool_sleep_time=>0))
+    q, q1 = Queue.new, Queue.new
+    t = Thread.new do
+      pool.hold do |c|
+        q1.push nil
+        3.times{Thread.pass}
+        q.pop
+      end
+    end
+    q1.pop
+    proc{pool.hold{}}.should raise_error(Sequel::PoolTimeout)
+    q.push nil
+    t.join
+  end
+
   specify "should not have all_connections yield all available connections" do
     pool = Sequel::ConnectionPool.get_pool(mock_db.call(&@icpp), @cp_opts.merge(:max_connections=>2, :pool_timeout=>0))
     q, q1 = Queue.new, Queue.new

data/spec/core/database_spec.rb

@@ -656,9 +656,58 @@ shared_examples_for "Database#transaction" do
     a.should == [1, 1]
   end
   
-  specify "should raise an error if attempting to use :disconnect=>:retry inside another transaction" do
+  specify "should support :retry_on option for automatically retrying transactions" do
+    a = []
+    @db.transaction(:retry_on=>Sequel::DatabaseDisconnectError){a << 1; raise Sequel::DatabaseDisconnectError if a.length < 2}
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
+    a.should == [1, 1]
+
+    a = []
+    @db.transaction(:retry_on=>[Sequel::ConstraintViolation, Sequel::SerializationFailure]) do
+      a << 1
+      raise Sequel::SerializationFailure if a.length == 1
+      raise Sequel::ConstraintViolation if a.length == 2
+    end
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
+    a.should == [1, 1, 1]
+  end
+  
+  specify "should support :num_retries option for limiting the number of retry times" do
+    a = []
+    lambda do
+      @db.transaction(:num_retries=>1, :retry_on=>[Sequel::ConstraintViolation, Sequel::SerializationFailure]) do
+        a << 1
+        raise Sequel::SerializationFailure if a.length == 1
+        raise Sequel::ConstraintViolation if a.length == 2
+      end
+    end.should raise_error(Sequel::ConstraintViolation)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK']
+    a.should == [1, 1]
+  end
+  
+  specify "should support :num_retries=>nil option to retry indefinitely" do
+    a = []
+    lambda do
+      @db.transaction(:num_retries=>nil, :retry_on=>[Sequel::ConstraintViolation]) do
+        a << 1
+        raise Sequel::SerializationFailure if a.length >= 100
+        raise Sequel::ConstraintViolation
+      end
+    end.should raise_error(Sequel::SerializationFailure)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK'] * 100
+    a.should == [1] * 100
+  end
+  
+  specify "should raise an error if using :disconnect=>:retry and :retry_on together" do
+    proc{@db.transaction(:disconnect=>:retry, :retry_on=>Sequel::ConstraintViolation){}}.should raise_error(Sequel::Error)
+    @db.sqls.should == []
+  end
+  
+  specify "should raise an error if attempting to use :disconnect=>:retry or :retry_on inside another transaction" do
     proc{@db.transaction{@db.transaction(:disconnect=>:retry){}}}.should raise_error(Sequel::Error)
     @db.sqls.should == ['BEGIN', 'ROLLBACK']
+    proc{@db.transaction{@db.transaction(:retry_on=>Sequel::ConstraintViolation){}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
   end
   
   specify "should handle returning inside of the block by committing" do
@@ -2259,3 +2308,30 @@ describe "Database extensions" do
     proc{@db.extension(:foo2)}.should raise_error(Sequel::Error)
   end
 end
+
+describe "Database specific exception classes" do
+  before do
+    @db = Sequel.mock
+    class << @db
+      attr_accessor :sql_state
+
+      def database_exception_sqlstate(exception, opts={})
+        @sql_state
+      end
+    end
+  end
+
+  specify "should use appropriate exception classes for given SQL states" do
+    @db.fetch = ArgumentError
+    @db.sql_state = '23502'
+    proc{@db.get(1)}.should raise_error(Sequel::NotNullConstraintViolation)
+    @db.sql_state = '23503'
+    proc{@db.get(1)}.should raise_error(Sequel::ForeignKeyConstraintViolation)
+    @db.sql_state = '23505'
+    proc{@db.get(1)}.should raise_error(Sequel::UniqueConstraintViolation)
+    @db.sql_state = '23513'
+    proc{@db.get(1)}.should raise_error(Sequel::CheckConstraintViolation)
+    @db.sql_state = '40001'
+    proc{@db.get(1)}.should raise_error(Sequel::SerializationFailure)
+  end
+end

data/spec/core/dataset_spec.rb

@@ -575,8 +575,8 @@ describe "Dataset#where" do
     @dataset.filter{gdp > d}.sql.should == "SELECT * FROM test WHERE (gdp > (SELECT avg(gdp) FROM test WHERE (region = 'Asia')))"
     @dataset.filter{a < 1}.sql.should == 'SELECT * FROM test WHERE (a < 1)'
     @dataset.filter{(a >= 1) & (b <= 2)}.sql.should == 'SELECT * FROM test WHERE ((a >= 1) AND (b <= 2))'
-    @dataset.filter{c.like 'ABC%'}.sql.should == "SELECT * FROM test WHERE (c LIKE 'ABC%')"
-    @dataset.filter{c.like 'ABC%', '%XYZ'}.sql.should == "SELECT * FROM test WHERE ((c LIKE 'ABC%') OR (c LIKE '%XYZ'))"
+    @dataset.filter{c.like 'ABC%'}.sql.should == "SELECT * FROM test WHERE (c LIKE 'ABC%' ESCAPE '\\')"
+    @dataset.filter{c.like 'ABC%', '%XYZ'}.sql.should == "SELECT * FROM test WHERE ((c LIKE 'ABC%' ESCAPE '\\') OR (c LIKE '%XYZ' ESCAPE '\\'))"
   end
   
   specify "should work for grouped datasets" do
@@ -2047,6 +2047,11 @@ describe "Dataset#from_self" do
     ds.from(:a).with(:a, ds.from(:b)).from_self.sql.should == 'WITH a AS (SELECT * FROM b) SELECT * FROM (SELECT * FROM a) AS t1'
     ds.from(:a, :c).with(:a, ds.from(:b)).with(:c, ds.from(:d)).from_self.sql.should == 'WITH a AS (SELECT * FROM b), c AS (SELECT * FROM d) SELECT * FROM (SELECT * FROM a, c) AS t1'
   end
+
+  specify "should have working mutation method" do
+    @ds.from_self!
+    @ds.sql.should == 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS t1'
+  end
 end
 
 describe "Dataset#join_table" do
@@ -3194,47 +3199,47 @@ describe "Dataset#grep" do
   end
   
   specify "should format a SQL filter correctly" do
-    @ds.grep(:title, 'ruby').sql.should == "SELECT * FROM posts WHERE ((title LIKE 'ruby'))"
+    @ds.grep(:title, 'ruby').sql.should == "SELECT * FROM posts WHERE ((title LIKE 'ruby' ESCAPE '\\'))"
   end
 
   specify "should support multiple columns" do
-    @ds.grep([:title, :body], 'ruby').sql.should == "SELECT * FROM posts WHERE ((title LIKE 'ruby') OR (body LIKE 'ruby'))"
+    @ds.grep([:title, :body], 'ruby').sql.should == "SELECT * FROM posts WHERE ((title LIKE 'ruby' ESCAPE '\\') OR (body LIKE 'ruby' ESCAPE '\\'))"
   end
   
   specify "should support multiple search terms" do
-    @ds.grep(:title, ['abc', 'def']).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def'))"
+    @ds.grep(:title, ['abc', 'def']).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc' ESCAPE '\\') OR (title LIKE 'def' ESCAPE '\\'))"
   end
   
   specify "should support multiple columns and search terms" do
-    @ds.grep([:title, :body], ['abc', 'def']).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def') OR (body LIKE 'abc') OR (body LIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def']).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc' ESCAPE '\\') OR (title LIKE 'def' ESCAPE '\\') OR (body LIKE 'abc' ESCAPE '\\') OR (body LIKE 'def' ESCAPE '\\'))"
   end
   
   specify "should support the :all_patterns option" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true).sql.should == "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (body LIKE 'abc')) AND ((title LIKE 'def') OR (body LIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true).sql.should == "SELECT * FROM posts WHERE (((title LIKE 'abc' ESCAPE '\\') OR (body LIKE 'abc' ESCAPE '\\')) AND ((title LIKE 'def' ESCAPE '\\') OR (body LIKE 'def' ESCAPE '\\')))"
   end
   
   specify "should support the :all_columns option" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true).sql.should == "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (title LIKE 'def')) AND ((body LIKE 'abc') OR (body LIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true).sql.should == "SELECT * FROM posts WHERE (((title LIKE 'abc' ESCAPE '\\') OR (title LIKE 'def' ESCAPE '\\')) AND ((body LIKE 'abc' ESCAPE '\\') OR (body LIKE 'def' ESCAPE '\\')))"
   end
   
   specify "should support the :case_insensitive option" do
-    @ds.grep([:title, :body], ['abc', 'def'], :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE ((title ILIKE 'abc') OR (title ILIKE 'def') OR (body ILIKE 'abc') OR (body ILIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def'], :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE ((UPPER(title) LIKE UPPER('abc') ESCAPE '\\') OR (UPPER(title) LIKE UPPER('def') ESCAPE '\\') OR (UPPER(body) LIKE UPPER('abc') ESCAPE '\\') OR (UPPER(body) LIKE UPPER('def') ESCAPE '\\'))"
   end
   
   specify "should support the :all_patterns and :all_columns options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc') AND (body LIKE 'abc') AND (title LIKE 'def') AND (body LIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true).sql.should == "SELECT * FROM posts WHERE ((title LIKE 'abc' ESCAPE '\\') AND (body LIKE 'abc' ESCAPE '\\') AND (title LIKE 'def' ESCAPE '\\') AND (body LIKE 'def' ESCAPE '\\'))"
   end
   
   specify "should support the :all_patterns and :case_insensitive options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (body ILIKE 'abc')) AND ((title ILIKE 'def') OR (body ILIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE (((UPPER(title) LIKE UPPER('abc') ESCAPE '\\') OR (UPPER(body) LIKE UPPER('abc') ESCAPE '\\')) AND ((UPPER(title) LIKE UPPER('def') ESCAPE '\\') OR (UPPER(body) LIKE UPPER('def') ESCAPE '\\')))"
   end
   
   specify "should support the :all_columns and :case_insensitive options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE (((title ILIKE 'abc') OR (title ILIKE 'def')) AND ((body ILIKE 'abc') OR (body ILIKE 'def')))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_columns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE (((UPPER(title) LIKE UPPER('abc') ESCAPE '\\') OR (UPPER(title) LIKE UPPER('def') ESCAPE '\\')) AND ((UPPER(body) LIKE UPPER('abc') ESCAPE '\\') OR (UPPER(body) LIKE UPPER('def') ESCAPE '\\')))"
   end
   
   specify "should support the :all_patterns, :all_columns, and :case_insensitive options together" do
-    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE ((title ILIKE 'abc') AND (body ILIKE 'abc') AND (title ILIKE 'def') AND (body ILIKE 'def'))"
+    @ds.grep([:title, :body], ['abc', 'def'], :all_patterns=>true, :all_columns=>true, :case_insensitive=>true).sql.should == "SELECT * FROM posts WHERE ((UPPER(title) LIKE UPPER('abc') ESCAPE '\\') AND (UPPER(body) LIKE UPPER('abc') ESCAPE '\\') AND (UPPER(title) LIKE UPPER('def') ESCAPE '\\') AND (UPPER(body) LIKE UPPER('def') ESCAPE '\\'))"
   end
 
   specify "should not support regexps if the database doesn't supports it" do
@@ -3245,11 +3250,11 @@ describe "Dataset#grep" do
   specify "should support regexps if the database supports it" do
     def @ds.supports_regexp?; true end
     @ds.grep(:title, /ruby/).sql.should == "SELECT * FROM posts WHERE ((title ~ 'ruby'))"
-    @ds.grep(:title, [/^ruby/, 'ruby']).sql.should == "SELECT * FROM posts WHERE ((title ~ '^ruby') OR (title LIKE 'ruby'))"
+    @ds.grep(:title, [/^ruby/, 'ruby']).sql.should == "SELECT * FROM posts WHERE ((title ~ '^ruby') OR (title LIKE 'ruby' ESCAPE '\\'))"
   end
 
   specify "should support searching against other columns" do
-    @ds.grep(:title, :body).sql.should == "SELECT * FROM posts WHERE ((title LIKE body))"
+    @ds.grep(:title, :body).sql.should == "SELECT * FROM posts WHERE ((title LIKE body ESCAPE '\\'))"
   end
 end
 
@@ -4608,3 +4613,13 @@ describe "Dataset#paged_each" do
   end
 end
 
+describe "Dataset#escape_like" do
+  before do
+    @ds = Sequel.mock[:test]
+  end
+
+  it "should escape % and _ and \\ characters" do
+    @ds.escape_like("foo\\%_bar").should == "foo\\\\\\%\\_bar"
+  end
+end
+

data/spec/core/expression_filters_spec.rb

@@ -96,9 +96,9 @@ describe "Blockless Ruby Filters" do
     @d.lit(Sequel.expr(:x) - ~Sequel.expr(:y)).should == '(x - NOT y)'
     @d.lit(Sequel.expr(:x) / (Sequel.expr(:y) & :z)).should == '(x / (y AND z))'
     @d.lit(Sequel.expr(:x) * (Sequel.expr(:y) | :z)).should == '(x * (y OR z))'
-    @d.lit(Sequel.expr(:x) + Sequel.expr(:y).like('a')).should == "(x + (y LIKE 'a'))"
-    @d.lit(Sequel.expr(:x) - ~Sequel.expr(:y).like('a')).should == "(x - (y NOT LIKE 'a'))"
-    @d.lit(Sequel.join([:x, ~Sequel.expr(:y).like('a')])).should == "(x || (y NOT LIKE 'a'))"
+    @d.lit(Sequel.expr(:x) + Sequel.expr(:y).like('a')).should == "(x + (y LIKE 'a' ESCAPE '\\'))"
+    @d.lit(Sequel.expr(:x) - ~Sequel.expr(:y).like('a')).should == "(x - (y NOT LIKE 'a' ESCAPE '\\'))"
+    @d.lit(Sequel.join([:x, ~Sequel.expr(:y).like('a')])).should == "(x || (y NOT LIKE 'a' ESCAPE '\\'))"
   end
 
   it "should support AND conditions via &" do
@@ -143,7 +143,7 @@ describe "Blockless Ruby Filters" do
     @d.l(Sequel.expr(Sequel.lit('y') => Sequel.lit('z')) & Sequel.lit('x')).should == '((y = z) AND x)'
     @d.l((Sequel.lit('x') > 200) & (Sequel.lit('y') < 200)).should == '((x > 200) AND (y < 200))'
     @d.l(~(Sequel.lit('x') + 1 > 100)).should == '((x + 1) <= 100)'
-    @d.l(Sequel.lit('x').like('a')).should == '(x LIKE \'a\')'
+    @d.l(Sequel.lit('x').like('a')).should == '(x LIKE \'a\' ESCAPE \'\\\')'
     @d.l(Sequel.lit('x') + 1 > 100).should == '((x + 1) > 100)'
     @d.l((Sequel.lit('x') * :y) < 100.01).should == '((x * y) < 100.01)'
     @d.l((Sequel.lit('x') - Sequel.expr(:y)/2) >= 100000000000000000000000000000000000).should == '((x - (y / 2)) >= 100000000000000000000000000000000000)'
@@ -380,8 +380,8 @@ describe "Blockless Ruby Filters" do
     @d.lit(d.asc).should == '(SELECT a FROM items) ASC'
     @d.lit(d.desc).should == '(SELECT a FROM items) DESC'
 
-    @d.lit(d.like(:b)).should == '((SELECT a FROM items) LIKE b)'
-    @d.lit(d.ilike(:b)).should == '((SELECT a FROM items) ILIKE b)'
+    @d.lit(d.like(:b)).should == '((SELECT a FROM items) LIKE b ESCAPE \'\\\')'
+    @d.lit(d.ilike(:b)).should == '(UPPER((SELECT a FROM items)) LIKE UPPER(b) ESCAPE \'\\\')'
   end
 
   it "should handled emulated char_length function" do
@@ -781,17 +781,17 @@ describe "Sequel core extension replacements" do
   end
 
   it "Sequel.like should use a LIKE expression" do
-    l(Sequel.like('a', 'b'), "('a' LIKE 'b')")
-    l(Sequel.like(:a, :b), "(a LIKE b)")
+    l(Sequel.like('a', 'b'), "('a' LIKE 'b' ESCAPE '\\')")
+    l(Sequel.like(:a, :b), "(a LIKE b ESCAPE '\\')")
     l(Sequel.like(:a, /b/), "(a ~ 'b')")
-    l(Sequel.like(:a, 'c', /b/), "((a LIKE 'c') OR (a ~ 'b'))")
+    l(Sequel.like(:a, 'c', /b/), "((a LIKE 'c' ESCAPE '\\') OR (a ~ 'b'))")
   end
 
   it "Sequel.ilike should use an ILIKE expression" do
-    l(Sequel.ilike('a', 'b'), "('a' ILIKE 'b')")
-    l(Sequel.ilike(:a, :b), "(a ILIKE b)")
+    l(Sequel.ilike('a', 'b'), "(UPPER('a') LIKE UPPER('b') ESCAPE '\\')")
+    l(Sequel.ilike(:a, :b), "(UPPER(a) LIKE UPPER(b) ESCAPE '\\')")
     l(Sequel.ilike(:a, /b/), "(a ~* 'b')")
-    l(Sequel.ilike(:a, 'c', /b/), "((a ILIKE 'c') OR (a ~* 'b'))")
+    l(Sequel.ilike(:a, 'c', /b/), "((UPPER(a) LIKE UPPER('c') ESCAPE '\\') OR (a ~* 'b'))")
   end
 
   it "Sequel.subscript should use an SQL subscript" do
@@ -913,7 +913,7 @@ describe "Sequel::SQL::Wrapper" do
     @ds.literal(s & true).should == "(foo AND 't')"
     @ds.literal(s < 1).should == "(foo < 1)"
     @ds.literal(s.sql_subscript(1)).should == "foo[1]"
-    @ds.literal(s.like('a')).should == "(foo LIKE 'a')"
+    @ds.literal(s.like('a')).should == "(foo LIKE 'a' ESCAPE '\\')"
     @ds.literal(s.as(:a)).should == "foo AS a"
     @ds.literal(s.cast(Integer)).should == "CAST(foo AS integer)"
     @ds.literal(s.desc).should == "foo DESC"
@@ -1009,3 +1009,45 @@ describe "Sequel.delay" do
     proc{Sequel.delay}.should raise_error(Sequel::Error)
   end
 end
+
+describe "Sequel.parse_json" do
+  before do
+    Sequel::JSON = Object.new
+    def (Sequel::JSON).parse(json, opts={})
+      [json, opts]
+    end
+  end
+  after do
+    Sequel.send(:remove_const, :JSON)
+  end
+
+  specify "should parse json correctly" do
+    Sequel.parse_json('[]').should == ['[]', {:create_additions=>false}]
+  end
+end
+
+describe "Sequel::LiteralString" do
+  before do
+    @s = Sequel::LiteralString.new("? = ?")
+  end
+
+  specify "should have lit return self if no arguments" do
+    @s.lit.should equal(@s)
+  end
+
+  specify "should have lit return self if return a placeholder literal string if arguments" do
+    @s.lit(1, 2).should be_a_kind_of(Sequel::SQL::PlaceholderLiteralString)
+    Sequel.mock.literal(@s.lit(1, :a)).should == '1 = a'
+  end
+
+  specify "should have to_sequel_blob convert to blob" do
+    @s.to_sequel_blob.should == @s
+    @s.to_sequel_blob.should be_a_kind_of(Sequel::SQL::Blob)
+  end
+end
+
+describe "Sequel core extensions" do
+  specify "should have Sequel.core_extensions? be false by default" do
+    Sequel.core_extensions?.should be_false
+  end
+end

data/spec/core/mock_adapter_spec.rb

@@ -448,6 +448,10 @@ describe "Sequel Mock Adapter" do
     Sequel.mock(:host=>'postgres').primary_key(:t).should == :id
   end
 
+  specify "should stub out the bound_variable_arg method for postgres" do
+    Sequel.mock(:host=>'postgres').bound_variable_arg(:t, nil).should == :t
+  end
+
   specify "should handle creating tables on oracle" do
     proc{Sequel.mock(:host=>'oracle').create_table(:a){String :b}}.should_not raise_error
   end

data/spec/core/schema_spec.rb

@@ -1393,7 +1393,6 @@ describe "Schema Parser" do
     @db.schema(:"number(10,0)").first.last[:type].should == :integer
     @db.schema(:"numeric(10, 10)").first.last[:type].should == :decimal
     @db.schema(:"decimal(10,1)").first.last[:type].should == :decimal
-    @db.schema(:money).first.last[:type].should == :decimal
     @db.schema(:bytea).first.last[:type].should == :blob
     @db.schema(:blob).first.last[:type].should == :blob
     @db.schema(:image).first.last[:type].should == :blob
@@ -1401,7 +1400,6 @@ describe "Schema Parser" do
     @db.schema(:nvarchar).first.last[:type].should == :string
     @db.schema(:ntext).first.last[:type].should == :string
     @db.schema(:smalldatetime).first.last[:type].should == :datetime
-    @db.schema(:smallmoney).first.last[:type].should == :decimal
     @db.schema(:binary).first.last[:type].should == :blob
     @db.schema(:varbinary).first.last[:type].should == :blob
     @db.schema(:enum).first.last[:type].should == :enum

data/spec/core/spec_helper.rb

@@ -1,5 +1,10 @@
 require 'rubygems'
 
+if ENV['COVERAGE']
+  require File.join(File.dirname(File.expand_path(__FILE__)), "../sequel_coverage")
+  SimpleCov.sequel_coverage(:filter=>%r{lib/sequel/(\w+\.rb|(dataset|database|model|connection_pool)/\w+\.rb|adapters/mock\.rb)\z})
+end
+
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   SEQUEL_NO_CORE_EXTENSIONS = true

data/spec/core_extensions_spec.rb

@@ -1,5 +1,10 @@
 require 'rubygems'
 
+if ENV['COVERAGE']
+  require File.join(File.dirname(File.expand_path(__FILE__)), "sequel_coverage")
+  SimpleCov.sequel_coverage(:filter=>%r{lib/sequel/extensions/core_extensions\.rb\z})
+end
+
 unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel/no_core_ext'
@@ -85,16 +90,16 @@ describe "Core extensions" do
   end
   
   it "should support LIKE via Symbol#like" do
-    @d.l(:x.like('a')).should == '(x LIKE \'a\')'
+    @d.l(:x.like('a')).should == '(x LIKE \'a\' ESCAPE \'\\\')'
     @d.l(:x.like(/a/)).should == '(x ~ \'a\')'
-    @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\') OR (x LIKE \'b\'))'
+    @d.l(:x.like('a', 'b')).should == '((x LIKE \'a\' ESCAPE \'\\\') OR (x LIKE \'b\' ESCAPE \'\\\'))'
     @d.l(:x.like(/a/, /b/i)).should == '((x ~ \'a\') OR (x ~* \'b\'))'
-    @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\') OR (x ~ \'b\'))'
+    @d.l(:x.like('a', /b/)).should == '((x LIKE \'a\' ESCAPE \'\\\') OR (x ~ \'b\'))'
 
-    @d.l('a'.like(:x)).should == "('a' LIKE x)"
-    @d.l('a'.like(:x, 'b')).should == "(('a' LIKE x) OR ('a' LIKE 'b'))"
-    @d.l('a'.like(:x, /b/)).should == "(('a' LIKE x) OR ('a' ~ 'b'))"
-    @d.l('a'.like(:x, /b/i)).should == "(('a' LIKE x) OR ('a' ~* 'b'))"
+    @d.l('a'.like(:x)).should == "('a' LIKE x ESCAPE '\\')"
+    @d.l('a'.like(:x, 'b')).should == "(('a' LIKE x ESCAPE '\\') OR ('a' LIKE 'b' ESCAPE '\\'))"
+    @d.l('a'.like(:x, /b/)).should == "(('a' LIKE x ESCAPE '\\') OR ('a' ~ 'b'))"
+    @d.l('a'.like(:x, /b/i)).should == "(('a' LIKE x ESCAPE '\\') OR ('a' ~* 'b'))"
 
     @d.l(/a/.like(:x)).should == "('a' ~ x)"
     @d.l(/a/.like(:x, 'b')).should == "(('a' ~ x) OR ('a' ~ 'b'))"
@@ -108,16 +113,16 @@ describe "Core extensions" do
   end
 
   it "should support NOT LIKE via Symbol#like and Symbol#~" do
-    @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\')'
+    @d.l(~:x.like('a')).should == '(x NOT LIKE \'a\' ESCAPE \'\\\')'
     @d.l(~:x.like(/a/)).should == '(x !~ \'a\')'
-    @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\') AND (x NOT LIKE \'b\'))'
+    @d.l(~:x.like('a', 'b')).should == '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x NOT LIKE \'b\' ESCAPE \'\\\'))'
     @d.l(~:x.like(/a/, /b/i)).should == '((x !~ \'a\') AND (x !~* \'b\'))'
-    @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\') AND (x !~ \'b\'))'
+    @d.l(~:x.like('a', /b/)).should == '((x NOT LIKE \'a\' ESCAPE \'\\\') AND (x !~ \'b\'))'
 
-    @d.l(~'a'.like(:x)).should == "('a' NOT LIKE x)"
-    @d.l(~'a'.like(:x, 'b')).should == "(('a' NOT LIKE x) AND ('a' NOT LIKE 'b'))"
-    @d.l(~'a'.like(:x, /b/)).should == "(('a' NOT LIKE x) AND ('a' !~ 'b'))"
-    @d.l(~'a'.like(:x, /b/i)).should == "(('a' NOT LIKE x) AND ('a' !~* 'b'))"
+    @d.l(~'a'.like(:x)).should == "('a' NOT LIKE x ESCAPE '\\')"
+    @d.l(~'a'.like(:x, 'b')).should == "(('a' NOT LIKE x ESCAPE '\\') AND ('a' NOT LIKE 'b' ESCAPE '\\'))"
+    @d.l(~'a'.like(:x, /b/)).should == "(('a' NOT LIKE x ESCAPE '\\') AND ('a' !~ 'b'))"
+    @d.l(~'a'.like(:x, /b/i)).should == "(('a' NOT LIKE x ESCAPE '\\') AND ('a' !~* 'b'))"
 
     @d.l(~/a/.like(:x)).should == "('a' !~ x)"
     @d.l(~/a/.like(:x, 'b')).should == "(('a' !~ x) AND ('a' !~ 'b'))"
@@ -131,16 +136,16 @@ describe "Core extensions" do
   end
 
   it "should support ILIKE via Symbol#ilike" do
-    @d.l(:x.ilike('a')).should == '(x ILIKE \'a\')'
+    @d.l(:x.ilike('a')).should == '(UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\')'
     @d.l(:x.ilike(/a/)).should == '(x ~* \'a\')'
-    @d.l(:x.ilike('a', 'b')).should == '((x ILIKE \'a\') OR (x ILIKE \'b\'))'
+    @d.l(:x.ilike('a', 'b')).should == '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (UPPER(x) LIKE UPPER(\'b\') ESCAPE \'\\\'))'
     @d.l(:x.ilike(/a/, /b/i)).should == '((x ~* \'a\') OR (x ~* \'b\'))'
-    @d.l(:x.ilike('a', /b/)).should == '((x ILIKE \'a\') OR (x ~* \'b\'))'
+    @d.l(:x.ilike('a', /b/)).should == '((UPPER(x) LIKE UPPER(\'a\') ESCAPE \'\\\') OR (x ~* \'b\'))'
 
-    @d.l('a'.ilike(:x)).should == "('a' ILIKE x)"
-    @d.l('a'.ilike(:x, 'b')).should == "(('a' ILIKE x) OR ('a' ILIKE 'b'))"
-    @d.l('a'.ilike(:x, /b/)).should == "(('a' ILIKE x) OR ('a' ~* 'b'))"
-    @d.l('a'.ilike(:x, /b/i)).should == "(('a' ILIKE x) OR ('a' ~* 'b'))"
+    @d.l('a'.ilike(:x)).should == "(UPPER('a') LIKE UPPER(x) ESCAPE '\\')"
+    @d.l('a'.ilike(:x, 'b')).should == "((UPPER('a') LIKE UPPER(x) ESCAPE '\\') OR (UPPER('a') LIKE UPPER('b') ESCAPE '\\'))"
+    @d.l('a'.ilike(:x, /b/)).should == "((UPPER('a') LIKE UPPER(x) ESCAPE '\\') OR ('a' ~* 'b'))"
+    @d.l('a'.ilike(:x, /b/i)).should == "((UPPER('a') LIKE UPPER(x) ESCAPE '\\') OR ('a' ~* 'b'))"
 
     @d.l(/a/.ilike(:x)).should == "('a' ~* x)"
     @d.l(/a/.ilike(:x, 'b')).should == "(('a' ~* x) OR ('a' ~* 'b'))"
@@ -154,16 +159,16 @@ describe "Core extensions" do
   end
 
   it "should support NOT ILIKE via Symbol#ilike and Symbol#~" do
-    @d.l(~:x.ilike('a')).should == '(x NOT ILIKE \'a\')'
+    @d.l(~:x.ilike('a')).should == '(UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\')'
     @d.l(~:x.ilike(/a/)).should == '(x !~* \'a\')'
-    @d.l(~:x.ilike('a', 'b')).should == '((x NOT ILIKE \'a\') AND (x NOT ILIKE \'b\'))'
+    @d.l(~:x.ilike('a', 'b')).should == '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (UPPER(x) NOT LIKE UPPER(\'b\') ESCAPE \'\\\'))'
     @d.l(~:x.ilike(/a/, /b/i)).should == '((x !~* \'a\') AND (x !~* \'b\'))'
-    @d.l(~:x.ilike('a', /b/)).should == '((x NOT ILIKE \'a\') AND (x !~* \'b\'))'
+    @d.l(~:x.ilike('a', /b/)).should == '((UPPER(x) NOT LIKE UPPER(\'a\') ESCAPE \'\\\') AND (x !~* \'b\'))'
 
-    @d.l(~'a'.ilike(:x)).should == "('a' NOT ILIKE x)"
-    @d.l(~'a'.ilike(:x, 'b')).should == "(('a' NOT ILIKE x) AND ('a' NOT ILIKE 'b'))"
-    @d.l(~'a'.ilike(:x, /b/)).should == "(('a' NOT ILIKE x) AND ('a' !~* 'b'))"
-    @d.l(~'a'.ilike(:x, /b/i)).should == "(('a' NOT ILIKE x) AND ('a' !~* 'b'))"
+    @d.l(~'a'.ilike(:x)).should == "(UPPER('a') NOT LIKE UPPER(x) ESCAPE '\\')"
+    @d.l(~'a'.ilike(:x, 'b')).should == "((UPPER('a') NOT LIKE UPPER(x) ESCAPE '\\') AND (UPPER('a') NOT LIKE UPPER('b') ESCAPE '\\'))"
+    @d.l(~'a'.ilike(:x, /b/)).should == "((UPPER('a') NOT LIKE UPPER(x) ESCAPE '\\') AND ('a' !~* 'b'))"
+    @d.l(~'a'.ilike(:x, /b/i)).should == "((UPPER('a') NOT LIKE UPPER(x) ESCAPE '\\') AND ('a' !~* 'b'))"
 
     @d.l(~/a/.ilike(:x)).should == "('a' !~* x)"
     @d.l(~/a/.ilike(:x, 'b')).should == "(('a' !~* x) AND ('a' !~* 'b'))"