sequel 3.21.0 → 3.32.0

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,51 @@ 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'))}]
+
+    @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
+    @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
   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
   
@@ -427,7 +434,7 @@ end
 describe "Postgres::Dataset#import" do
   before do
     @db = POSTGRES_DB
-    @db.create_table!(:test){Integer :x; Integer :y}
+    @db.create_table!(:test){primary_key :x; Integer :y}
     @db.sqls.clear
     @ds = @db[:test]
   end
@@ -437,28 +444,45 @@ describe "Postgres::Dataset#import" do
   
   specify "#import should return separate insert statements if server_version < 80200" do
     @ds.meta_def(:server_version){80199}
-    
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    
-    @db.sqls.should == [
-      'BEGIN',
-      'INSERT INTO test (x, y) VALUES (1, 2)',
-      'INSERT INTO test (x, y) VALUES (3, 4)',
-      'COMMIT'
-    ]
+    @db.sqls.should == ['BEGIN', '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}]
   end
   
   specify "#import should a single insert statement if server_version >= 80200" do
     @ds.meta_def(:server_version){80200}
-    
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    
-    @db.sqls.should == [
-      'BEGIN',
-      'INSERT INTO test (x, y) VALUES (1, 2), (3, 4)',
-      'COMMIT'
-    ]
+    @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)', 'COMMIT']
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys for server_version < 80200" do
+    @ds.meta_def(:server_version){80199}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys for server_version >= 80200" do
+    @ds.meta_def(:server_version){80200}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys with :slice option for server_version < 80200" do
+    @ds.meta_def(:server_version){80199}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key, :slice=>1).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly when returning primary keys with :slice option for server_version >= 80200" do
+    @ds.meta_def(:server_version){80200}
+    @ds.import([:x, :y], [[1, 2], [3, 4]], :return=>:primary_key, :slice=>1).should == [1, 3]
+    @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
+  end
+  
+  specify "#import should work correctly with an arbitrary returning value" do
+    @ds.meta_def(:server_version){80200}
+    @ds.returning(:y, :x).import([:x, :y], [[1, 2], [3, 4]]).should == [{:y=>2, :x=>1}, {:y=>4, :x=>3}]
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
 end
@@ -487,36 +511,36 @@ 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}]
   end
   
-  specify "should call execute_insert if server_version < 80200" do
+  specify "should insert correctly 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.insert(:value=>10)
+    @ds.insert(:value=>10).should == 1
+    @ds.all.should == [{:xid=>1, :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.insert(:value=>10)
+  specify "should insert correctly if disabling insert returning" do
+    @ds.disable_insert_returning.insert(:value=>10).should == 1
+    @ds.all.should == [{:xid=>1, :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'
+  specify "should insert correctly if using a column array and a value array and server_version < 80200" do
+    @ds.meta_def(:server_version){80100}
+    @ds.insert([:value], [10]).should == 1
+    @ds.all.should == [{:xid=>1, :value=>10}]
   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 *"
+  specify "should use INSERT RETURNING if server_version >= 80200" do
+    @ds.meta_def(:server_version){80201}
+    @ds.insert(:value=>10).should == 1
+    @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,10 +630,16 @@ 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
+  specify "#schema should raise an exception if columns from tables in two separate schema are returned" do
+    POSTGRES_DB.create_table!(:public__domains){integer :d}
+    POSTGRES_DB.create_table(:schema_test__domains){integer :i}
+    begin
+      proc{POSTGRES_DB.schema(:domains)}.should raise_error(Sequel::Error)
+      POSTGRES_DB.schema(:public__domains).map{|x| x.first}.should == [:d]
+      POSTGRES_DB.schema(:schema_test__domains).map{|x| x.first}.should == [:i]
+    ensure
+      POSTGRES_DB.drop_table(:public__domains)
+    end
   end
   
   specify "#table_exists? should see if the table is in a given schema" do
@@ -909,7 +939,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 +970,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 +1003,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 +1035,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

data/spec/adapters/sqlite_spec.rb

@@ -66,6 +66,17 @@ describe "An SQLite database" do
     @db[:fk].all.should == [{:id=>1, :parent_id=>2}]
   end
   
+  specify "should support a use_timestamp_timezones setting" do
+    @db.create_table!(:time){Time :time}
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_string).should =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = false
+    @db[:time].delete
+    @db[:time].insert(Time.now)
+    @db[:time].get(:time.cast_string).should_not =~ /[-+]\d\d\d\d\z/
+    @db.use_timestamp_timezones = true
+  end
+  
   specify "should provide a list of existing tables" do
     @db.drop_table(:testing) rescue nil
     @db.tables.should be_a_kind_of(Array)
@@ -133,13 +144,6 @@ describe "An SQLite dataset" do
     @d = SQLITE_DB[:items]
   end
   
-  specify "should handle string pattern matches correctly" do
-    @d.literal(:x.like('a')).should == "(x LIKE 'a')"
-    @d.literal(~:x.like('a')).should == "NOT (x LIKE 'a')"
-    @d.literal(:x.ilike('a')).should == "(x LIKE 'a')"
-    @d.literal(~:x.ilike('a')).should == "NOT (x LIKE 'a')"
-  end
-
   specify "should raise errors if given a regexp pattern match" do
     proc{@d.literal(:x.like(/a/))}.should raise_error(Sequel::Error)
     proc{@d.literal(~:x.like(/a/))}.should raise_error(Sequel::Error)
@@ -164,27 +168,27 @@ end
 
 describe "An SQLite dataset AS clause" do
   specify "should use a string literal for :col___alias" do
-    SQLITE_DB.literal(:c___a).should == "c AS 'a'"
+    SQLITE_DB.literal(:c___a).should == "`c` AS 'a'"
   end
 
   specify "should use a string literal for :table__col___alias" do
-    SQLITE_DB.literal(:t__c___a).should == "t.c AS 'a'"
+    SQLITE_DB.literal(:t__c___a).should == "`t`.`c` AS 'a'"
   end
 
   specify "should use a string literal for :column.as(:alias)" do
-    SQLITE_DB.literal(:c.as(:a)).should == "c AS 'a'"
+    SQLITE_DB.literal(:c.as(:a)).should == "`c` AS 'a'"
   end
 
   specify "should use a string literal in the SELECT clause" do
-    SQLITE_DB[:t].select(:c___a).sql.should == "SELECT c AS 'a' FROM t"
+    SQLITE_DB[:t].select(:c___a).sql.should == "SELECT `c` AS 'a' FROM `t`"
   end
 
   specify "should use a string literal in the FROM clause" do
-    SQLITE_DB[:t___a].sql.should == "SELECT * FROM t AS 'a'"
+    SQLITE_DB[:t___a].sql.should == "SELECT * FROM `t` AS 'a'"
   end
 
   specify "should use a string literal in the JOIN clause" do
-    SQLITE_DB[:t].join_table(:natural, :j, nil, :a).sql.should == "SELECT * FROM t NATURAL JOIN j AS 'a'"
+    SQLITE_DB[:t].join_table(:natural, :j, nil, :a).sql.should == "SELECT * FROM `t` NATURAL JOIN `j` AS 'a'"
   end
 end
 
@@ -313,6 +317,15 @@ describe "A SQLite database" do
     @db[:test2].first.should == {:name => 'mmm'}
   end
 
+  specify "should keep a composite primary key when dropping columns" do
+    @db.create_table!(:test2){Integer :a; Integer :b; Integer :c; primary_key [:a, :b]}
+    @db.drop_column :test2, :c
+    @db[:test2].columns.should == [:a, :b]
+    @db[:test2] << {:a=>1, :b=>2}
+    @db[:test2] << {:a=>2, :b=>3}
+    proc{@db[:test2] << {:a=>2, :b=>3}}.should raise_error(Sequel::Error)
+  end
+
   specify "should keep column attributes when dropping a column" do
     @db.create_table! :test3 do
       primary_key :id
@@ -412,14 +425,15 @@ describe "A SQLite database" do
   specify "should choose a temporary table name that isn't already used when dropping or renaming columns" do
     sqls = []
     @db.loggers << (l=Class.new{%w'info error'.each{|m| define_method(m){|sql| sqls << sql}}}.new)
-    @db.create_table! :test3 do
+    @db.tables.each{|t| @db.drop_table(t) if t.to_s =~ /test3/}
+    @db.create_table :test3 do
       Integer :h
       Integer :i
     end
-    @db.create_table! :test3_backup0 do
+    @db.create_table :test3_backup0 do
       Integer :j
     end
-    @db.create_table! :test3_backup1 do
+    @db.create_table :test3_backup1 do
       Integer :k
     end
 
@@ -428,20 +442,20 @@ describe "A SQLite database" do
     @db[:test3_backup1].columns.should == [:k]
     sqls.clear
     @db.drop_column(:test3, :i)
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup2/}.should == true
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup[01]/}.should == false
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup2/}.should == true
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup[01]/}.should == false
     @db[:test3].columns.should == [:h]
     @db[:test3_backup0].columns.should == [:j]
     @db[:test3_backup1].columns.should == [:k]
 
-    @db.create_table! :test3_backup2 do
+    @db.create_table :test3_backup2 do
       Integer :l
     end
 
     sqls.clear
     @db.rename_column(:test3, :h, :i)
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup3/}.should == true
-    sqls.any?{|x| x =~ /\ACREATE TABLE.*test3_backup[012]/}.should == false
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup3/}.should == true
+    sqls.any?{|x| x =~ /\AALTER TABLE.*test3.*RENAME TO.*test3_backup[012]/}.should == false
     @db[:test3].columns.should == [:i]
     @db[:test3_backup0].columns.should == [:j]
     @db[:test3_backup1].columns.should == [:k]