sequel 2.11.0 → 2.12.0

data/spec/adapters/oracle_spec.rb

@@ -10,7 +10,7 @@ end
 ORACLE_DB.create_table :items do
   varchar2 :name, :size => 50
   number :value, :size => 38
-  
+  date :date_created
   index :value
 end
 
@@ -38,10 +38,30 @@ context "An Oracle database" do
     ORACLE_DB.disconnect
     ORACLE_DB.pool.size.should == 0
   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 => 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
+    end
+  end
 end
 
 context "An Oracle dataset" do
-  setup do
+  before do
     @d = ORACLE_DB[:items]
     @d.delete # remove all records
   end
@@ -61,52 +81,52 @@ context "An Oracle dataset" do
     @d << {:name => 'def', :value => 789}
 
     @d.order(:value).to_a.should == [
-      {:name => 'abc', :value => 123},
-      {:name => 'abc', :value => 456},
-      {:name => 'def', :value => 789}
+      {:date_created=>nil, :name => 'abc', :value => 123},
+      {:date_created=>nil, :name => 'abc', :value => 456},
+      {:date_created=>nil, :name => 'def', :value => 789}
     ]
 
-    @d.select(:name).uniq.order_by(:name).to_a.should == [
+    @d.select(:name).distinct.order_by(:name).to_a.should == [
       {:name => 'abc'},
       {:name => 'def'}
     ]
            
     @d.order(:value.desc).limit(1).to_a.should == [
-      {:name => 'def', :value => 789}                                        
+      {:date_created=>nil, :name => 'def', :value => 789}                                        
     ]
 
     @d.filter(:name => 'abc').to_a.should == [
-      {:name => 'abc', :value => 123},
-      {:name => 'abc', :value => 456} 
+      {:date_created=>nil, :name => 'abc', :value => 123},
+      {:date_created=>nil, :name => 'abc', :value => 456} 
     ]
     
     @d.order(:value.desc).filter(:name => 'abc').to_a.should == [
-      {:name => 'abc', :value => 456},
-      {:name => 'abc', :value => 123} 
+      {:date_created=>nil, :name => 'abc', :value => 456},
+      {:date_created=>nil, :name => 'abc', :value => 123} 
     ]
 
     @d.filter(:name => 'abc').limit(1).to_a.should == [
-      {:name => 'abc', :value => 123}                                        
+      {:date_created=>nil, :name => 'abc', :value => 123}                                        
     ]
         
     @d.filter(:name => 'abc').order(:value.desc).limit(1).to_a.should == [
-      {:name => 'abc', :value => 456}                                        
+      {:date_created=>nil, :name => 'abc', :value => 456}                                        
     ]
     
     @d.filter(:name => 'abc').order(:value).limit(1).to_a.should == [
-      {:name => 'abc', :value => 123}                                        
+      {:date_created=>nil, :name => 'abc', :value => 123}                                        
     ]
         
     @d.order(:value).limit(1).to_a.should == [
-      {:name => 'abc', :value => 123}                                        
+      {:date_created=>nil, :name => 'abc', :value => 123}                                        
     ]
 
     @d.order(:value).limit(1, 1).to_a.should == [
-      {:name => 'abc', :value => 456}
+      {:date_created=>nil, :name => 'abc', :value => 456}
     ]
 
     @d.order(:value).limit(1, 2).to_a.should == [
-      {:name => 'def', :value => 789}
+      {:date_created=>nil, :name => 'def', :value => 789}
     ]    
     
     @d.avg(:value).to_i.should == (789+123+456)/3
@@ -155,6 +175,14 @@ context "An Oracle dataset" do
     @d[:name => 'def'][:value].should == 789
     @d.filter(:value => 530).count.should == 2
   end
+
+  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[:name => 'def'][:date_created].should == Time.parse('2009-09-09')
+  end
   
   specify "should delete records correctly" do
     @d << {:name => 'abc', :value => 123}
@@ -181,7 +209,7 @@ context "An Oracle dataset" do
 end
 
 context "Joined Oracle dataset" do
-  setup do
+  before do
     @d1 = ORACLE_DB[:books]
     @d1.delete # remove all records
     @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
@@ -222,7 +250,7 @@ context "Joined Oracle dataset" do
 end
 
 context "Oracle aliasing" do
-  setup do
+  before do
     @d1 = ORACLE_DB[:books]
     @d1.delete # remove all records
     @d1 << {:id => 1, :title => 'aaa', :category_id => 100}

data/spec/adapters/postgres_spec.rb

@@ -27,7 +27,7 @@ POSTGRES_DB.create_table! :test5 do
 end
 
 context "A PostgreSQL database" do
-  setup do
+  before do
     @db = POSTGRES_DB
   end
   
@@ -57,14 +57,10 @@ context "A PostgreSQL database" do
       [:value, {:type=>:blob, :allow_null=>true, :default=>nil, :db_type=>"bytea", :primary_key=>false}]
     ]
   end
-
-  specify "should get the schema all database tables if no table name is used" do
-    @db.schema(:test3, :reload=>true).should == @db.schema(nil, :reload=>true)[:test3]
-  end
 end
 
 context "A PostgreSQL dataset" do
-  setup do
+  before do
     @d = POSTGRES_DB[:test]
     @d.delete # remove all records
   end
@@ -160,6 +156,9 @@ context "A PostgreSQL dataset" do
 
     @d.insert_sql(:x => :y).should =~ \
       /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
+
+    @d.disable_insert_returning.insert_sql(:value => 333).should =~ \
+      /\AINSERT INTO "test" \("value"\) VALUES \(333\)\z/
   end
   
   specify "should quote fields correctly when reversing the order if quoting identifiers" do
@@ -199,6 +198,13 @@ context "A PostgreSQL dataset" do
       end
     end.should raise_error(Interrupt)
 
+    proc do
+      POSTGRES_DB.transaction do
+        @d << {:name => 'abc', :value => 1}
+        raise Sequel::Rollback
+      end
+    end.should_not raise_error
+
     @d.count.should == 0
   end
   
@@ -224,29 +230,28 @@ context "A PostgreSQL dataset" do
     @d.count.should == 2
   end
 
-  specify "should support nested transactions through savepoints" do
+  specify "should support nested transactions through savepoints using the savepoint option" do
     POSTGRES_DB.transaction do
       @d << {:name => '1'}
-      POSTGRES_DB.transaction do
+      POSTGRES_DB.transaction(:savepoint=>true) do
         @d << {:name => '2'}
         POSTGRES_DB.transaction do
           @d << {:name => '3'}
-          raise Sequel::Error::Rollback
+          raise Sequel::Rollback
         end
-        @d << {:name => '4'}
-        POSTGRES_DB.transaction do
-          @d << {:name => '6'}
-          POSTGRES_DB.transaction do
-            @d << {:name => '7'}
-          end
-          raise Sequel::Error::Rollback
+      end
+      @d << {:name => '4'}
+      POSTGRES_DB.transaction do
+        @d << {:name => '6'}
+        POSTGRES_DB.transaction(:savepoint=>true) do
+          @d << {:name => '7'}
+          raise Sequel::Rollback
         end
-        @d << {:name => '5'}
       end
+      @d << {:name => '5'}
     end
 
-    @d.count.should == 4
-    @d.order(:name).map(:name).should == %w{1 2 4 5}
+    @d.order(:name).map(:name).should == %w{1 4 5 6}
   end
 
   specify "should support regexps" do
@@ -265,16 +270,16 @@ context "A PostgreSQL dataset" do
   end
 
   specify "should properly escape binary data" do
-    POSTGRES_DB['SELECT ? AS a', "\1\2\3".to_blob].get(:a) == "\1\2\3"
+    POSTGRES_DB['SELECT ? AS a', "\1\2\3".to_sequel_blob].get(:a) == "\1\2\3"
   end
 
   specify "should retrieve binary data as Blob object" do
     d = POSTGRES_DB[:test4]
-    d << {:name => '123', :value => "\1\2\3".to_blob}
+    d << {:name => '123', :value => "\1\2\3".to_sequel_blob}
     retrieved_binary_value = d[:name => '123'][:value]
     retrieved_binary_value.should be_a_kind_of(::Sequel::SQL::Blob)
     retrieved_binary_value.should == "\1\2\3"
-    retrieved_binary_value = d[:value => "\1\2\3".to_blob][:value]
+    retrieved_binary_value = d[:value => "\1\2\3".to_sequel_blob][:value]
     retrieved_binary_value.should be_a_kind_of(::Sequel::SQL::Blob)
     retrieved_binary_value.should == "\1\2\3"
   end
@@ -285,7 +290,7 @@ context "A PostgreSQL dataset" do
 end
 
 context "A PostgreSQL dataset with a timestamp field" do
-  setup do
+  before do
     @d = POSTGRES_DB[:test3]
     @d.delete
   end
@@ -299,7 +304,7 @@ context "A PostgreSQL dataset with a timestamp field" do
 end
 
 context "A PostgreSQL database" do
-  setup do
+  before do
     @db = POSTGRES_DB
   end
 
@@ -337,7 +342,7 @@ context "A PostgreSQL database" do
 end  
 
 context "A PostgreSQL database" do
-  setup do
+  before do
   end
   
   specify "should support fulltext indexes" do
@@ -346,7 +351,7 @@ context "A PostgreSQL database" do
       text :body
       full_text_index [:title, :body]
     end
-    POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
+    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).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, ''))))"
     ]
@@ -358,7 +363,7 @@ context "A PostgreSQL database" do
       text :body
       full_text_index [:title, :body], :language => 'french'
     end
-    POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
+    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
       "CREATE TABLE posts (title text, body text)",
       "CREATE INDEX posts_title_body_index ON posts USING gin (to_tsvector('french', (COALESCE(title, '') || ' ' || COALESCE(body, ''))))"
     ]
@@ -380,7 +385,7 @@ context "A PostgreSQL database" do
       geometry :geom
       spatial_index [:geom]
     end
-    POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
+    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
       "CREATE TABLE posts (geom geometry)",
       "CREATE INDEX posts_geom_index ON posts USING gist (geom)"
     ]
@@ -391,7 +396,7 @@ context "A PostgreSQL database" do
       varchar :title, :size => 5
       index :title, :type => 'hash'
     end
-    POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
+    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
       "CREATE TABLE posts (title varchar(5))",
       "CREATE INDEX posts_title_index ON posts USING hash (title)"
     ]
@@ -402,7 +407,7 @@ context "A PostgreSQL database" do
       varchar :title, :size => 5
       index :title, :type => 'hash', :unique => true
     end
-    POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
+    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
       "CREATE TABLE posts (title varchar(5))",
       "CREATE UNIQUE INDEX posts_title_index ON posts USING hash (title)"
     ]
@@ -413,7 +418,7 @@ context "A PostgreSQL database" do
       varchar :title, :size => 5
       index :title, :where => {:something => 5}
     end
-    POSTGRES_DB.create_table_sql_list(:posts, *g.create_info).should == [
+    POSTGRES_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [
       "CREATE TABLE posts (title varchar(5))",
       "CREATE INDEX posts_title_index ON posts (title) WHERE (something = 5)"
     ]
@@ -424,15 +429,15 @@ context "A PostgreSQL database" do
       varchar :title, :size => 5
       index :title, :where => {:something => 5}
     end
-    POSTGRES_DB.create_table_sql_list(Sequel::SQL::Identifier.new(:posts__test), *g.create_info).should == [
+    POSTGRES_DB.send(:create_table_sql_list, Sequel::SQL::Identifier.new(:posts__test), *g.create_info).should == [
       "CREATE TABLE posts__test (title varchar(5))",
       "CREATE INDEX posts__test_title_index ON posts__test (title) WHERE (something = 5)"
     ]
   end
 end
 
-context "Postgres::Dataset#multi_insert_sql / #import" do
-  setup do
+context "Postgres::Dataset#multi_insert_sql" do
+  before do
     @ds = POSTGRES_DB[:test]
   end
   
@@ -461,7 +466,7 @@ context "Postgres::Dataset#multi_insert_sql / #import" do
 end
 
 context "Postgres::Dataset#insert" do
-  setup do
+  before do
     @ds = POSTGRES_DB[:test5]
     @ds.delete
   end
@@ -472,9 +477,16 @@ context "Postgres::Dataset#insert" do
     @ds.insert(:value=>10)
   end
 
+  specify "should call insert_sql 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)
+  end
+
   specify "should use INSERT RETURNING if server_version >= 80200" do
     @ds.meta_def(:server_version){80201}
-    @ds.should_receive(:single_value).once.with(:server=>:default, :sql=>'INSERT INTO test5 (value) VALUES (10) RETURNING xid')
+    @ds.should_receive(:clone).once.with(:server=>:default, :sql=>'INSERT INTO test5 (value) VALUES (10) RETURNING xid').and_return(@ds)
+    @ds.should_receive(:single_value).once
     @ds.insert(:value=>10)
   end
 
@@ -512,12 +524,12 @@ context "Postgres::Dataset#insert" do
 end
 
 context "Postgres::Database schema qualified tables" do
-  setup do
+  before do
     POSTGRES_DB << "CREATE SCHEMA schema_test"
     POSTGRES_DB.instance_variable_set(:@primary_keys, {})
     POSTGRES_DB.instance_variable_set(:@primary_key_sequences, {})
   end
-  teardown do
+  after do
     POSTGRES_DB << "DROP SCHEMA schema_test CASCADE"
     POSTGRES_DB.default_schema = :public
   end
@@ -618,10 +630,10 @@ if POSTGRES_DB.server_version >= 80300
 end
 
 context "Postgres::Database functions, languages, and triggers" do
-  setup do
+  before do
     @d = POSTGRES_DB
   end
-  teardown 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)
@@ -631,37 +643,37 @@ context "Postgres::Database functions, languages, and triggers" do
   specify "#create_function and #drop_function should create and drop functions" do
     proc{@d['SELECT tf()'].all}.should raise_error(Sequel::DatabaseError)
     args = ['tf', 'SELECT 1', {:returns=>:integer}]
-    @d.create_function_sql(*args).should =~ /\A\s*CREATE FUNCTION tf\(\)\s+RETURNS integer\s+LANGUAGE SQL\s+AS 'SELECT 1'\s*\z/
+    @d.send(:create_function_sql, *args).should =~ /\A\s*CREATE FUNCTION tf\(\)\s+RETURNS integer\s+LANGUAGE SQL\s+AS 'SELECT 1'\s*\z/
     @d.create_function(*args)
     rows = @d['SELECT tf()'].all.should == [{:tf=>1}]
-    @d.drop_function_sql('tf').should == 'DROP FUNCTION tf()'
+    @d.send(:drop_function_sql, 'tf').should == 'DROP FUNCTION tf()'
     @d.drop_function('tf')
     proc{@d['SELECT tf()'].all}.should raise_error(Sequel::DatabaseError)
   end
   
   specify "#create_function and #drop_function should support options" do
     args = ['tf', 'SELECT $1 + $2', {:args=>[[:integer, :a], :integer], :replace=>true, :returns=>:integer, :language=>'SQL', :behavior=>:immutable, :strict=>true, :security_definer=>true, :cost=>2, :set=>{:search_path => 'public'}}]
-    @d.create_function_sql(*args).should =~ /\A\s*CREATE OR REPLACE FUNCTION tf\(a integer, integer\)\s+RETURNS integer\s+LANGUAGE SQL\s+IMMUTABLE\s+STRICT\s+SECURITY DEFINER\s+COST 2\s+SET search_path = public\s+AS 'SELECT \$1 \+ \$2'\s*\z/
+    @d.send(:create_function_sql,*args).should =~ /\A\s*CREATE OR REPLACE FUNCTION tf\(a integer, integer\)\s+RETURNS integer\s+LANGUAGE SQL\s+IMMUTABLE\s+STRICT\s+SECURITY DEFINER\s+COST 2\s+SET search_path = public\s+AS 'SELECT \$1 \+ \$2'\s*\z/
     @d.create_function(*args)
     # Make sure replace works
     @d.create_function(*args)
     rows = @d['SELECT tf(1, 2)'].all.should == [{:tf=>3}]
     args = ['tf', {:if_exists=>true, :cascade=>true, :args=>[[:integer, :a], :integer]}]
-    @d.drop_function_sql(*args).should == 'DROP FUNCTION IF EXISTS tf(a integer, integer) CASCADE'
+    @d.send(:drop_function_sql,*args).should == 'DROP FUNCTION IF EXISTS tf(a integer, integer) CASCADE'
     @d.drop_function(*args)
     # Make sure if exists works
     @d.drop_function(*args)
   end
   
   specify "#create_language and #drop_language should create and drop languages" do
-    @d.create_language_sql(:plpgsql).should == 'CREATE LANGUAGE plpgsql'
+    @d.send(:create_language_sql, :plpgsql).should == 'CREATE LANGUAGE plpgsql'
     @d.create_language(:plpgsql)
     proc{@d.create_language(:plpgsql)}.should raise_error(Sequel::DatabaseError)
-    @d.drop_language_sql(:plpgsql).should == 'DROP LANGUAGE plpgsql'
+    @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.create_language_sql(:plpgsql, :trusted=>true, :handler=>:a, :validator=>:b).should == 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b'
-    @d.drop_language_sql(:plpgsql, :if_exists=>true, :cascade=>true).should == 'DROP LANGUAGE IF EXISTS plpgsql CASCADE'
+    @d.send(:create_language_sql, :plpgsql, :trusted=>true, :handler=>:a, :validator=>:b).should == '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)
   end
@@ -669,7 +681,7 @@ context "Postgres::Database functions, languages, and triggers" do
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
     @d.create_language(:plpgsql)
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
-    @d.create_trigger_sql(:test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON public.test FOR EACH ROW EXECUTE PROCEDURE tf()'
+    @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON public.test FOR EACH ROW EXECUTE PROCEDURE tf()'
     @d.create_trigger(:test, :identity, :tf, :each_row=>true)
     @d[:test].insert(:name=>'a', :value=>1)
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>1}]
@@ -677,10 +689,10 @@ context "Postgres::Database functions, languages, and triggers" do
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>1}]
     @d[:test].filter(:name=>'a').update(:value=>3)
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>3}]
-    @d.drop_trigger_sql(:test, :identity).should == 'DROP TRIGGER identity ON public.test'
+    @d.send(:drop_trigger_sql, :test, :identity).should == 'DROP TRIGGER identity ON public.test'
     @d.drop_trigger(:test, :identity)
-    @d.create_trigger_sql(:test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a']).should == 'CREATE TRIGGER identity AFTER INSERT ON public.test EXECUTE PROCEDURE tf(1, \'a\')'
-    @d.drop_trigger_sql(:test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON public.test CASCADE'
+    @d.send(:create_trigger_sql, :test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a']).should == 'CREATE TRIGGER identity AFTER INSERT ON public.test EXECUTE PROCEDURE tf(1, \'a\')'
+    @d.send(:drop_trigger_sql, :test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON public.test CASCADE'
     # Make sure if exists works
     @d.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
   end