sequel 3.21.0 → 3.29.0

data/spec/adapters/oracle_spec.rb

@@ -1,36 +1,26 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-require "timeout"
 
 unless defined?(ORACLE_DB)
   ORACLE_DB = Sequel.connect('oracle://hr:hr@localhost/XE')
 end
 INTEGRATION_DB = ORACLE_DB unless defined?(INTEGRATION_DB)
 
-if ORACLE_DB.table_exists?(:items)
-  ORACLE_DB.drop_table :items
-end
-ORACLE_DB.create_table :items do
-  varchar2 :name, :size => 50
-  number :value, :size => 38
-  date :date_created
+ORACLE_DB.create_table!(:items) do
+  String :name, :size => 50
+  Integer :value
+  Date :date_created
   index :value
 end
 
-if ORACLE_DB.table_exists?(:books)
-  ORACLE_DB.drop_table :books
-end
-ORACLE_DB.create_table :books do
-  number :id, :size => 38
-  varchar2 :title, :size => 50
-  number :category_id, :size => 38
+ORACLE_DB.create_table!(:books) do
+  Integer :id
+  String :title, :size => 50
+  Integer :category_id
 end
 
-if ORACLE_DB.table_exists?(:categories)
-  ORACLE_DB.drop_table :categories
-end
-ORACLE_DB.create_table :categories do
-  number :id, :size => 38
-  varchar2 :cat_name, :size => 50
+ORACLE_DB.create_table!(:categories) do
+  Integer :id
+  String :cat_name, :size => 50
 end
 
 describe "An Oracle database" do
@@ -40,38 +30,39 @@ describe "An Oracle database" do
     ORACLE_DB.disconnect
     ORACLE_DB.pool.size.should == 0
   end
+
+  specify "should be able to get current sequence value with SQL" do
+    begin
+      ORACLE_DB.create_table!(:foo){primary_key :id}
+      ORACLE_DB.fetch('SELECT seq_foo_id.nextval FROM DUAL').single_value.should == 1
+    ensure
+      ORACLE_DB.drop_table(:foo)
+    end
+  end
   
   specify "should provide schema information" do
-    books_schema = [
-      [:id, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}], 
-      [:title, {:char_size=>50, :type=>:varchar2, :allow_null=>true, :type_string=>"VARCHAR2(50)", :data_size=>50, :precision=>0, :char_used=>false, :scale=>0, :charset_form=>:implicit, :fsprecision=>0, :lfprecision=>0, :db_type=>"VARCHAR2(50)"}], 
-      [:category_id, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}]]
-    categories_schema = [
-      [:id, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}], 
-      [:cat_name, {:char_size=>50, :type=>:varchar2, :allow_null=>true, :type_string=>"VARCHAR2(50)", :data_size=>50, :precision=>0, :char_used=>false, :scale=>0, :charset_form=>:implicit, :fsprecision=>0, :lfprecision=>0, :db_type=>"VARCHAR2(50)"}]]
-    items_schema = [
-      [:name, {:char_size=>50, :type=>:varchar2, :allow_null=>true, :type_string=>"VARCHAR2(50)", :data_size=>50, :precision=>0, :char_used=>false, :scale=>0, :charset_form=>:implicit, :fsprecision=>0, :lfprecision=>0, :db_type=>"VARCHAR2(50)"}], 
-      [:value, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}],
-      [:date_created, {:charset_form=>nil, :type=>:date, :type_string=>"DATE", :fsprecision=>0, :data_size=>7, :lfprecision=>0, :precision=>0, :db_type=>"DATE", :char_used=>false, :char_size=>0, :scale=>0, :allow_null=>true}]]
+    books_schema = [[:id, [:integer, false, true, nil]],
+      [:title, [:string, false, true, nil]],
+      [:category_id, [:integer, false, true, nil]]]
+    categories_schema = [[:id, [:integer, false, true, nil]],
+      [:cat_name, [:string, false, true, nil]]]
+    items_schema = [[:name, [:string, false, true, nil]],
+      [:value, [:integer, false, true, nil]],
+      [:date_created, [:datetime, false, true, nil]]]
      
     {:books => books_schema, :categories => categories_schema, :items => items_schema}.each_pair do |table, expected_schema|
       schema = ORACLE_DB.schema(table)
       schema.should_not be_nil
-      expected_schema.should == schema
+      schema.map{|c, s| [c, s.values_at(:type, :primary_key, :allow_null, :ruby_default)]}.should == expected_schema
     end
   end
   
   specify "should create a temporary table" do
-    ORACLE_DB.create_table :test_tmp, :temporary => true do
+    ORACLE_DB.create_table! :test_tmp, :temp => true do
+      varchar2 :name, :size => 50
       primary_key :id, :integer, :null => false
-      column :name, :text
       index :name, :unique => true
     end
-    
-    ORACLE_DB.sqls.should == [
-      'CREATE GLOBAL TEMPORARY TABLE test_tmp (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
-      'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)'
-    ]
   end
 end
 
@@ -148,27 +139,27 @@ describe "An Oracle dataset" do
     
     @d.max(:value).to_i.should == 789
     
-    @d.select(:name, :AVG.sql_function(:value)).filter(:name => 'abc').group(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0}
+    @d.select(:name, :AVG.sql_function(:value).as(:avg)).filter(:name => 'abc').group(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0}
     ]
 
-    @d.select(:AVG.sql_function(:value)).group(:name).order(:name).limit(1).to_a.should == [
-      {:"avg(value)" => (456+123)/2.0}
+    @d.select(:AVG.sql_function(:value).as(:avg)).group(:name).order(:name).limit(1).to_a.should == [
+      {:avg => (456+123)/2.0}
     ]
         
-    @d.select(:name, :AVG.sql_function(:value)).group(:name).order(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
-      {:name => 'def', :"avg(value)" => 789*1.0}
+    @d.select(:name, :AVG.sql_function(:value).as(:avg)).group(:name).order(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0},
+      {:name => 'def', :avg => 789*1.0}
     ]
     
-    @d.select(:name, :AVG.sql_function(:value)).group(:name).order(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
-      {:name => 'def', :"avg(value)" => 789*1.0}
+    @d.select(:name, :AVG.sql_function(:value).as(:avg)).group(:name).order(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0},
+      {:name => 'def', :avg => 789*1.0}
     ]
 
-    @d.select(:name, :AVG.sql_function(:value)).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
-      {:name => 'def', :"avg(value)" => 789*1.0}
+    @d.select(:name, :AVG.sql_function(:value).as(:avg)).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0},
+      {:name => 'def', :avg => 789*1.0}
     ]
     
     @d.select(:name, :value).filter(:name => 'abc').union(@d.select(:name, :value).filter(:name => 'def')).order(:value).to_a.should == [
@@ -194,7 +185,7 @@ describe "An Oracle dataset" do
   specify "should translate values correctly" do
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
-    @d.filter(:value > 500).update(:date_created => "to_timestamp('2009-09-09', 'YYYY-MM-DD')".lit)
+    @d.filter('value > 500').update(:date_created => "to_timestamp('2009-09-09', 'YYYY-MM-DD')".lit)
     
     @d[:name => 'def'][:date_created].should == Time.parse('2009-09-09')
   end
@@ -289,34 +280,15 @@ end
 describe "Row locks in Oracle" do
   before do
     @d1 = ORACLE_DB[:books]
-    @d1.delete # remove all records
+    @d1.delete
     @d1 << {:id => 1, :title => 'aaa'}
   end
 
   specify "#for_update should use FOR UPDATE" do
-    @d1.for_update.sql.should == "SELECT * FROM BOOKS FOR UPDATE"
+    @d1.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"
-  end
-
-  specify "should not update during row lock" do
-    ORACLE_DB.transaction do
-      @d1.filter(:id => 1).for_update.to_a
-      proc do
-        t1 = Thread.start do
-          # wait for unlock
-          Timeout::timeout(0.02) do
-            ORACLE_DB[:books].filter(:id => 1).update(:title => "bbb")
-          end
-        end
-        t1.join
-      end.should raise_error
-      @d1.filter(:id => 1).first[:title].should == "aaa"
-    end
-    t2 = Thread.start { ORACLE_DB[:books].filter(:id => 1).update(:title => "bbb") }
-    t2.join
-    @d1.filter(:id => 1).first[:title].should == "bbb"
+    @d1.lock_style(:update).sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
   end
 end

data/spec/adapters/postgres_spec.rb

@@ -197,35 +197,39 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
     
     specify "should handle FOR UPDATE" do
       @ds.insert(:number=>20)
-      c = nil
-      t = nil
+      c, t = nil, nil
+      q = Queue.new
       POSTGRES_DB.transaction do
         @ds.for_update.first(:id=>1)
         t = Thread.new do
           POSTGRES_DB.transaction do
+            q.push nil
             @ds.filter(:id=>1).update(:name=>'Jim')
             c = @ds.first(:id=>1)
+            q.push nil
           end
         end
-        sleep 0.01
+        q.pop
         @ds.filter(:id=>1).update(:number=>30)
       end
+      q.pop
       t.join
       c.should == {:id=>1, :number=>30, :name=>'Jim'}
     end
   
     specify "should handle FOR SHARE" do
       @ds.insert(:number=>20)
-      c = nil
-      t = nil
+      c, t = nil
+      q = Queue.new
       POSTGRES_DB.transaction do
         @ds.for_share.first(:id=>1)
         t = Thread.new do
           POSTGRES_DB.transaction do
             c = @ds.for_share.filter(:id=>1).first
+            q.push nil
           end
         end
-        sleep 0.1
+        q.pop
         @ds.filter(:id=>1).update(:name=>'Jim')
         c.should == {:id=>1, :number=>20, :name=>nil}
       end
@@ -351,17 +355,17 @@ describe "A PostgreSQL database" do
   specify "should support opclass specification" do
     @db.create_table(:posts){text :title; text :body; integer :user_id; index(:user_id, :opclass => :int4_ops, :type => :btree)}
     @db.sqls.should == [
-    "CREATE TABLE posts (title text, body text, user_id integer)",
-    "CREATE INDEX posts_user_id_index ON posts USING btree (user_id int4_ops)"
+    'CREATE TABLE "posts" ("title" text, "body" text, "user_id" integer)',
+    'CREATE INDEX "posts_user_id_index" ON "posts" USING btree ("user_id" int4_ops)'
     ]
   end
 
   specify "should support fulltext indexes and searching" do
     @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french'}
     @db.sqls.should == [
-      "CREATE TABLE posts (title text, body text)",
-      "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))",
-      "CREATE INDEX posts_title_index ON posts USING gin (to_tsvector('french', (COALESCE(title, ''))))"
+      %{CREATE TABLE "posts" ("title" text, "body" text)},
+      %{CREATE INDEX "posts_title_body_index" ON "posts" USING gin (to_tsvector('simple', (COALESCE("title", '') || ' ' || COALESCE("body", ''))))},
+      %{CREATE INDEX "posts_title_index" ON "posts" USING gin (to_tsvector('french', (COALESCE("title", ''))))}
     ]
 
     @db[:posts].insert(:title=>'ruby rails', :body=>'yowsa')
@@ -373,48 +377,48 @@ describe "A PostgreSQL database" do
     @db[:posts].full_text_search([:title, :body], ['yowsa', 'rails']).all.should == [:title=>'ruby rails', :body=>'yowsa']
     @db[:posts].full_text_search(:title, 'scooby', :language => 'french').all.should == [{:title=>'ruby scooby', :body=>'x'}]
     @db.sqls.should == [
-      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, ''))) @@ to_tsquery('simple', 'rails'))",
-      "SELECT * FROM posts WHERE (to_tsvector('simple', (COALESCE(title, '') || ' ' || COALESCE(body, ''))) @@ to_tsquery('simple', 'yowsa | rails'))",
-      "SELECT * FROM posts WHERE (to_tsvector('french', (COALESCE(title, ''))) @@ to_tsquery('french', 'scooby'))"]
+      %{SELECT * FROM "posts" WHERE (to_tsvector('simple', (COALESCE("title", ''))) @@ to_tsquery('simple', 'rails'))},
+      %{SELECT * FROM "posts" WHERE (to_tsvector('simple', (COALESCE("title", '') || ' ' || COALESCE("body", ''))) @@ to_tsquery('simple', 'yowsa | rails'))},
+      %{SELECT * FROM "posts" WHERE (to_tsvector('french', (COALESCE("title", ''))) @@ to_tsquery('french', 'scooby'))}]
   end
 
   specify "should support spatial indexes" do
     @db.create_table(:posts){box :geom; spatial_index [:geom]}
     @db.sqls.should == [
-      "CREATE TABLE posts (geom box)",
-      "CREATE INDEX posts_geom_index ON posts USING gist (geom)"
+      'CREATE TABLE "posts" ("geom" box)',
+      'CREATE INDEX "posts_geom_index" ON "posts" USING gist ("geom")'
     ]
   end
   
   specify "should support indexes with index type" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'hash'}
     @db.sqls.should == [
-      "CREATE TABLE posts (title varchar(5))",
-      "CREATE INDEX posts_title_index ON posts USING hash (title)"
+      'CREATE TABLE "posts" ("title" varchar(5))',
+      'CREATE INDEX "posts_title_index" ON "posts" USING hash ("title")'
     ]
   end
   
   specify "should support unique indexes with index type" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'btree', :unique => true}
     @db.sqls.should == [
-      "CREATE TABLE posts (title varchar(5))",
-      "CREATE UNIQUE INDEX posts_title_index ON posts USING btree (title)"
+      'CREATE TABLE "posts" ("title" varchar(5))',
+      'CREATE UNIQUE INDEX "posts_title_index" ON "posts" USING btree ("title")'
     ]
   end
   
   specify "should support partial indexes" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
     @db.sqls.should == [
-      "CREATE TABLE posts (title varchar(5))",
-      "CREATE INDEX posts_title_index ON posts (title) WHERE (title = '5')"
+      'CREATE TABLE "posts" ("title" varchar(5))',
+      'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
     ]
   end
   
   specify "should support identifiers for table names in indicies" do
     @db.create_table(Sequel::SQL::Identifier.new(:posts)){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
     @db.sqls.should == [
-      "CREATE TABLE posts (title varchar(5))",
-      "CREATE INDEX posts_title_index ON posts (title) WHERE (title = '5')"
+      'CREATE TABLE "posts" ("title" varchar(5))',
+      'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
     ]
   end
   
@@ -442,8 +446,8 @@ describe "Postgres::Dataset#import" do
     
     @db.sqls.should == [
       'BEGIN',
-      'INSERT INTO test (x, y) VALUES (1, 2)',
-      'INSERT INTO test (x, y) VALUES (3, 4)',
+      'INSERT INTO "test" ("x", "y") VALUES (1, 2)',
+      'INSERT INTO "test" ("x", "y") VALUES (3, 4)',
       'COMMIT'
     ]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
@@ -456,7 +460,7 @@ describe "Postgres::Dataset#import" do
     
     @db.sqls.should == [
       'BEGIN',
-      'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)',
+      'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)',
       'COMMIT'
     ]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
@@ -487,10 +491,10 @@ describe "Postgres::Dataset#insert" do
     @ds.insert(:value=>13).should == 3
     
     @db.sqls.reject{|x| x =~ /pg_class/}.should == [
-      'INSERT INTO test5 (value) VALUES (10) RETURNING xid',
-      'INSERT INTO test5 (value) VALUES (20)',
+      'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"',
+      'INSERT INTO "test5" ("value") VALUES (20)',
       "SELECT currval('\"public\".test5_xid_seq')",
-      'INSERT INTO test5 (value) VALUES (13)',
+      'INSERT INTO "test5" ("value") VALUES (13)',
       "SELECT currval('\"public\".test5_xid_seq')"
     ]
     @ds.all.should == [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}, {:xid=>3, :value=>13}]
@@ -498,25 +502,20 @@ describe "Postgres::Dataset#insert" do
   
   specify "should call execute_insert if server_version < 80200" do
     @ds.meta_def(:server_version){80100}
-    @ds.should_receive(:execute_insert).once.with('INSERT INTO test5 (value) VALUES (10)', :table=>:test5, :values=>{:value=>10})
+    @ds.should_receive(:execute_insert).once.with('INSERT INTO "test5" ("value") VALUES (10)', :table=>:test5, :values=>{:value=>10})
     @ds.insert(:value=>10)
   end
 
   specify "should call execute_insert if disabling insert returning" do
     @ds.disable_insert_returning!
-    @ds.should_receive(:execute_insert).once.with('INSERT INTO test5 (value) VALUES (10)', :table=>:test5, :values=>{:value=>10})
+    @ds.should_receive(:execute_insert).once.with('INSERT INTO "test5" ("value") VALUES (10)', :table=>:test5, :values=>{:value=>10})
     @ds.insert(:value=>10)
   end
 
   specify "should use INSERT RETURNING if server_version >= 80200" do
     @ds.meta_def(:server_version){80201}
     @ds.insert(:value=>10)
-    @db.sqls.last.should == 'INSERT INTO test5 (value) VALUES (10) RETURNING xid'
-  end
-
-  specify "should have insert_returning_sql use the RETURNING keyword" do
-    @ds.insert_returning_sql(:xid, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING xid"
-    @ds.insert_returning_sql('*'.lit, :value=>10).should == "INSERT INTO test5 (value) VALUES (10) RETURNING *"
+    @db.sqls.last.should == 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"'
   end
 
   specify "should have insert_select return nil if server_version < 80200" do
@@ -606,12 +605,6 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB.drop_table(:domains)
   end
   
-  specify "#table_exists? should not include tables from the default non-public schemas" do
-    POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
-    POSTGRES_DB.table_exists?(:schema_test).should == true
-    POSTGRES_DB.table_exists?(:domain_udt_usage).should == false
-  end
-  
   specify "#table_exists? should see if the table is in a given schema" do
     POSTGRES_DB.create_table(:schema_test__schema_test){integer :i}
     POSTGRES_DB.table_exists?(:schema_test__schema_test).should == true
@@ -909,7 +902,7 @@ describe "Postgres::Database functions, languages, and triggers" do
   after do
     @d.drop_function('tf', :if_exists=>true, :cascade=>true)
     @d.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>%w'integer integer')
-    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
     @d.drop_table(:test) rescue nil
   end
 
@@ -940,19 +933,19 @@ describe "Postgres::Database functions, languages, and triggers" do
   
   specify "#create_language and #drop_language should create and drop languages" do
     @d.send(:create_language_sql, :plpgsql).should == 'CREATE LANGUAGE plpgsql'
-    @d.create_language(:plpgsql, :replace=>true)
+    @d.create_language(:plpgsql, :replace=>true) if @d.server_version < 90000
     proc{@d.create_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
     @d.send(:drop_language_sql, :plpgsql).should == 'DROP LANGUAGE plpgsql'
-    @d.drop_language(:plpgsql)
-    proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
+    @d.drop_language(:plpgsql) if @d.server_version < 90000
+    proc{@d.drop_language(:plpgsql)}.should raise_error(Sequel::DatabaseError) if @d.server_version < 90000
     @d.send(:create_language_sql, :plpgsql, :replace=>true, :trusted=>true, :handler=>:a, :validator=>:b).should == (@d.server_version >= 90000 ? 'CREATE OR REPLACE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b' : 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b')
     @d.send(:drop_language_sql, :plpgsql, :if_exists=>true, :cascade=>true).should == 'DROP LANGUAGE IF EXISTS plpgsql CASCADE'
     # Make sure if exists works
-    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
   end
   
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
-    @d.create_language(:plpgsql)
+    @d.create_language(:plpgsql) if @d.server_version < 90000
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
     @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON test FOR EACH ROW EXECUTE PROCEDURE tf()'
     @d.create_table(:test){String :name; Integer :value}
@@ -973,17 +966,17 @@ describe "Postgres::Database functions, languages, and triggers" do
 end
 
 if POSTGRES_DB.adapter_scheme == :postgres
-describe "Postgres::Dataset #use_cursor" do
-  before(:all) do
-    @db = POSTGRES_DB
-    @db.create_table!(:test_cursor){Integer :x}
-    @db.sqls.clear
-    @ds = @db[:test_cursor]
-    @db.transaction{1001.times{|i| @ds.insert(i)}}
-  end
-  after(:all) do
-    @db.drop_table(:test) rescue nil
-  end
+  describe "Postgres::Dataset #use_cursor" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_cursor){Integer :x}
+      @db.sqls.clear
+      @ds = @db[:test_cursor]
+      @db.transaction{1001.times{|i| @ds.insert(i)}}
+    end
+    after(:all) do
+      @db.drop_table(:test_cursor) rescue nil
+    end
   
     specify "should return the same results as the non-cursor use" do
       @ds.all.should == @ds.use_cursor.all
@@ -1005,5 +998,164 @@ describe "Postgres::Dataset #use_cursor" do
       @ds.check_return
       @ds.all.should == @ds.use_cursor.all
     end
+  end
+
+  describe "Postgres::PG_NAMED_TYPES" do
+    before do
+      @db = POSTGRES_DB
+      Sequel::Postgres::PG_NAMED_TYPES[:interval] = lambda{|v| v.reverse}
+      @db.instance_eval do
+        disconnect
+        @conversion_procs = nil
+      end 
+    end
+    after do
+      Sequel::Postgres::PG_NAMED_TYPES.delete(:interval)
+      @db.instance_eval do
+        disconnect
+        @conversion_procs = nil
+      end
+      @db.drop_table(:foo)
+    end
+
+    specify "should look up conversion procs by name" do
+      @db.create_table!(:foo){interval :bar}
+      @db[:foo].insert('21 days')
+      @db[:foo].get(:bar).should == 'syad 12'
+    end
+  end
 end
+
+if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRES_DB.server_version >= 90000
+  describe "Postgres::Database#copy_table" do
+    before(:all) do
+      @db = POSTGRES_DB
+      @db.create_table!(:test_copy){Integer :x; Integer :y}
+      ds = @db[:test_copy]
+      ds.insert(1, 2)
+      ds.insert(3, 4)
+    end
+    after(:all) do
+      @db.drop_table(:test_copy) rescue nil
+    end
+  
+    specify "without a block or options should return a text version of the table as a single string" do
+      @db.copy_table(:test_copy).should == "1\t2\n3\t4\n"
+    end
+
+    specify "without a block and with :format=>:csv should return a csv version of the table as a single string" do
+      @db.copy_table(:test_copy, :format=>:csv).should == "1,2\n3,4\n"
+    end
+  
+    specify "should treat string as SQL code" do
+      @db.copy_table('COPY "test_copy" TO STDOUT').should == "1\t2\n3\t4\n"
+    end
+  
+    specify "should respect given :options options" do
+      @db.copy_table(:test_copy, :options=>"FORMAT csv, HEADER TRUE").should == "x,y\n1,2\n3,4\n"
+    end
+  
+    specify "should respect given :options options when :format is used" do
+      @db.copy_table(:test_copy, :format=>:csv, :options=>"QUOTE '''', FORCE_QUOTE *").should == "'1','2'\n'3','4'\n"
+    end
+  
+    specify "should accept dataset as first argument" do
+      @db.copy_table(@db[:test_copy].cross_join(:test_copy___tc).order(1, 2, 3, 4)).should == "1\t2\t1\t2\n1\t2\t3\t4\n3\t4\t1\t2\n3\t4\t3\t4\n"
+    end
+  
+    specify "with a block and no options should yield each row as a string in text format" do
+      buf = []
+      @db.copy_table(:test_copy){|b| buf << b}
+      buf.should == ["1\t2\n", "3\t4\n"]
+    end
+  
+    specify "with a block and :format=>:csv should yield each row as a string in csv format" do
+      buf = []
+      @db.copy_table(:test_copy, :format=>:csv){|b| buf << b}
+      buf.should == ["1,2\n", "3,4\n"]
+    end
+  
+    specify "should work fine when using a block that is terminated early with a following copy_table" do
+      buf = []
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; raise ArgumentError}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      @db.copy_table(:test_copy){|b| buf << b}
+      buf.should == ["1\t2\n", "3\t4\n"]
+    end
+  
+    specify "should work fine when using a block that is terminated early with a following regular query" do
+      buf = []
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; break}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      buf.clear
+      proc{@db.copy_table(:test_copy, :format=>:csv){|b| buf << b; raise ArgumentError}}.should raise_error(Sequel::DatabaseDisconnectError)
+      buf.should == ["1,2\n"]
+      @db[:test_copy].select_order_map(:x).should == [1, 3]
+    end
+  end  
+
+  describe "Postgres::Database LISTEN/NOTIFY" do
+    before(:all) do
+      @db = POSTGRES_DB
+    end
+  
+    specify "should support listen and notify" do
+      notify_pid = @db.synchronize{|conn| conn.backend_pid}
+
+      called = false
+      @db.listen('foo', :after_listen=>proc{@db.notify('foo')}) do |ev, pid, payload|
+        ev.should == 'foo'
+        pid.should == notify_pid
+        ['', nil].should include(payload)
+        called = true
+      end.should == 'foo'
+      called.should be_true
+
+      called = false
+      @db.listen('foo', :after_listen=>proc{@db.notify('foo', :payload=>'bar')}) do |ev, pid, payload|
+        ev.should == 'foo'
+        pid.should == notify_pid
+        payload.should == 'bar'
+        called = true
+      end.should == 'foo'
+      called.should be_true
+
+      @db.listen('foo', :after_listen=>proc{@db.notify('foo')}).should == 'foo'
+
+      called = false
+      called2 = false
+      i = 0
+      @db.listen(['foo', 'bar'], :after_listen=>proc{@db.notify('foo', :payload=>'bar'); @db.notify('bar', :payload=>'foo')}, :loop=>proc{i+=1}) do |ev, pid, payload|
+        if !called
+          ev.should == 'foo'
+          pid.should == notify_pid
+          payload.should == 'bar'
+          called = true
+        else
+          ev.should == 'bar'
+          pid.should == notify_pid
+          payload.should == 'foo'
+          called2 = true
+          break
+        end
+      end.should be_nil
+      called.should be_true
+      called2.should be_true
+      i.should == 1
+    end
+
+    specify "should accept a :timeout option in listen" do
+      @db.listen('foo2', :timeout=>0.001).should == nil
+      called = false
+      @db.listen('foo2', :timeout=>0.001){|ev, pid, payload| called = true}.should == nil
+      called.should be_false
+      i = 0
+      @db.listen('foo2', :timeout=>0.001, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.should == nil
+      i.should == 4
+    end
+  end
 end

data/spec/adapters/spec_helper.rb

@@ -3,13 +3,17 @@ require 'logger'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
   require 'sequel'
-  Sequel.quote_identifiers = false
 end
 begin
   require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'spec_config.rb')
 rescue LoadError
 end
 
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
 class Sequel::Database
   def log_duration(duration, message)
     log_info(message)
@@ -26,11 +30,8 @@ end
     end 
   end 
 
-  def self.log_specify(message, &block)
-    specify(message){log{instance_eval(&block)}}
-  end
-
   def self.cspecify(message, *checked, &block)
+    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
     pending = false
     checked.each do |c|
       case c