sequel 3.21.0 → 3.39.0

data/spec/integration/spec_helper.rb

@@ -2,19 +2,20 @@ require 'rubygems'
 require 'logger'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  require 'sequel'
+  require 'sequel/no_core_ext'
 end
 begin
   require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb') unless defined?(INTEGRATION_DB)
 rescue LoadError
 end
 
-Sequel::Model.use_transactions = false
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
 
-$sqls = []
-def clear_sqls
-  $sqls.clear
-end 
+Sequel::Model.use_transactions = false
+Sequel::Model.cache_anonymous_models = false
 
 unless defined?(RSpec)
   module Spec::Matchers
@@ -29,46 +30,46 @@ 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)
-    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.last == INTEGRATION_DB.database_type && c.first.call(INTEGRATION_DB)
           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
-      specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
+  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).map{|x| x.is_a?(Proc) ? :proc : x}.join(', ')}", &block)}
     else
       specify(message, &block)
     end
@@ -82,5 +83,14 @@ 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
+  def INTEGRATION_DB.drop_table(*tables)
+    super
+  rescue Sequel::DatabaseError
+    disconnect
+    super
+  end
 end

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", [: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], [:swift, :postgres], [:swift, :mysql] 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(Sequel.cast(:t, String))
+    if o = Date._parse(s)[:offset]
+      o.should == t.utc_offset
+    end
   end
 end

data/spec/integration/transaction_test.rb

@@ -1,15 +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}
+    @db.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
     @d = @db[:items]
-    clear_sqls
   end
-  after do
-    @db.drop_table(:items) if @db.table_exists?(:items)
+  before do
+    @d.delete
+  end
+  after(:all) do
+    @db.drop_table?(:items)
   end
 
   specify "should support transactions" do
@@ -21,6 +22,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 +37,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
@@ -115,6 +133,16 @@ describe "Database transactions" do
   end
 
   if INTEGRATION_DB.supports_prepared_transactions?
+    specify "should allow saving and destroying of model objects" do
+      c = Class.new(Sequel::Model(@d))
+      c.set_primary_key :name
+      c.unrestrict_primary_key
+      c.use_after_commit_rollback = false
+      @db.transaction(:prepare=>'XYZ'){c.create(:name => '1'); c.create(:name => '2').destroy}
+      @db.commit_prepared_transaction('XYZ')
+      @d.select_order_map(:name).should == ['1']
+    end
+
     specify "should commit prepared transactions using commit_prepared_transaction" do
       @db.transaction(:prepare=>'XYZ'){@d << {:name => '1'}}
       @db.commit_prepared_transaction('XYZ')
@@ -126,6 +154,14 @@ describe "Database transactions" do
       @db.rollback_prepared_transaction('XYZ')
       @d.select_order_map(:name).should == []
     end
+
+    if INTEGRATION_DB.supports_savepoints_in_prepared_transactions?
+      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
@@ -134,4 +170,143 @@ describe "Database transactions" do
       @d.count.should == i + 1
     end
   end
+
+  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_in_prepared_transactions?
+      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
+  end
+end
+
+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.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
+      @d = @db[:items]
+    end
+    after do
+      @db.drop_table?(: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 => 'def', :value => 2}
+        end
+      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
+  end
 end

data/spec/integration/type_test.rb

@@ -6,13 +6,13 @@ describe "Supported types" do
     INTEGRATION_DB[:items]
   end
 
-  cspecify "should support casting correctly", [:sqlite, :sqlite] do
+  specify "should support casting correctly" do
     ds = create_items_table_with_column(:number, Integer)
     ds.insert(:number => 1)
-    ds.select(:number.cast_string.as(:n)).map(:n).should == %w'1'
+    ds.select(Sequel.cast(:number, String).as(:n)).map(:n).should == %w'1'
     ds = create_items_table_with_column(:name, String)
     ds.insert(:name=> '1')
-    ds.select(:name.cast_numeric.as(:n)).map(:n).should == [1]
+    ds.select(Sequel.cast(:name, Integer).as(:n)).map(:n).should == [1]
   end
 
   specify "should support NULL correctly" do
@@ -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,6 +68,20 @@ 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, :sqlite], [:mysql2], [:tinytds], :oracle do
+    ds = create_items_table_with_column(:tim, Time, :only_time=>true)
+    t = Sequel::SQLTime.now
+    ds.insert(:tim => t)
+    v = ds.first[:tim]
+    ds.literal(v).should == ds.literal(t)
+    v.should be_a_kind_of(Sequel::SQLTime)
+    ds.delete
+    ds.insert(:tim => v)
+    v2 = ds.first[:tim]
+    ds.literal(v2).should == ds.literal(t)
+    v2.should be_a_kind_of(Sequel::SQLTime)
+  end
+  
   cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
     ds = create_items_table_with_column(:tim, DateTime)
     t = DateTime.now
@@ -79,14 +93,14 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').should == t.strftime('%Y%m%d%H%M%S')
   end
   
-  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:swift], [:tinytds] do
+  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:tinytds] do
     ds = create_items_table_with_column(:name, File)
-    ds.insert(:name => ("a\0"*300).to_sequel_blob)
-    ds.all.should == [{:name=>("a\0"*300).to_sequel_blob}]
+    ds.insert(:name =>Sequel.blob("a\0"*300))
+    ds.all.should == [{:name=>Sequel.blob("a\0"*300)}]
     ds.first[:name].should be_a_kind_of(::Sequel::SQL::Blob)
   end
   
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [: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}]
@@ -94,4 +108,13 @@ describe "Supported types" do
     ds.insert(:number => true)
     ds.all.should == [{:number=>true}]
   end
+  
+  cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], [:odbc, :mssql], :oracle do
+    ds = create_items_table_with_column(:number, TrueClass, :default=>true)
+    ds.insert
+    ds.all.should == [{:number=>true}]
+    ds = create_items_table_with_column(:number, FalseClass, :default=>false)
+    ds.insert
+    ds.all.should == [{:number=>false}]
+  end
 end