sequel 4.47.0 → 4.48.0

data/spec/adapters/oracle_spec.rb

@@ -117,17 +117,17 @@ describe "An Oracle database" do
 
   it "should return the correct record count" do
     @d.count.must_equal 0
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.count.must_equal 3
   end
   
   it "should return the correct records" do
     @d.to_a.must_equal []
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
 
     @d.order(:value).to_a.must_equal [
       {:date_created=>nil, :name => 'abc', :value => 123},
@@ -214,9 +214,9 @@ describe "An Oracle database" do
   end
   
   it "should update records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter(:name => 'abc').update(:value => 530)
     
     @d[:name => 'def'][:value].must_equal 789
@@ -224,17 +224,17 @@ describe "An Oracle database" do
   end
 
   it "should translate values correctly" do
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter{value > 500}.update(:date_created => Sequel.lit("to_timestamp('2009-09-09', 'YYYY-MM-DD')"))
     
     @d[:name => 'def'][:date_created].strftime('%F').must_equal '2009-09-09'
   end
   
   it "should delete records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter(:name => 'abc').delete
     
     @d.count.must_equal 1
@@ -248,7 +248,7 @@ describe "An Oracle database" do
   
   it "should support transactions" do
     DB.transaction do
-      @d << {:name => 'abc', :value => 1}
+      @d.insert(:name => 'abc', :value => 1)
     end
 
     @d.count.must_equal 1
@@ -257,15 +257,15 @@ describe "An Oracle database" do
   it "should return correct result" do
     @d1 = DB[:books]
     @d1.delete
-    @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
-    @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
-    @d1 << {:id => 3, :title => 'ccc', :category_id => 101}
-    @d1 << {:id => 4, :title => 'ddd', :category_id => 102}
+    @d1.insert(:id => 1, :title => 'aaa', :category_id => 100)
+    @d1.insert(:id => 2, :title => 'bbb', :category_id => 100)
+    @d1.insert(:id => 3, :title => 'ccc', :category_id => 101)
+    @d1.insert(:id => 4, :title => 'ddd', :category_id => 102)
     
     @d2 = DB[:categories]
     @d2.delete
-    @d2 << {:id => 100, :cat_name => 'ruby'}
-    @d2 << {:id => 101, :cat_name => 'rails'}
+    @d2.insert(:id => 100, :cat_name => 'ruby')
+    @d2.insert(:id => 101, :cat_name => 'rails')
   
     @d1.join(:categories, :id => :category_id).select(Sequel[:books][:id], :title, :cat_name).order(Sequel[:books][:id]).to_a.must_equal [
       {:id => 1, :title => 'aaa', :cat_name => 'ruby'},
@@ -294,9 +294,9 @@ describe "An Oracle database" do
   it "should allow columns to be renamed" do
     @d1 = DB[:books]
     @d1.delete
-    @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
-    @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
-    @d1 << {:id => 3, :title => 'bbb', :category_id => 100}
+    @d1.insert(:id => 1, :title => 'aaa', :category_id => 100)
+    @d1.insert(:id => 2, :title => 'bbb', :category_id => 100)
+    @d1.insert(:id => 3, :title => 'bbb', :category_id => 100)
 
     @d1.select(Sequel.as(:title, :name)).order_by(:id).to_a.must_equal [
       { :name => 'aaa' },

data/spec/adapters/postgres_spec.rb

@@ -4,6 +4,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 uses_pg = Sequel::Postgres::USES_PG if DB.adapter_scheme == :postgres
 uses_pg_or_jdbc = uses_pg || DB.adapter_scheme == :jdbc
+# SEQUEL5: Remove native handling
 
 def DB.sqls
   (@sqls ||= [])
@@ -445,16 +446,16 @@ describe "A PostgreSQL dataset" do
   end
 
   it "should support regexps" do
-    @d << {:name => 'abc', :value => 1}
-    @d << {:name => 'bcd', :value => 2}
+    @d.insert(:name => 'abc', :value => 1)
+    @d.insert(:name => 'bcd', :value => 2)
     @d.filter(:name => /bc/).count.must_equal 2
     @d.filter(:name => /^bc/).count.must_equal 1
   end
 
   it "should support NULLS FIRST and NULLS LAST" do
-    @d << {:name => 'abc'}
-    @d << {:name => 'bcd'}
-    @d << {:name => 'bcd', :value => 2}
+    @d.insert(:name => 'abc')
+    @d.insert(:name => 'bcd')
+    @d.insert(:name => 'bcd', :value => 2)
     @d.order(Sequel.asc(:value, :nulls=>:first), :name).select_map(:name).must_equal %w[abc bcd bcd]
     @d.order(Sequel.asc(:value, :nulls=>:last), :name).select_map(:name).must_equal %w[bcd abc bcd]
     @d.order(Sequel.asc(:value, :nulls=>:first), :name).reverse.select_map(:name).must_equal %w[bcd bcd abc]
@@ -681,12 +682,12 @@ describe "A PostgreSQL dataset" do
   end
 
   it "should truncate with options" do
-    @d << { :name => 'abc', :value => 1}
+    @d.insert( :name => 'abc', :value => 1)
     @d.count.must_equal 1
     @d.truncate(:cascade => true)
     @d.count.must_equal 0
     if @d.db.server_version > 80400
-      @d << { :name => 'abc', :value => 1}
+      @d.insert( :name => 'abc', :value => 1)
       @d.truncate(:cascade => true, :only=>true, :restart=>true)
       @d.count.must_equal 0
     end
@@ -802,7 +803,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
   cspecify "should store milliseconds in time fields for Time objects", [:do], [:swift] do
     t = Time.now
-    @d << {:time=>t}
+    @d.insert(:time=>t)
     t2 = @d.get(:time)
     @d.literal(t2).must_equal @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').must_equal t.strftime('%Y-%m-%d %H:%M:%S')
@@ -811,7 +812,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
   cspecify "should store milliseconds in time fields for DateTime objects", [:do], [:swift] do
     t = DateTime.now
-    @d << {:time=>t}
+    @d.insert(:time=>t)
     t2 = @d.get(:time)
     @d.literal(t2).must_equal @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').must_equal t.strftime('%Y-%m-%d %H:%M:%S')
@@ -820,7 +821,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
 
   if DB.adapter_scheme == :postgres
     it "should handle infinite timestamps if convert_infinite_timestamps is set" do
-      @d << {:time=>Sequel.cast('infinity', DateTime)}
+      @d.insert(:time=>Sequel.cast('infinity', DateTime))
       @db.convert_infinite_timestamps = :nil
       @db[:test3].get(:time).must_be_nil
       @db.convert_infinite_timestamps = :string
@@ -863,7 +864,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
     end
 
     it "should handle infinite dates if convert_infinite_timestamps is set" do
-      @d << {:date=>Sequel.cast('infinity', Date)}
+      @d.insert(:date=>Sequel.cast('infinity', Date))
       @db.convert_infinite_timestamps = :nil
       @db[:test3].get(:date).must_be_nil
       @db.convert_infinite_timestamps = :string
@@ -916,12 +917,12 @@ describe "A PostgreSQL database" do
 
   it "should support column operations" do
     @db.create_table!(:test2){text :name; integer :value}
-    @db[:test2] << {}
+    @db[:test2].insert({})
     @db[:test2].columns.must_equal [:name, :value]
 
     @db.add_column :test2, :xyz, :text, :default => '000'
     @db[:test2].columns.must_equal [:name, :value, :xyz]
-    @db[:test2] << {:name => 'mmm', :value => 111}
+    @db[:test2].insert(:name => 'mmm', :value => 111)
     @db[:test2].first[:xyz].must_equal '000'
 
     @db[:test2].columns.must_equal [:name, :value, :xyz]
@@ -931,7 +932,7 @@ describe "A PostgreSQL database" do
 
     @db[:test2].delete
     @db.add_column :test2, :xyz, :text, :default => '000'
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz => 'qqqq')
 
     @db[:test2].columns.must_equal [:name, :value, :xyz]
     @db.rename_column :test2, :xyz, :zyx
@@ -940,7 +941,7 @@ describe "A PostgreSQL database" do
 
     @db.add_column :test2, :xyz, :float
     @db[:test2].delete
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz => 56.78)
     @db.set_column_type :test2, :xyz, :integer
 
     @db[:test2].first[:xyz].must_equal 57
@@ -1517,19 +1518,19 @@ if DB.server_version >= 80300
 
     it "should search by indexed column" do
       record =  {:title => "oopsla conference", :body => "test"}
-      @ds << record
+      @ds.insert(record)
       @ds.full_text_search(:title, "oopsla").all.must_include(record)
     end
 
     it "should join multiple coumns with spaces to search by last words in row" do
       record = {:title => "multiple words", :body => "are easy to search"}
-      @ds << record
+      @ds.insert(record)
       @ds.full_text_search([:title, :body], "words").all.must_include(record)
     end
 
     it "should return rows with a NULL in one column if a match in another column" do
       record = {:title => "multiple words", :body =>nil}
-      @ds << record
+      @ds.insert(record)
       @ds.full_text_search([:title, :body], "words").all.must_include(record)
     end
   end
@@ -1781,7 +1782,7 @@ if DB.adapter_scheme == :postgres
     before(:all) do
       deprecated do
         @db = DB
-        @old_cp = @db.conversion_procs[1013]
+        @cp = @db.conversion_procs.dup
         @db.conversion_procs.delete(1013)
         Sequel::Postgres::PG_NAMED_TYPES[:oidvector] = lambda{|v| v.reverse}
         @db.reset_conversion_procs
@@ -1791,8 +1792,7 @@ if DB.adapter_scheme == :postgres
     after(:all) do
       deprecated do
         Sequel::Postgres::PG_NAMED_TYPES.delete(:oidvector)
-        @db.conversion_procs.delete(30)
-        @db.conversion_procs[1013] = @old_cp
+        @db.conversion_procs.replace(@cp)
         @db.drop_table?(:foo)
         @db.drop_enum(:foo_enum) rescue nil
       end
@@ -1961,6 +1961,18 @@ if uses_pg_or_jdbc && DB.server_version >= 90000
       buf.must_equal ["1,2\n"]
       @db[:test_copy].select_order_map(:x).must_equal [1, 3]
     end
+
+    it "should not swallow error raised by block" do
+      begin
+        @db.copy_table(:test_copy){|b| raise ArgumentError, "foo"}
+      rescue => e
+      end
+
+      e.must_be_kind_of Sequel::DatabaseDisconnectError
+      e.wrapped_exception.must_be_kind_of ArgumentError
+      e.message.must_include "foo"
+    end
+
   end
 end
 
@@ -3375,7 +3387,7 @@ describe 'PostgreSQL interval types' do
     @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after(:all) do
-    Sequel::Postgres::PG_TYPES.delete(1186)
+    Sequel::Postgres::PG__TYPES.delete(1186) # SEQUEL5: Remove
   end
   after do
     @db.drop_table?(:items)
@@ -3487,16 +3499,18 @@ describe 'PostgreSQL row-valued/composite types' do
       Integer :id
       column :employees, 'person[]'
     end
+    oids = @db.conversion_procs.keys
     @db.register_row_type(:address)
     @db.register_row_type(Sequel.qualify(:public, :person))
     @db.register_row_type(Sequel[:public][:company])
+    @new_oids = @db.conversion_procs.keys - oids
 
     @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after(:all) do
-    @db.drop_table?(:company, :person, :address)
+    @new_oids.each{|oid| @db.conversion_procs.delete(oid)}
     @db.row_types.clear
-    @db.reset_conversion_procs if @native
+    @db.drop_table?(:company, :person, :address)
   end
   after do
     [:company, :person, :address].each{|t| @db[t].delete}

data/spec/adapters/sqlanywhere_spec.rb

@@ -6,73 +6,66 @@ if DB.table_exists?(:test)
   DB.drop_table(:test)
 end
 
-describe "Convert smallint to boolean" do
+describe "convert_smallint_to_bool" do
   before do
     @db = DB
+    @ds = @db[:booltest]
+    @db.send(:remove_instance_variable, :@convert_smallint_to_bool) if @db.instance_variable_defined?(:@convert_smallint_to_bool)
   end
   after do
-    Sequel::SqlAnywhere.convert_smallint_to_bool = true
-    @db.convert_smallint_to_bool = true
+    deprecated do
+      Sequel::SqlAnywhere.convert_smallint_to_bool = true
+    end
+    @db.send(:remove_instance_variable, :@convert_smallint_to_bool) if @db.instance_variable_defined?(:@convert_smallint_to_bool)
   end
   
+  # SEQUEL5: Remove
   describe "Sequel::SqlAnywhere.convert_smallint_to_bool" do
     before do
       @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
-      @ds = @db[:booltest]
     end
     after do
       @db.drop_table(:booltest)
     end
 
-    it "should consider smallint datatypes as boolean if set, but if not, as larger smallints" do
+    deprecated "should consider smallint datatypes as boolean if set, but if not, as larger smallints" do
       @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
       @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
       @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
 
       Sequel::SqlAnywhere.convert_smallint_to_bool = false
-      @db2 = Sequel.connect(DB.url)
-      @db2.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
-      @db2.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-
-      @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
+      @db.send(:remove_instance_variable, :@convert_smallint_to_bool) if @db.instance_variable_defined?(:@convert_smallint_to_bool)
+      @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
       @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-
-      @db2.disconnect
     end
 
-    describe "datasets" do
-      it "should return smallints as bools and integers as integers when set" do
-        @ds.delete
-        @ds << {:b=>true, :i=>10}
-        @ds.all.must_equal [{:b=>true, :i=>10}]
-        @ds.delete
-        @ds << {:b=>false, :i=>0}
-        @ds.all.must_equal [{:b=>false, :i=>0}]
-        @ds.delete
-        @ds << {:b=>true, :i=>1}
-        @ds.all.must_equal [{:b=>true, :i=>1}]
-      end
-
-      it "should return all smallints as integers when unset" do
-        Sequel::SqlAnywhere.convert_smallint_to_bool = false
-        @db2 = Sequel.connect(DB.url)
-        @ds2 = @db2[:booltest]
-        @ds2.delete
-        @ds2 << {:b=>true, :i=>10}
-        @ds2.all.must_equal [{:b=>1, :i=>10}]
-        @ds2.delete
-        @ds2 << {:b=>false, :i=>0}
-        @ds2.all.must_equal [{:b=>0, :i=>0}]
-        
-        @ds2.delete
-        @ds2 << {:b=>1, :i=>10}
-        @ds2.all.must_equal [{:b=>1, :i=>10}]
-        @ds2.delete
-        @ds2 << {:b=>0, :i=>0}
-        @ds2.all.must_equal [{:b=>0, :i=>0}]
+    it "should return smallints as bools and integers as integers when set" do
+      @ds.delete
+      @ds.insert(:b=>true, :i=>10)
+      @ds.all.must_equal [{:b=>true, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>false, :i=>0)
+      @ds.all.must_equal [{:b=>false, :i=>0}]
+      @ds.delete
+      @ds.insert(:b=>true, :i=>1)
+      @ds.all.must_equal [{:b=>true, :i=>1}]
+    end
 
-        @db2.disconnect
-      end
+    deprecated "should return all smallints as integers when unset" do
+      Sequel::SqlAnywhere.convert_smallint_to_bool = false
+      @ds.delete
+      @ds.insert(:b=>true, :i=>10)
+      @ds.all.must_equal [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>false, :i=>0)
+      @ds.all.must_equal [{:b=>0, :i=>0}]
+      
+      @ds.delete
+      @ds.insert(:b=>1, :i=>10)
+      @ds.all.must_equal [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>0, :i=>0)
+      @ds.all.must_equal [{:b=>0, :i=>0}]
     end
   end
   
@@ -92,47 +85,39 @@ describe "Convert smallint to boolean" do
       @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
     end
   
-    describe "datasets" do
-      it "should return smallints as bools and integers as integers when set" do
-        @ds = @db[:booltest]
-        @ds.delete
-        @ds << {:b=>true, :i=>10}
-        @ds.all.must_equal [{:b=>true, :i=>10}]
-        @ds.delete
-        @ds << {:b=>false, :i=>0}
-        @ds.all.must_equal [{:b=>false, :i=>0}]
-        @ds.delete
-        @ds << {:b=>true, :i=>1}
-        @ds.all.must_equal [{:b=>true, :i=>1}]
-      end
-  
-      it "should return all smallints as integers when unset" do
-        @db2 = Sequel.connect(DB.url)
-        @db2.convert_smallint_to_bool = false
-        @ds2 = @db2[:booltest]
-        @ds2.delete
-        @ds2 << {:b=>true, :i=>10}
-        @ds2.all.must_equal [{:b=>1, :i=>10}]
-        @ds2.delete
-        @ds2 << {:b=>false, :i=>0}
-        @ds2.all.must_equal [{:b=>0, :i=>0}]
-      
-        @ds2.delete
-        @ds2 << {:b=>1, :i=>10}
-        @ds2.all.must_equal [{:b=>1, :i=>10}]
-        @ds2.delete
-        @ds2 << {:b=>0, :i=>0}
-        @ds2.all.must_equal [{:b=>0, :i=>0}]
+    it "should return smallints as bools and integers as integers when set" do
+      @ds.delete
+      @ds.insert(:b=>true, :i=>10)
+      @ds.all.must_equal [{:b=>true, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>false, :i=>0)
+      @ds.all.must_equal [{:b=>false, :i=>0}]
+      @ds.delete
+      @ds.insert(:b=>true, :i=>1)
+      @ds.all.must_equal [{:b=>true, :i=>1}]
+    end
 
-        @db2.disconnect
-      end
+    it "should return all smallints as integers when unset" do
+      @db.convert_smallint_to_bool = false
+      @ds.delete
+      @ds.insert(:b=>true, :i=>10)
+      @ds.all.must_equal [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>false, :i=>0)
+      @ds.all.must_equal [{:b=>0, :i=>0}]
+    
+      @ds.delete
+      @ds.insert(:b=>1, :i=>10)
+      @ds.all.must_equal [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>0, :i=>0)
+      @ds.all.must_equal [{:b=>0, :i=>0}]
     end
   end
 
   describe "Dataset#convert_smallint_to_bool" do
     before do
       @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
-      @ds = @db[:booltest]
     end
     after do
       @db.drop_table(:booltest)
@@ -140,30 +125,47 @@ describe "Convert smallint to boolean" do
     
     it "should return smallints as bools and integers as integers when set" do
       @ds.delete
-      @ds << {:b=>true, :i=>10}
+      @ds.insert(:b=>true, :i=>10)
       @ds.all.must_equal [{:b=>true, :i=>10}]
       @ds.delete
-      @ds << {:b=>false, :i=>0}
+      @ds.insert(:b=>false, :i=>0)
       @ds.all.must_equal [{:b=>false, :i=>0}]
       @ds.delete
-      @ds << {:b=>true, :i=>1}
+      @ds.insert(:b=>true, :i=>1)
       @ds.all.must_equal [{:b=>true, :i=>1}]
     end
 
-    it "should return all smallints as integers when unset" do
+    deprecated "should return all smallints as integers when unset" do
       @ds.convert_smallint_to_bool = false
       @ds.delete
-      @ds << {:b=>true, :i=>10}
+      @ds.insert(:b=>true, :i=>10)
+      @ds.all.must_equal [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>false, :i=>0)
+      @ds.all.must_equal [{:b=>0, :i=>0}]
+    
+      @ds.delete
+      @ds.insert(:b=>1, :i=>10)
+      @ds.all.must_equal [{:b=>1, :i=>10}]
+      @ds.delete
+      @ds.insert(:b=>0, :i=>0)
+      @ds.all.must_equal [{:b=>0, :i=>0}]
+    end
+
+    it "should support with_convert_smallint_to_bool for returning modified dataset with setting changed" do
+      @ds = @ds.with_convert_smallint_to_bool(false)
+      @ds.delete
+      @ds.insert(:b=>true, :i=>10)
       @ds.all.must_equal [{:b=>1, :i=>10}]
       @ds.delete
-      @ds << {:b=>false, :i=>0}
+      @ds.insert(:b=>false, :i=>0)
       @ds.all.must_equal [{:b=>0, :i=>0}]
     
       @ds.delete
-      @ds << {:b=>1, :i=>10}
+      @ds.insert(:b=>1, :i=>10)
       @ds.all.must_equal [{:b=>1, :i=>10}]
       @ds.delete
-      @ds << {:b=>0, :i=>0}
+      @ds.insert(:b=>0, :i=>0)
       @ds.all.must_equal [{:b=>0, :i=>0}]
     end
   end