sequel 3.28.0 → 3.29.0

data/spec/integration/spec_helper.rb

@@ -16,11 +16,6 @@ end
 
 Sequel::Model.use_transactions = false
 
-$sqls = []
-def clear_sqls
-  $sqls.clear
-end 
-
 unless defined?(RSpec)
   module Spec::Matchers
     class BeWithin
@@ -34,46 +29,45 @@ unless defined?(RSpec)
   end
 end
 
-(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
-  def log
-    begin
-      INTEGRATION_DB.loggers << Logger.new(STDOUT)
-      yield
-    ensure
-     INTEGRATION_DB.loggers.pop
-    end
-  end
-  
-  def self.log_specify(message, &block)
-    specify(message){log{instance_eval(&block)}}
-  end
-
-  def self.cspecify(message, *checked, &block)
-    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
-    pending = false
+def Sequel.guarded?(*checked)
+  unless ENV['SEQUEL_NO_PENDING']
     checked.each do |c|
       case c
       when INTEGRATION_DB.database_type
-        pending = c
+        return c
       when Array
         case c.length
         when 1
-          pending = c if c.first == INTEGRATION_DB.adapter_scheme
+          return c if c.first == INTEGRATION_DB.adapter_scheme
         when 2
           if c.first.is_a?(Proc)
-            pending = c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
+            return c if c.first.call(INTEGRATION_DB) && c.last == INTEGRATION_DB.database_type
           elsif c.last.is_a?(Proc)
-            pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last.call(INTEGRATION_DB)
+            return c if c.first == INTEGRATION_DB.adapter_scheme && c.last.call(INTEGRATION_DB)
           else
-            pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.database_type
+            return c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.database_type
           end
         when 3
-          pending = c if c[0] == INTEGRATION_DB.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
+          return c if c[0] == INTEGRATION_DB.adapter_scheme && c[1] == INTEGRATION_DB.database_type && c[2].call(INTEGRATION_DB)
         end          
       end
-      break if pending
     end
-    if pending
+  end
+  false
+end
+
+(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
+  def log
+    begin
+      INTEGRATION_DB.loggers << Logger.new(STDOUT)
+      yield
+    ensure
+     INTEGRATION_DB.loggers.pop
+    end
+  end
+  
+  def self.cspecify(message, *checked, &block)
+    if pending = Sequel.guarded?(*checked)
       specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
     else
       specify(message, &block)
@@ -88,7 +82,7 @@ if defined?(INTEGRATION_DB) || defined?(INTEGRATION_URL) || ENV['SEQUEL_INTEGRAT
     #INTEGRATION_DB.instance_variable_set(:@server_version, 80100)
   end
 else
-  INTEGRATION_DB = Sequel.sqlite('', :quote_identifiers=>false)
+  INTEGRATION_DB = Sequel.sqlite
 end
 
 if INTEGRATION_DB.adapter_scheme == :ibmdb

data/spec/integration/timezone_test.rb

@@ -1,15 +1,17 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Sequel timezone support" do
-  def test_timezone
+  def test_timezone(timezone=Sequel.application_timezone)
+    tz = timezone
+    Sequel.datetime_class = Time
     # Tests should cover both DST and non-DST times.
     [Time.now, Time.local(2010,1,1,12), Time.local(2010,6,1,12)].each do |t|
       @db[:t].insert(t)
       t2 = @db[:t].single_value
-      t2 = Sequel.database_to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
+      t2 = @db.to_application_timestamp(t2.to_s) unless t2.is_a?(Time)
       (t2 - t).should be_within(2).of(0)
-      t2.utc_offset.should == 0 if Sequel.application_timezone == :utc
-      t2.utc_offset.should == t.getlocal.utc_offset if Sequel.application_timezone == :local
+      t2.utc_offset.should == 0 if timezone == :utc
+      t2.utc_offset.should == t.getlocal.utc_offset if timezone == :local
       @db[:t].delete
     end
 
@@ -19,10 +21,10 @@ describe "Sequel timezone support" do
     [DateTime.now, DateTime.civil(2010,1,1,12,0,0,local_std_offset), DateTime.civil(2010,6,1,12,0,0,local_dst_offset)].each do |dt|
       @db[:t].insert(dt)
       dt2 = @db[:t].single_value
-      dt2 = Sequel.database_to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
+      dt2 = @db.to_application_timestamp(dt2.to_s) unless dt2.is_a?(DateTime)
       (dt2 - dt).should be_within(0.00002).of(0)
-      dt2.offset.should == 0 if Sequel.application_timezone == :utc
-      dt2.offset.should == dt.offset if Sequel.application_timezone == :local
+      dt2.offset.should == 0 if timezone == :utc
+      dt2.offset.should == dt.offset if timezone == :local
       @db[:t].delete
     end
   end
@@ -32,30 +34,54 @@ describe "Sequel timezone support" do
     @db.create_table!(:t){DateTime :t}
   end
   after do
-    @db.drop_table(:t)
+    @db.timezone = nil
     Sequel.default_timezone = nil
     Sequel.datetime_class = Time
+    @db.drop_table(:t)
   end
 
-  cspecify "should support using UTC for database storage and local time for the application", [:swift], [:tinytds], [:do, proc{|db| db.database_type != :sqlite}] do
+  cspecify "should support using UTC for database storage and local time for the application", [:swift], [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
     test_timezone
+    Sequel.database_timezone = nil
+    @db.timezone = :utc
+    test_timezone
   end
 
-  cspecify "should support using local time for database storage and UTC for the application", [:swift], [:tinytds], [:do, proc{|db| db.database_type != :sqlite}] do
+  cspecify "should support using local time for database storage and UTC for the application", [:swift], [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
     test_timezone
+    Sequel.database_timezone = nil
+    @db.timezone = :local
+    test_timezone
   end
 
-  cspecify "should support using UTC for both database storage and for application", [:swift], [:do, proc{|db| db.database_type != :sqlite}] do
+  cspecify "should support using UTC for both database storage and for application", [:swift], [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.default_timezone = :utc
     test_timezone
+    Sequel.database_timezone = :local
+    @db.timezone = :utc
+    test_timezone
   end
 
-  cspecify "should support using local time for both database storage and for application", [:do, proc{|db| db.database_type != :sqlite}] do
+  cspecify "should support using local time for both database storage and for application", [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.default_timezone = :local
     test_timezone
+    Sequel.database_timezone = :utc
+    @db.timezone = :local
+    test_timezone
+  end
+
+  specify "should allow overriding the database_timezone on a per-database basis" do
+    Sequel.database_timezone = :utc
+    @db.timezone = :local
+    t = Time.now
+    @db[:t].insert(t)
+    s = @db[:t].get(:t.cast(String))
+    if o = Date._parse(s)[:offset]
+      o.should == t.utc_offset
+    end
   end
 end

data/spec/integration/transaction_test.rb

@@ -1,14 +1,16 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Database transactions" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.drop_table(:items) if @db.table_exists?(:items)
     @db.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
     @d = @db[:items]
-    clear_sqls
   end
-  after do
+  before do
+    @d.delete
+  end
+  after(:all) do
     @db.drop_table(:items) if @db.table_exists?(:items)
   end
 
@@ -21,6 +23,13 @@ describe "Database transactions" do
     @db.transaction{|conn| conn.should_not == nil}
   end
 
+  specify "should have #in_transaction? work correctly" do
+    @db.in_transaction?.should be_false
+    c = nil
+    @db.transaction{c = @db.in_transaction?}
+    c.should be_true
+  end
+
   specify "should correctly rollback transactions" do
     proc do
       @db.transaction do
@@ -29,12 +38,22 @@ describe "Database transactions" do
       end
     end.should raise_error(Interrupt)
 
+    @db.transaction do
+      @d << {:name => 'abc', :value => 1}
+      raise Sequel::Rollback
+    end.should be_nil
+
     proc do
-      @db.transaction do
+      @db.transaction(:rollback=>:reraise) do
         @d << {:name => 'abc', :value => 1}
         raise Sequel::Rollback
       end
-    end.should_not raise_error
+    end.should raise_error(Sequel::Rollback)
+
+    @db.transaction(:rollback=>:always) do
+      @d << {:name => 'abc', :value => 1}
+      2
+    end.should be_nil
 
     @d.count.should == 0
   end
@@ -126,6 +145,14 @@ describe "Database transactions" do
       @db.rollback_prepared_transaction('XYZ')
       @d.select_order_map(:name).should == []
     end
+
+    if INTEGRATION_DB.supports_savepoints?
+      specify "should support savepoints when using prepared transactions" do
+        @db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@d << {:name => '1'}}}
+        @db.commit_prepared_transaction('XYZ')
+        @d.select_order_map(:name).should == ['1']
+      end
+    end
   end
 
   specify "should support all transaction isolation levels" do
@@ -135,43 +162,143 @@ describe "Database transactions" do
     end
   end
 
-if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' && ![[:do, :sqlite], [:tinytds, :mssql]].include?([INTEGRATION_DB.adapter_scheme, INTEGRATION_DB.database_type]))) and RUBY_VERSION < '1.9'
-  specify "should handle Thread#kill for transactions inside threads" do
-    q = Queue.new
-    q1 = Queue.new
-    t = Thread.new do
-      @db.transaction do
-        @d << {:name => 'abc', :value => 1}
-        q1.push nil
-        q.pop
-        @d << {:name => 'def', :value => 2}
+  specify "should support after_commit outside transactions" do
+    c = nil
+    @db.after_commit{c = 1}
+    c.should == 1
+  end
+
+  specify "should support after_rollback outside transactions" do
+    c = nil
+    @db.after_rollback{c = 1}
+    c.should be_nil
+  end
+
+  specify "should support after_commit inside transactions" do
+    c = nil
+    @db.transaction{@db.after_commit{c = 1}; c.should be_nil}
+    c.should == 1
+  end
+
+  specify "should support after_rollback inside transactions" do
+    c = nil
+    @db.transaction{@db.after_rollback{c = 1}; c.should be_nil}
+    c.should be_nil
+  end
+
+  specify "should not call after_commit if the transaction rolls back" do
+    c = nil
+    @db.transaction{@db.after_commit{c = 1}; c.should be_nil; raise Sequel::Rollback}
+    c.should be_nil
+  end
+
+  specify "should call after_rollback if the transaction rolls back" do
+    c = nil
+    @db.transaction{@db.after_rollback{c = 1}; c.should be_nil; raise Sequel::Rollback}
+    c.should == 1
+  end
+
+  specify "should support multiple after_commit blocks inside transactions" do
+    c = []
+    @db.transaction{@db.after_commit{c << 1}; @db.after_commit{c << 2}; c.should == []}
+    c.should == [1, 2]
+  end
+
+  specify "should support multiple after_rollback blocks inside transactions" do
+    c = []
+    @db.transaction{@db.after_rollback{c << 1}; @db.after_rollback{c << 2}; c.should == []; raise Sequel::Rollback}
+    c.should == [1, 2]
+  end
+
+  specify "should support after_commit inside nested transactions" do
+    c = nil
+    @db.transaction{@db.transaction{@db.after_commit{c = 1}}; c.should be_nil}
+    c.should == 1
+  end
+
+  specify "should support after_rollback inside nested transactions" do
+    c = nil
+    @db.transaction{@db.transaction{@db.after_rollback{c = 1}}; c.should be_nil; raise Sequel::Rollback}
+    c.should == 1
+  end
+
+  if INTEGRATION_DB.supports_savepoints?
+    specify "should support after_commit inside savepoints" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit{c = 1}}; c.should be_nil}
+      c.should == 1
+    end
+
+    specify "should support after_rollback inside savepoints" do
+      c = nil
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.should be_nil; raise Sequel::Rollback}
+      c.should == 1
+    end
+  end
+
+  if INTEGRATION_DB.supports_prepared_transactions?
+    specify "should raise an error if you attempt to use after_commit or after_rollback inside a prepared transaction" do
+      proc{@db.transaction(:prepare=>'XYZ'){@db.after_commit{}}}.should raise_error(Sequel::Error)
+      proc{@db.transaction(:prepare=>'XYZ'){@db.after_rollback{}}}.should raise_error(Sequel::Error)
+    end
+
+    if INTEGRATION_DB.supports_savepoints?
+      specify "should raise an error if you attempt to use after_commit or after rollback inside a savepoint in a prepared transaction" do
+        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_commit{}}}}.should raise_error(Sequel::Error)
+        proc{@db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@db.after_rollback{}}}}.should raise_error(Sequel::Error)
       end
     end
-    q1.pop
-    t.kill
-    @d.count.should == 0
   end
+end
 
-if INTEGRATION_DB.supports_savepoints?
-  specify "should handle Thread#kill for transactions with savepoints inside threads" do
-    q = Queue.new
-    q1 = Queue.new
-    t = Thread.new do
-      @db.transaction do
-        @d << {:name => 'abc', :value => 1}
-        @db.transaction(:savepoint=>true) do
-          @d << {:name => 'def', :value => 2}
+if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' && !Sequel.guarded?([:do, :sqlite], [:tinytds, :mssql]))) and RUBY_VERSION < '1.9'
+  describe "Database transactions and Thread#kill" do
+    before do
+      @db = INTEGRATION_DB
+      @db.drop_table(:items) if @db.table_exists?(:items)
+      @db.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
+      @d = @db[:items]
+    end
+    after do
+      @db.drop_table(:items) if @db.table_exists?(:items)
+    end
+
+    specify "should handle transactions inside threads" do
+      q = Queue.new
+      q1 = Queue.new
+      t = Thread.new do
+        @db.transaction do
+          @d << {:name => 'abc', :value => 1}
           q1.push nil
           q.pop
-          @d << {:name => 'ghi', :value => 3}
+          @d << {:name => 'def', :value => 2}
         end
-        @d << {:name => 'jkl', :value => 4}
+      end
+      q1.pop
+      t.kill
+      @d.count.should == 0
+    end
+
+    if INTEGRATION_DB.supports_savepoints?
+      specify "should handle transactions with savepoints inside threads" do
+        q = Queue.new
+        q1 = Queue.new
+        t = Thread.new do
+          @db.transaction do
+            @d << {:name => 'abc', :value => 1}
+            @db.transaction(:savepoint=>true) do
+              @d << {:name => 'def', :value => 2}
+              q1.push nil
+              q.pop
+              @d << {:name => 'ghi', :value => 3}
+            end
+            @d << {:name => 'jkl', :value => 4}
+          end
+        end
+        q1.pop
+        t.kill
+        @d.count.should == 0
       end
     end
-    q1.pop
-    t.kill
-    @d.count.should == 0
   end
 end
-end
-end

data/spec/integration/type_test.rb

@@ -60,7 +60,7 @@ describe "Supported types" do
     ds.all.should == [{:name=>'Test User'}]
   end
   
-  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], :mssql do
+  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], :mssql, :oracle do
     ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
@@ -68,7 +68,7 @@ describe "Supported types" do
     ds.first[:dat].to_s.should == d.to_s
   end
   
-  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :postgres], [:mysql2], [:tinytds] do
+  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :postgres], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle do
     ds = create_items_table_with_column(:tim, Time, :only_time=>true)
     t = Sequel::SQLTime.now
     ds.insert(:tim => t)
@@ -100,7 +100,7 @@ describe "Supported types" do
     ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql] do
+  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql], :oracle do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
     ds.all.should == [{:number=>true}]