sequel 3.38.0 → 3.39.0

data/spec/adapters/mysql_spec.rb

@@ -14,10 +14,6 @@ INTEGRATION_DB = MYSQL_DB unless defined?(INTEGRATION_DB)
 
 MYSQL_URI = URI.parse(MYSQL_DB.uri)
 
-MYSQL_DB.create_table! :test2 do
-  text :name
-  integer :value
-end
 def MYSQL_DB.sqls
   (@sqls ||= [])
 end
@@ -86,24 +82,17 @@ describe "MySQL", '#create_table' do
     @db[:dolls].insert
     @db[:dolls].select_map(:name).should == ["foo"]
   end
-end
-
-describe "A MySQL database" do
-  specify "should provide the server version" do
-    MYSQL_DB.server_version.should >= 40000
-  end
 
-  specify "should handle the creation and dropping of an InnoDB table with foreign keys" do
-    proc{MYSQL_DB.create_table!(:test_innodb, :engine=>:InnoDB){primary_key :id; foreign_key :fk, :test_innodb, :key=>:id}}.should_not raise_error
-  end
-
-  specify "should support for_share" do
-    MYSQL_DB.transaction{MYSQL_DB[:test2].for_share.all.should == []}
+  specify "should be able to parse the default value for set and enum types" do
+    @db.create_table!(:dolls){column :t, "set('a', 'b', 'c', 'd')", :default=>'a,b'}
+    @db.schema(:dolls).first.last[:ruby_default].should == 'a,b'
+    @db.create_table!(:dolls){column :t, "enum('a', 'b', 'c', 'd')", :default=>'b'}
+    @db.schema(:dolls).first.last[:ruby_default].should == 'b'
   end
 end
 
-if MYSQL_DB.adapter_scheme == :mysql
-  describe "Sequel::MySQL.convert_tinyint_to_bool" do
+if [:mysql, :mysql2].include?(MYSQL_DB.adapter_scheme)
+  describe "Sequel::MySQL::Database#convert_tinyint_to_bool" do
     before do
       @db = MYSQL_DB
       @db.create_table(:booltest){column :b, 'tinyint(1)'; column :i, 'tinyint(4)'}
@@ -149,6 +138,17 @@ if MYSQL_DB.adapter_scheme == :mysql
       @ds << {:b=>0, :i=>0}
       @ds.all.should == [{:b=>0, :i=>0}]
     end
+
+    specify "should allow disabling the conversion on a per-dataset basis" do
+      @db.convert_tinyint_to_bool = true
+      ds = @ds.clone
+      ds.meta_def(:cast_tinyint_integer?){|f| true} # mysql
+      ds.meta_def(:convert_tinyint_to_bool?){false} # mysql2
+      ds.delete
+      ds << {:b=>true, :i=>10}
+      ds.all.should == [{:b=>1, :i=>10}]
+      @ds.all.should == [{:b=>true, :i=>10}]
+    end
   end
 end
 
@@ -269,7 +269,6 @@ end
 describe "MySQL join expressions" do
   before do
     @ds = MYSQL_DB[:nodes]
-    @ds.db.meta_def(:server_version) {50014}
   end
 
   specify "should raise error for :full_outer join requests." do
@@ -342,8 +341,41 @@ describe "Joined MySQL dataset" do
 end
 
 describe "A MySQL database" do
-  before do
+  after do
+    MYSQL_DB.drop_table?(:test_innodb)
+  end
+
+  specify "should handle the creation and dropping of an InnoDB table with foreign keys" do
+    proc{MYSQL_DB.create_table!(:test_innodb, :engine=>:InnoDB){primary_key :id; foreign_key :fk, :test_innodb, :key=>:id}}.should_not raise_error
+  end
+end
+
+describe "A MySQL database" do
+  before(:all) do
     @db = MYSQL_DB
+    @db.create_table! :test2 do
+      text :name
+      integer :value
+    end
+  end
+  after(:all) do
+    @db.drop_table?(:test2)
+  end
+
+  specify "should provide the server version" do
+    @db.server_version.should >= 40000
+  end
+
+  specify "should cache the server version" do
+    # warm cache:
+    @db.server_version
+    @db.sqls.clear
+    3.times{@db.server_version}
+    @db.sqls.should be_empty
+  end
+
+  specify "should support for_share" do
+    @db.transaction{@db[:test2].for_share.all.should == []}
   end
 
   specify "should support add_column operations" do
@@ -472,8 +504,7 @@ describe "A MySQL database" do
     @db.alter_table(:items){add_foreign_key :p_id, :users, :key => :id, :null => false, :on_delete => :cascade}
     @db.sqls.should == ["CREATE TABLE `items` (`id` integer)",
       "CREATE TABLE `users` (`id` integer PRIMARY KEY AUTO_INCREMENT)",
-      "ALTER TABLE `items` ADD COLUMN `p_id` integer NOT NULL",
-      "ALTER TABLE `items` ADD FOREIGN KEY (`p_id`) REFERENCES `users`(`id`) ON DELETE CASCADE"]
+      "ALTER TABLE `items` ADD COLUMN `p_id` integer NOT NULL, ADD FOREIGN KEY (`p_id`) REFERENCES `users`(`id`) ON DELETE CASCADE"]
   end
 
   specify "should have rename_column support keep existing options" do
@@ -500,7 +531,7 @@ describe "A MySQL database" do
   specify "should have set_column_type pass through options" do
     @db.create_table(:items){integer :id; enum :list, :elements=>%w[one]}
     @db.alter_table(:items){set_column_type :id, :int, :unsigned=>true, :size=>8; set_column_type :list, :enum, :elements=>%w[two]}
-    @db.sqls.should == ["CREATE TABLE `items` (`id` integer, `list` enum('one'))", "DESCRIBE `items`", "ALTER TABLE `items` CHANGE COLUMN `id` `id` int(8) UNSIGNED NULL", "ALTER TABLE `items` CHANGE COLUMN `list` `list` enum('two') NULL"]
+    @db.sqls.should == ["CREATE TABLE `items` (`id` integer, `list` enum('one'))", "DESCRIBE `items`", "ALTER TABLE `items` CHANGE COLUMN `id` `id` int(8) UNSIGNED NULL, CHANGE COLUMN `list` `list` enum('two') NULL"]
   end
 
   specify "should have set_column_default support keep existing options" do
@@ -625,6 +656,9 @@ describe "A grouped MySQL dataset" do
     MYSQL_DB[:test2] << {:name => '12', :value => 20}
     MYSQL_DB[:test2] << {:name => '13', :value => 10}
   end
+  after do
+    MYSQL_DB.drop_table?(:test2)
+  end
 
   specify "should return the correct count for raw sql query" do
     ds = MYSQL_DB["select name FROM test2 WHERE name = '11' GROUP BY name"]

data/spec/adapters/oracle_spec.rb

@@ -5,25 +5,34 @@ unless defined?(ORACLE_DB)
 end
 INTEGRATION_DB = ORACLE_DB unless defined?(INTEGRATION_DB)
 
-ORACLE_DB.create_table!(:items) do
-  String :name, :size => 50
-  Integer :value
-  Date :date_created
-  index :value
-end
+describe "An Oracle database" do
+  before(:all) do
+    ORACLE_DB.create_table!(:items) do
+      String :name, :size => 50
+      Integer :value
+      Date :date_created
+      index :value
+    end
 
-ORACLE_DB.create_table!(:books) do
-  Integer :id
-  String :title, :size => 50
-  Integer :category_id
-end
+    ORACLE_DB.create_table!(:books) do
+      Integer :id
+      String :title, :size => 50
+      Integer :category_id
+    end
 
-ORACLE_DB.create_table!(:categories) do
-  Integer :id
-  String :cat_name, :size => 50
-end
+    ORACLE_DB.create_table!(:categories) do
+      Integer :id
+      String :cat_name, :size => 50
+    end
+    @d = ORACLE_DB[:items]
+  end
+  after do
+    @d.delete
+  end
+  after(:all) do
+    ORACLE_DB.drop_table?(:items, :books, :categories)
+  end
 
-describe "An Oracle database" do
   specify "should provide disconnect functionality" do
     ORACLE_DB.execute("select user from dual")
     ORACLE_DB.pool.size.should == 1
@@ -81,15 +90,9 @@ describe "An Oracle database" do
       primary_key :id, :integer, :null => false
       index :name, :unique => true
     end
+    ORACLE_DB.drop_table?(:test_tmp)
   end
-end
 
-describe "An Oracle dataset" do
-  before do
-    @d = ORACLE_DB[:items]
-    @d.delete # remove all records
-  end
-  
   specify "should return the correct record count" do
     @d.count.should == 0
     @d << {:name => 'abc', :value => 123}
@@ -194,8 +197,6 @@ describe "An Oracle dataset" do
     @d << {:name => 'def', :value => 789}
     @d.filter(:name => 'abc').update(:value => 530)
     
-    # the third record should stay the same
-    # floating-point precision bullshit
     @d[:name => 'def'][:value].should == 789
     @d.filter(:value => 530).count.should == 2
   end
@@ -230,24 +231,20 @@ describe "An Oracle dataset" do
 
     @d.count.should == 1
   end
-end
 
-describe "Joined Oracle dataset" do
-  before do
+  specify "should return correct result" do
     @d1 = ORACLE_DB[:books]
-    @d1.delete # remove all records
+    @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}
     
     @d2 = ORACLE_DB[:categories]
-    @d2.delete # remove all records
+    @d2.delete
     @d2 << {:id => 100, :cat_name => 'ruby'}
     @d2 << {:id => 101, :cat_name => 'rails'}
-  end
   
-  specify "should return correct result" do
     @d1.join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id).to_a.should == [
       {:id => 1, :title => 'aaa', :cat_name => 'ruby'},
       {:id => 2, :title => 'bbb', :cat_name => 'ruby'},
@@ -271,18 +268,14 @@ describe "Joined Oracle dataset" do
       {:id => 3, :title => 'ccc', :cat_name => 'rails'}
     ]      
   end  
-end
 
-describe "Oracle aliasing" do
-  before do
+  specify "should allow columns to be renamed" do
     @d1 = ORACLE_DB[:books]
-    @d1.delete # remove all records
+    @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}
-  end
 
-  specify "should allow columns to be renamed" do
     @d1.select(Sequel.as(:title, :name)).order_by(:id).to_a.should == [
       { :name => 'aaa' },
       { :name => 'bbb' },
@@ -291,22 +284,14 @@ describe "Oracle aliasing" do
   end
 
   specify "nested queries should work" do
-    @d1.select(:title).group_by(:title).count.should == 2
-  end
-end
-
-describe "Row locks in Oracle" do
-  before do
-    @d1 = ORACLE_DB[:books]
-    @d1.delete
-    @d1 << {:id => 1, :title => 'aaa'}
+    ORACLE_DB[:books].select(:title).group_by(:title).count.should == 2
   end
 
   specify "#for_update should use FOR UPDATE" do
-    @d1.for_update.sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
+    ORACLE_DB[:books].for_update.sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
   end
 
   specify "#lock_style should accept symbols" do
-    @d1.lock_style(:update).sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
+    ORACLE_DB[:books].lock_style(:update).sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
   end
 end

data/spec/adapters/postgres_spec.rb

@@ -24,26 +24,14 @@ end
 POSTGRES_DB.loggers << logger
 
 #POSTGRES_DB.instance_variable_set(:@server_version, 80200)
-POSTGRES_DB.create_table! :test do
-  text :name
-  integer :value, :index => true
-end
-POSTGRES_DB.create_table! :test2 do
-  text :name
-  integer :value
-end
-POSTGRES_DB.create_table! :test3 do
-  integer :value
-  timestamp :time
-end
-POSTGRES_DB.create_table! :test4 do
-  varchar :name, :size => 20
-  bytea :value
-end
 
 describe "A PostgreSQL database" do
-  before do
+  before(:all) do
     @db = POSTGRES_DB
+    @db.create_table!(:public__testfk){primary_key :id; foreign_key :i, :public__testfk}
+  end
+  after(:all) do
+    @db.drop_table?(:public__testfk)
   end
 
   specify "should provide the server version" do
@@ -51,23 +39,13 @@ describe "A PostgreSQL database" do
   end
 
   specify "should correctly parse the schema" do
-    @db.schema(:test3, :reload=>true).should == [
-      [:value, {:oid=>23, :type=>:integer, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"integer", :primary_key=>false}],
-      [:time, {:oid=>1114, :type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp without time zone", :primary_key=>false}]
-    ]
-    @db.schema(:test4, :reload=>true).should == [
-      [:name, {:oid=>1043, :type=>:string, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"character varying(20)", :primary_key=>false}],
-      [:value, {:oid=>17, :type=>:blob, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"bytea", :primary_key=>false}]
-    ]
+    @db.schema(:public__testfk, :reload=>true).should == [
+      [:id, {:type=>:integer, :ruby_default=>nil, :db_type=>"integer", :default=>"nextval('testfk_id_seq'::regclass)", :oid=>23, :primary_key=>true, :allow_null=>false}],
+      [:i, {:type=>:integer, :ruby_default=>nil, :db_type=>"integer", :default=>nil, :oid=>23, :primary_key=>false, :allow_null=>true}]]
   end
 
   specify "should parse foreign keys for tables in a schema" do
-    begin
-      @db.create_table!(:public__testfk){primary_key :id; foreign_key :i, :public__testfk}
-      @db.foreign_key_list(:public__testfk).should == [{:on_delete=>:no_action, :on_update=>:no_action, :columns=>[:i], :key=>[:id], :deferrable=>false, :table=>Sequel.qualify(:public, :testfk), :name=>:testfk_i_fkey}]
-    ensure
-      @db.drop_table(:public__testfk)
-    end
+    @db.foreign_key_list(:public__testfk).should == [{:on_delete=>:no_action, :on_update=>:no_action, :columns=>[:i], :key=>[:id], :deferrable=>false, :table=>Sequel.qualify(:public, :testfk), :name=>:testfk_i_fkey}]
   end
 
   specify "should return uuid fields as strings" do
@@ -76,10 +54,23 @@ describe "A PostgreSQL database" do
 end
 
 describe "A PostgreSQL dataset" do
+  before(:all) do
+    @db = POSTGRES_DB
+    @d = @db[:test]
+    @db.create_table! :test do
+      text :name
+      integer :value, :index => true
+    end
+  end
   before do
-    @d = POSTGRES_DB[:test]
     @d.delete
-    POSTGRES_DB.sqls.clear
+    @db.sqls.clear
+  end
+  after do
+    @db.drop_table?(:atest)
+  end
+  after(:all) do
+    @db.drop_table?(:test)
   end
 
   specify "should quote columns and tables using double quotes if quoting identifiers" do
@@ -130,68 +121,52 @@ describe "A PostgreSQL dataset" do
   end
 
   specify "should support exclusion constraints when creating or altering tables" do
-    begin
-      @db = POSTGRES_DB
-      @db.create_table!(:atest){Integer :t; exclude [[Sequel.desc(:t, :nulls=>:last), '=']], :using=>:btree, :where=>proc{t > 0}}
-      @db[:atest].insert(1)
-      @db[:atest].insert(2)
-      proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
-
-      @db.create_table!(:atest){Integer :t}
-      @db.alter_table(:atest){add_exclusion_constraint [[:t, '=']], :using=>:btree, :name=>'atest_ex'}
-      @db[:atest].insert(1)
-      @db[:atest].insert(2)
-      proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
-      @db.alter_table(:atest){drop_constraint 'atest_ex'}
-    ensure
-      @db.drop_table?(:atest)
-    end
+    @db.create_table!(:atest){Integer :t; exclude [[Sequel.desc(:t, :nulls=>:last), '=']], :using=>:btree, :where=>proc{t > 0}}
+    @db[:atest].insert(1)
+    @db[:atest].insert(2)
+    proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
+
+    @db.create_table!(:atest){Integer :t}
+    @db.alter_table(:atest){add_exclusion_constraint [[:t, '=']], :using=>:btree, :name=>'atest_ex'}
+    @db[:atest].insert(1)
+    @db[:atest].insert(2)
+    proc{@db[:atest].insert(2)}.should raise_error(Sequel::DatabaseError)
+    @db.alter_table(:atest){drop_constraint 'atest_ex'}
   end if POSTGRES_DB.server_version >= 90000
 
   specify "should support adding foreign key constarints that are not yet valid, and validating them later" do
-    begin
-      @db = POSTGRES_DB
-      @db.create_table!(:atest){primary_key :id; Integer :fk}
-      @db[:atest].insert(1, 5)
-      @db.alter_table(:atest){add_foreign_key [:fk], :atest, :not_valid=>true, :name=>:atest_fk}
-      @db[:atest].insert(2, 1)
-      proc{@db[:atest].insert(3, 4)}.should raise_error(Sequel::DatabaseError)
-
-      proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should raise_error(Sequel::DatabaseError)
-      @db[:atest].where(:id=>1).update(:fk=>2)
-      @db.alter_table(:atest){validate_constraint :atest_fk}
-      proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should_not raise_error
-    ensure
-      @db.drop_table?(:atest)
-    end
+    @db.create_table!(:atest){primary_key :id; Integer :fk}
+    @db[:atest].insert(1, 5)
+    @db.alter_table(:atest){add_foreign_key [:fk], :atest, :not_valid=>true, :name=>:atest_fk}
+    @db[:atest].insert(2, 1)
+    proc{@db[:atest].insert(3, 4)}.should raise_error(Sequel::DatabaseError)
+
+    proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should raise_error(Sequel::DatabaseError)
+    @db[:atest].where(:id=>1).update(:fk=>2)
+    @db.alter_table(:atest){validate_constraint :atest_fk}
+    proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should_not raise_error
   end if POSTGRES_DB.server_version >= 90200
 
   specify "should support :using when altering a column's type" do
-    begin
-      @db = POSTGRES_DB
-      @db.create_table!(:atest){Integer :t}
-      @db[:atest].insert(1262304000)
-      @db.alter_table(:atest){set_column_type :t, Time, :using=>Sequel.cast('epoch', Time) + Sequel.cast('1 second', :interval) * :t}
-      @db[:atest].get(Sequel.extract(:year, :t)).should == 2010
-    ensure
-      @db.drop_table?(:atest)
-    end
+    @db.create_table!(:atest){Integer :t}
+    @db[:atest].insert(1262304000)
+    @db.alter_table(:atest){set_column_type :t, Time, :using=>Sequel.cast('epoch', Time) + Sequel.cast('1 second', :interval) * :t}
+    @db[:atest].get(Sequel.extract(:year, :t)).should == 2010
   end
 
   specify "should support :using with a string when altering a column's type" do
-    begin
-      @db = POSTGRES_DB
-      @db.create_table!(:atest){Integer :t}
-      @db[:atest].insert(1262304000)
-      @db.alter_table(:atest){set_column_type :t, Time, :using=>"'epoch'::timestamp + '1 second'::interval * t"}
-      @db[:atest].get(Sequel.extract(:year, :t)).should == 2010
-    ensure
-      @db.drop_table?(:atest)
-    end
+    @db.create_table!(:atest){Integer :t}
+    @db[:atest].insert(1262304000)
+    @db.alter_table(:atest){set_column_type :t, Time, :using=>"'epoch'::timestamp + '1 second'::interval * t"}
+    @db[:atest].get(Sequel.extract(:year, :t)).should == 2010
+  end
+
+  specify "should be able to parse the default value for an interval type" do
+    @db.create_table!(:atest){interval :t, :default=>'1 week'}
+    @db.schema(:atest).first.last[:ruby_default].should == '7 days'
   end
 
   specify "should have #transaction support various types of synchronous options" do
-    @db = POSTGRES_DB
     @db.transaction(:synchronous=>:on){}
     @db.transaction(:synchronous=>true){}
     @db.transaction(:synchronous=>:off){}
@@ -216,7 +191,6 @@ describe "A PostgreSQL dataset" do
   end
 
   specify "should have #transaction support read only transactions" do
-    @db = POSTGRES_DB
     @db.transaction(:read_only=>true){}
     @db.transaction(:read_only=>false){}
     @db.transaction(:isolation=>:serializable, :read_only=>true){}
@@ -225,7 +199,6 @@ describe "A PostgreSQL dataset" do
   end
 
   specify "should have #transaction support deferrable transactions" do
-    @db = POSTGRES_DB
     @db.transaction(:deferrable=>true){}
     @db.transaction(:deferrable=>false){}
     @db.transaction(:deferrable=>true, :read_only=>true){}
@@ -236,43 +209,42 @@ describe "A PostgreSQL dataset" do
   end if POSTGRES_DB.server_version >= 90100
 
   specify "should support creating indexes concurrently" do
-    POSTGRES_DB.sqls.clear
-    POSTGRES_DB.add_index :test, [:name, :value], :concurrently=>true
-    POSTGRES_DB.sqls.should == ['CREATE INDEX CONCURRENTLY "test_name_value_index" ON "test" ("name", "value")'] if check_sqls
+    @db.add_index :test, [:name, :value], :concurrently=>true
+    @db.sqls.should == ['CREATE INDEX CONCURRENTLY "test_name_value_index" ON "test" ("name", "value")'] if check_sqls
   end
 
   specify "should support dropping indexes only if they already exist" do
-    POSTGRES_DB.add_index :test, [:name, :value], :name=>'tnv1'
-    POSTGRES_DB.sqls.clear
-    POSTGRES_DB.drop_index :test, [:name, :value], :if_exists=>true, :name=>'tnv1'
-    POSTGRES_DB.sqls.should == ['DROP INDEX IF EXISTS "tnv1"']
+    @db.add_index :test, [:name, :value], :name=>'tnv1'
+    @db.sqls.clear
+    @db.drop_index :test, [:name, :value], :if_exists=>true, :name=>'tnv1'
+    @db.sqls.should == ['DROP INDEX IF EXISTS "tnv1"']
   end
 
   specify "should support CASCADE when dropping indexes" do
-    POSTGRES_DB.add_index :test, [:name, :value], :name=>'tnv2'
-    POSTGRES_DB.sqls.clear
-    POSTGRES_DB.drop_index :test, [:name, :value], :cascade=>true, :name=>'tnv2'
-    POSTGRES_DB.sqls.should == ['DROP INDEX "tnv2" CASCADE']
+    @db.add_index :test, [:name, :value], :name=>'tnv2'
+    @db.sqls.clear
+    @db.drop_index :test, [:name, :value], :cascade=>true, :name=>'tnv2'
+    @db.sqls.should == ['DROP INDEX "tnv2" CASCADE']
   end
 
   specify "should support dropping indexes concurrently" do
-    POSTGRES_DB.add_index :test, [:name, :value], :name=>'tnv2'
-    POSTGRES_DB.sqls.clear
-    POSTGRES_DB.drop_index :test, [:name, :value], :concurrently=>true, :name=>'tnv2'
-    POSTGRES_DB.sqls.should == ['DROP INDEX CONCURRENTLY "tnv2"']
+    @db.add_index :test, [:name, :value], :name=>'tnv2'
+    @db.sqls.clear
+    @db.drop_index :test, [:name, :value], :concurrently=>true, :name=>'tnv2'
+    @db.sqls.should == ['DROP INDEX CONCURRENTLY "tnv2"']
   end if POSTGRES_DB.server_version >= 90200
 
   specify "#lock should lock table if inside a transaction" do
-    POSTGRES_DB.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
+    @db.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
   end
 
   specify "#lock should return nil" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}.should == nil
-    POSTGRES_DB.transaction{@d.lock('EXCLUSIVE').should == nil; @d.insert(:name=>'a')}
+    @db.transaction{@d.lock('EXCLUSIVE').should == nil; @d.insert(:name=>'a')}
   end
 
   specify "should raise an error if attempting to update a joined dataset with a single FROM table" do
-    proc{POSTGRES_DB[:test].join(:test2, [:name]).update(:name=>'a')}.should raise_error(Sequel::Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs')
+    proc{@db[:test].join(:test, [:name]).update(:name=>'a')}.should raise_error(Sequel::Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs')
   end
 
   specify "should truncate with options" do
@@ -288,9 +260,9 @@ describe "A PostgreSQL dataset" do
   end
 
   specify "should truncate multiple tables at once" do
-    tables = [:test, :test2, :test3, :test4]
+    tables = [:test, :test]
     tables.each{|t| @d.from(t).insert}
-    @d.from(:test, :test2, :test3, :test4).truncate
+    @d.from(:test, :test).truncate
     tables.each{|t| @d.from(t).count.should == 0}
   end
 end
@@ -377,14 +349,23 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
 end
 
 describe "A PostgreSQL dataset with a timestamp field" do
-  before do
+  before(:all) do
     @db = POSTGRES_DB
+    @db.create_table! :test3 do
+      integer :value
+      timestamp :time
+    end
     @d = @db[:test3]
+  end
+  before do
     @d.delete
   end
   after do
     @db.convert_infinite_timestamps = false if @db.adapter_scheme == :postgres
   end
+  after(:all) do
+    @db.drop_table?(:test3)
+  end
 
   cspecify "should store milliseconds in time fields for Time objects", :do, :swift do
     t = Time.now
@@ -432,19 +413,29 @@ describe "A PostgreSQL dataset with a timestamp field" do
       c.new(:time=>-1.0/0.0).time.should == -1.0/0.0
     end
   end
-end
 
-describe "PostgreSQL's EXPLAIN and ANALYZE" do
-  specify "should not raise errors" do
+  specify "explain and analyze should not raise errors" do
     @d = POSTGRES_DB[:test3]
     proc{@d.explain}.should_not raise_error
     proc{@d.analyze}.should_not raise_error
   end
+
+  specify "#locks should be a dataset returning database locks " do
+    @db.locks.should be_a_kind_of(Sequel::Dataset)
+    @db.locks.all.should be_a_kind_of(Array)
+  end
 end
 
 describe "A PostgreSQL database" do
   before do
     @db = POSTGRES_DB
+    @db.create_table! :test2 do
+      text :name
+      integer :value
+    end
+  end
+  after do
+    @db.drop_table?(:test2)
   end
 
   specify "should support column operations" do
@@ -478,11 +469,6 @@ describe "A PostgreSQL database" do
 
     @db[:test2].first[:xyz].should == 57
   end
-
-  specify "#locks should be a dataset returning database locks " do
-    @db.locks.should be_a_kind_of(Sequel::Dataset)
-    @db.locks.all.should be_a_kind_of(Array)
-  end
 end
 
 describe "A PostgreSQL database" do
@@ -679,9 +665,9 @@ describe "Postgres::Dataset#insert" do
   end
 
   specify "should return nil if the table has no primary key" do
-    ds = POSTGRES_DB[:test4]
-    ds.delete
-    ds.insert(:name=>'a').should == nil
+    @db.create_table!(:test5){String :name; Integer :value}
+    @ds.delete
+    @ds.insert(:name=>'a').should == nil
   end
 end
 
@@ -763,7 +749,7 @@ describe "Postgres::Database schema qualified tables" do
 
   specify "should be able to get serial sequences for tables in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){primary_key :i}
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".schema_test_i_seq'
+    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
   end
 
   specify "should be able to get serial sequences for tables that have spaces in the name in a given schema" do
@@ -789,7 +775,7 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB.table_exists?(:schema_test).should == true
     POSTGRES_DB.tables.should == [:schema_test]
     POSTGRES_DB.primary_key(:schema_test__schema_test).should == 'i'
-    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test".schema_test_i_seq'
+    POSTGRES_DB.primary_key_sequence(:schema_test__schema_test).should == '"schema_test"."schema_test_i_seq"'
   end
 end
 
@@ -972,20 +958,21 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
 end
 
 if POSTGRES_DB.server_version >= 80300
-
-  POSTGRES_DB.create_table! :test6 do
-    text :title
-    text :body
-    full_text_index [:title, :body]
-  end
-
   describe "PostgreSQL tsearch2" do
-    before do
+    before(:all) do
+      POSTGRES_DB.create_table! :test6 do
+        text :title
+        text :body
+        full_text_index [:title, :body]
+      end
       @ds = POSTGRES_DB[:test6]
     end
     after do
       POSTGRES_DB[:test6].delete
     end
+    after(:all) do
+      POSTGRES_DB.drop_table?(:test6)
+    end
 
     specify "should search by indexed column" do
       record =  {:title => "oopsla conference", :body => "test"}
@@ -1244,6 +1231,78 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
     end
   end
 
+  describe "Postgres::Database#copy_table_from" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_copy){Integer :x; Integer :y}
+      @ds = @db[:test_copy].order(:x, :y)
+    end
+    before do
+      @db[:test_copy].delete
+    end
+    after(:all) do
+      @db.drop_table?(:test_copy)
+    end
+
+    specify "should work with a :data option containing data in PostgreSQL text format" do
+      @db.copy_into(:test_copy, :data=>"1\t2\n3\t4\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should work with :format=>:csv option and :data option containing data in CSV format" do
+      @db.copy_into(:test_copy, :format=>:csv, :data=>"1,2\n3,4\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should respect given :options" do
+      @db.copy_into(:test_copy, :options=>"FORMAT csv, HEADER TRUE", :data=>"x,y\n1,2\n3,4\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should respect given :options options when :format is used" do
+      @db.copy_into(:test_copy, :options=>"QUOTE '''', DELIMITER '|'", :format=>:csv, :data=>"'1'|'2'\n'3'|'4'\n")
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should accept :columns option to online copy the given columns" do
+      @db.copy_into(:test_copy, :data=>"1\t2\n3\t4\n", :columns=>[:y, :x])
+      @ds.select_map([:x, :y]).should == [[2, 1], [4, 3]]
+    end
+
+    specify "should accept a block and use returned values for the copy in data stream" do
+      buf = ["1\t2\n", "3\t4\n"]
+      @db.copy_into(:test_copy){buf.shift}
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should work correctly with a block and :format=>:csv" do
+      buf = ["1,2\n", "3,4\n"]
+      @db.copy_into(:test_copy, :format=>:csv){buf.shift}
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should accept an enumerable as the :data option" do
+      @db.copy_into(:test_copy, :data=>["1\t2\n", "3\t4\n"])
+      @ds.select_map([:x, :y]).should == [[1, 2], [3, 4]]
+    end
+
+    specify "should have an exception should cause a rollback of copied data and still have a usable connection" do
+      2.times do
+        sent = false
+        proc{@db.copy_into(:test_copy){raise ArgumentError if sent; sent = true; "1\t2\n"}}.should raise_error(ArgumentError)
+        @ds.select_map([:x, :y]).should == []
+      end
+    end
+
+    specify "should raise an Error if both :data and a block are provided" do
+      proc{@db.copy_into(:test_copy, :data=>["1\t2\n", "3\t4\n"]){}}.should raise_error(Sequel::Error)
+    end
+
+    specify "should raise an Error if neither :data or a block are provided" do
+      proc{@db.copy_into(:test_copy)}.should raise_error(Sequel::Error)
+    end
+  end
+
   describe "Postgres::Database LISTEN/NOTIFY" do
     before(:all) do
       @db = POSTGRES_DB
@@ -2363,6 +2422,7 @@ end if ((require 'active_support/duration'; require 'active_support/inflector';
 describe 'PostgreSQL row-valued/composite types' do
   before(:all) do
     @db = POSTGRES_DB
+    Sequel.extension :pg_array_ops, :pg_row_ops
     @db.extension :pg_array, :pg_row
     @ds = @db[:person]
 
@@ -2450,7 +2510,6 @@ describe 'PostgreSQL row-valued/composite types' do
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'operations/functions with pg_row_ops' do
-    Sequel.extension :pg_row_ops, :pg_array_ops
     @ds.insert(:id=>1, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))
     @ds.get(Sequel.pg_row(:address)[:street]).should == '123 Sesame St'
     @ds.get(Sequel.pg_row(:address)[:city]).should == 'Somewhere'
@@ -2470,6 +2529,45 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.get(Sequel.pg_row(:company)[:employees][1][:address][:zip]).should == '12345'
   end
 
+  context "#splat and #*" do
+    before(:all) do
+      @db.create_table!(:a){Integer :a}
+      @db.create_table!(:b){a :b; Integer :a}
+      @db.register_row_type(:a)
+      @db.register_row_type(:b)
+      @db[:b].insert(:a=>1, :b=>@db.row_type(:a, [2]))
+    end
+    after(:all) do
+      @db.drop_table?(:b, :a)
+    end
+
+    specify "splat should reference the table type" do
+      @db[:b].select(:a).first.should == {:a=>1}
+      @db[:b].select(:b__a).first.should == {:a=>1}
+      @db[:b].select(Sequel.pg_row(:b)[:a]).first.should == {:a=>2}
+      @db[:b].select(Sequel.pg_row(:b).splat[:a]).first.should == {:a=>1}
+
+      if @native
+        @db[:b].select(:b).first.should == {:b=>{:a=>2}}
+        @db[:b].select(Sequel.pg_row(:b).splat).first.should == {:a=>1, :b=>{:a=>2}}
+        @db[:b].select(Sequel.pg_row(:b).splat(:b)).first.should == {:b=>{:a=>1, :b=>{:a=>2}}}
+      end
+    end
+
+    specify "* should expand the table type into separate columns" do
+      ds = @db[:b].select(Sequel.pg_row(:b).splat(:b)).from_self(:alias=>:t)
+      if @native
+        ds.first.should == {:b=>{:a=>1, :b=>{:a=>2}}}
+        ds.select(Sequel.pg_row(:b).*).first.should == {:a=>1, :b=>{:a=>2}}
+        ds.select(Sequel.pg_row(:b)[:b]).first.should == {:b=>{:a=>2}}
+        ds.select(Sequel.pg_row(:t__b).*).first.should == {:a=>1, :b=>{:a=>2}}
+        ds.select(Sequel.pg_row(:t__b)[:b]).first.should == {:b=>{:a=>2}}
+      end
+      ds.select(Sequel.pg_row(:b)[:a]).first.should == {:a=>1}
+      ds.select(Sequel.pg_row(:t__b)[:a]).first.should == {:a=>1}
+    end
+  end
+
   context "with models" do
     before(:all) do
       class Address < Sequel::Model(:address)