sequel 4.46.0 → 4.49.0

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 ||= [])
@@ -168,6 +169,8 @@ describe "PostgreSQL views" do
     @db[:items_view].select_order_map(:number).must_equal [10, 20]
     @db.refresh_view(:items_view)
     @db[:items_view].select_order_map(:number).must_equal [10, 15, 20]
+    @db.views.wont_include :items_view
+    @db.views(@opts).must_include :items_view
   end if DB.server_version >= 90300
 
   it "should support refreshing materialized views concurrently" do
@@ -443,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]
@@ -679,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
@@ -800,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')
@@ -809,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')
@@ -818,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
@@ -861,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
@@ -914,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]
@@ -929,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
@@ -938,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
@@ -1515,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
@@ -1779,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
@@ -1789,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
@@ -1959,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
 
@@ -3373,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)
@@ -3485,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

data/spec/adapters/sqlite_spec.rb

@@ -134,7 +134,7 @@ describe "An SQLite database" do
     @db.create_table!(:fk){timestamp :t; datetime :d}
     @db.use_timestamp_timezones = true
     t1 = Time.at(1)
-    @db[:fk] << {:t => t1, :d => t1}
+    @db[:fk].insert(:t => t1, :d => t1)
     @db[:fk].map(:t).must_equal [t1]
     @db[:fk].map(:d).must_equal [t1]
     Sequel.datetime_class = DateTime
@@ -145,9 +145,9 @@ describe "An SQLite database" do
   
   it "should support sequential primary keys" do
     @db.create_table!(:fk) {primary_key :id; text :name}
-    @db[:fk] << {:name => 'abc'}
-    @db[:fk] << {:name => 'def'}
-    @db[:fk] << {:name => 'ghi'}
+    @db[:fk].insert(:name => 'abc')
+    @db[:fk].insert(:name => 'def')
+    @db[:fk].insert(:name => 'ghi')
     @db[:fk].order(:name).all.must_equal [
       {:id => 1, :name => 'abc'},
       {:id => 2, :name => 'def'},
@@ -347,9 +347,9 @@ describe "SQLite::Dataset#delete" do
     end
     @d = DB[:items]
     @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
+    @d.insert(:name => 'abc', :value => 1.23)
+    @d.insert(:name => 'def', :value => 4.56)
+    @d.insert(:name => 'ghi', :value => 7.89)
   end
   after do
     DB.drop_table?(:items)
@@ -382,9 +382,9 @@ describe "SQLite::Dataset#update" do
     end
     @d = DB[:items]
     @d.delete # remove all records
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
+    @d.insert(:name => 'abc', :value => 1.23)
+    @d.insert(:name => 'def', :value => 4.56)
+    @d.insert(:name => 'ghi', :value => 7.89)
   end
   
   it "should return the number of records affected" do
@@ -444,16 +444,16 @@ describe "SQLite dataset" do
       Float :value
     end
     @d = DB[:items]
-    @d << {:name => 'abc', :value => 1.23}
-    @d << {:name => 'def', :value => 4.56}
-    @d << {:name => 'ghi', :value => 7.89}
+    @d.insert(:name => 'abc', :value => 1.23)
+    @d.insert(:name => 'def', :value => 4.56)
+    @d.insert(:name => 'ghi', :value => 7.89)
   end
   after do
     DB.drop_table?(:test, :items)
   end
   
   it "should be able to insert from a subquery" do
-    DB[:test] << @d
+    DB[:test].insert(@d)
     DB[:test].count.must_equal 3
     DB[:test].select(:name, :value).order(:value).to_a.must_equal \
       @d.select(:name, :value).order(:value).to_a
@@ -484,21 +484,21 @@ describe "A SQLite database" do
     @db.add_column :test2, :xyz, :text
     
     @db[:test2].columns.must_equal [:name, :value, :xyz]
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz=>'000'}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz=>'000')
     @db[:test2].first.must_equal(:name => 'mmm', :value => 111, :xyz=>'000')
   end
   
   it "should support drop_column operations" do
     @db.drop_column :test2, :value
     @db[:test2].columns.must_equal [:name]
-    @db[:test2] << {:name => 'mmm'}
+    @db[:test2].insert(:name => 'mmm')
     @db[:test2].first.must_equal(:name => 'mmm')
   end
   
   it "should support drop_column operations in a transaction" do
     @db.transaction{@db.drop_column :test2, :value}
     @db[:test2].columns.must_equal [:name]
-    @db[:test2] << {:name => 'mmm'}
+    @db[:test2].insert(:name => 'mmm')
     @db[:test2].first.must_equal(:name => 'mmm')
   end
 
@@ -506,9 +506,9 @@ describe "A SQLite database" do
     @db.create_table!(:test2){Integer :a; Integer :b; Integer :c; primary_key [:a, :b]}
     @db.drop_column :test2, :c
     @db[:test2].columns.must_equal [:a, :b]
-    @db[:test2] << {:a=>1, :b=>2}
-    @db[:test2] << {:a=>2, :b=>3}
-    proc{@db[:test2] << {:a=>2, :b=>3}}.must_raise(Sequel::UniqueConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
+    @db[:test2].insert(:a=>1, :b=>2)
+    @db[:test2].insert(:a=>2, :b=>3)
+    proc{@db[:test2].insert(:a=>2, :b=>3)}.must_raise(Sequel::UniqueConstraintViolation, Sequel::ConstraintViolation, Sequel::DatabaseError)
   end
 
   it "should keep column attributes when dropping a column" do
@@ -520,9 +520,9 @@ describe "A SQLite database" do
 
     # This lame set of additions and deletions are to test that the primary keys
     # don't get messed up when we recreate the database.
-    @db[:test3] << { :name => "foo", :value => 1}
-    @db[:test3] << { :name => "foo", :value => 2}
-    @db[:test3] << { :name => "foo", :value => 3}
+    @db[:test3].insert( :name => "foo", :value => 1)
+    @db[:test3].insert( :name => "foo", :value => 2)
+    @db[:test3].insert( :name => "foo", :value => 3)
     @db[:test3].filter(:id => 2).delete
 
     @db.drop_column :test3, :value
@@ -558,7 +558,7 @@ describe "A SQLite database" do
   it "should support rename_column operations" do
     @db[:test2].delete
     @db.add_column :test2, :xyz, :text
-    @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, :type => :text
@@ -717,4 +717,9 @@ describe "A SQLite database" do
     @db[:test2].insert(:name=>'a')
     proc{@db[:test2].insert(:name=>'a')}.must_raise(Sequel::ConstraintViolation, Sequel::UniqueConstraintViolation)
   end
+
+  it "should show unique constraints in Database#indexes" do
+    @db.alter_table(:test2){add_unique_constraint :name}
+    @db.indexes(:test2).values.first[:columns].must_equal [:name]
+  end if DB.sqlite_version >= 30808
 end

data/spec/bin_spec.rb

@@ -40,7 +40,13 @@ describe "bin/sequel" do
     DB2.disconnect
     File.delete(BIN_SPEC_DB) if File.file?(BIN_SPEC_DB)
     File.delete(BIN_SPEC_DB2) if File.file?(BIN_SPEC_DB2)
-    File.delete(TMP_FILE) if File.file?(TMP_FILE)
+    if File.file?(TMP_FILE)
+      begin
+        File.delete(TMP_FILE)
+      rescue Errno::ENOENT
+        nil
+      end
+    end
     File.delete(OUTPUT) if File.file?(OUTPUT)
   end