rails-pg-procs 1.0.0

data/lib/connection_adapters/type_definition.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class TypeDefinition < Struct.new(:id, :name, :columns)
+
+      def to_sql(action="create", options={})
+        case action
+          when "create", :create
+              "CREATE SCHEMA #{name.to_sql_name} AUTHORIZATION #{owner.to_sql_name}"
+          # TODO - [ schema_element ]
+          when "drop", :drop
+            "DROP SCHEMA #{name.to_sql_name} #{cascade_or_restrict(options[:cascade])}"
+          # TODO - [ IF EXISTS ]
+        end
+      end
+    end
+  end
+end

data/lib/connection_adapters/view_definition.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class ViewDefinition
+      include SchemaProcs
+      attr_accessor :id, :name, :columns, :view_body
+      def initialize(id, name, columns=[], &block)
+        @id            = id
+        self.name      = name
+        self.columns   = columns
+        self.view_body = block
+      end
+
+      def to_rdl
+        "  create_view(#{ActiveSupport::Inflector.symbolize(name)}) { $#{name}_body$\n    #{view_body.call}\n  $#{name}_body$ }"
+			end
+
+#     CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] VIEW NAME [ ( column_name [, ...] ) ]
+#     AS query
+#     [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]
+#			DROP VIEW [ IF EXISTS ] NAME [, ...] [ CASCADE | RESTRICT ]
+      def to_sql(action="create", options={})
+        case action
+          when "create", :create
+            ret = "CREATE OR REPLACE#{' TEMPORARY' if options[:temp] } VIEW #{name.to_sql_name}
+            AS #{view_body.call}"
+				# TODO - [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]
+          when "drop", :drop
+            ret = "DROP VIEW #{name.to_sql_name} #{cascade_or_restrict(options[:cascade])}"
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/inflector.rb

@@ -0,0 +1,10 @@
+module ActiveSupport::Inflector
+  def triggerize(table_name, events=[], before=false)
+    events.join(" or ").gsub(":", "").tr(" ", "_").downcase + "_" + (before ? "before_" : "after_") + table_name.to_s + "_trigger"
+  end
+
+  def symbolize(val)
+    return "'#{val}'" if val =~ /-/
+    ":#{val}"
+  end
+end

data/lib/rails_pg_procs.rb

@@ -0,0 +1,8 @@
+require 'active_record'
+require "active_support/inflector"
+
+require 'lib/inflector'
+require 'lib/sql_format'
+require 'lib/schema_procs'
+require 'lib/schema_dumper'
+require 'lib/connection_adapters/connection_adapters'

data/lib/schema_dumper.rb

@@ -0,0 +1,96 @@
+module ActiveRecord
+  # This class is used to dump the database schema for some connection to some
+  # output format (i.e., ActiveRecord::Schema).
+  class SchemaDumper
+    include SchemaProcs
+
+    # TODO -Implement checks on SchemaDumper instance 
+    # to ensure we do this only when using pg db.
+    def postgres?
+      adapter_name == 'PostgreSQL'
+    end
+
+    private
+      def get_type(types)
+        case types
+          when Array
+            types.collect {|type|
+              get_type(type)
+            }.join(", ")
+          when String && /^\d+$/
+            type = @connection.select_value("SELECT typname FROM pg_type WHERE oid = '#{types}'")
+            return type = 'nil' if type == 'void'
+            get_type(type)
+          when String
+            return %("#{types}") if types =~ /[\s\(]/
+            ActiveSupport::Inflector.symbolize(types)
+        end
+      end
+
+      # TODO - Facilitate create_proc(name, [argname, argtype] and create_proc(name, [argmode, argname, argtype] ...
+      def procedures(stream, conditions=nil)
+        @connection.procedures(conditions).each { |proc_row|
+          oid, name, namespace, owner, lang, is_agg, sec_def, is_strict, ret_set, volatile, nargs, ret_type, arg_types, arg_names, src, bin, acl = proc_row
+          is_agg    = is_agg    == 't'
+          is_strict = is_strict == 't'
+          ret_set   = ret_set   == 't'
+          arg_names ||= ''
+          args      = get_type(arg_types.split(" "))#.zip(arg_names.split(" "))
+
+          stream.print "  create_proc(#{name.to_sql_name}, [#{args}], :return => #{get_type(ret_type)}"
+          stream.print ", :resource => ['#{bin}', '#{src}']" unless bin == '-'
+          stream.print ", :set => true" if ret_set
+          stream.print ", :strict => true" if is_strict
+          stream.print ", :behavior => '#{behavior(volatile)}'" unless volatile == 'v'
+          stream.print ", :lang => '#{lang}')"
+          stream.print " {\n    <<-#{ActiveSupport::Inflector.underscore(name)}_sql\n#{src.chomp}\n    #{ActiveSupport::Inflector.underscore(name)}_sql\n  }" if bin == '-'
+          stream.print "\n"
+        }
+      end
+
+      def schemas(stream)
+        schemas = @connection.schemas
+        schemas.each {|schema|
+          stream.puts schema.to_rdl
+        }
+        stream.puts unless schemas.empty?
+      end
+
+      def triggers(table_name, stream)
+        triggers = @connection.triggers(table_name)
+        triggers.each {|trigger|
+          stream.puts trigger.to_rdl
+        }
+        stream.puts unless triggers.empty?
+      end
+
+      def types(stream)
+        @connection.types.each {|type|
+          stream.print "  create_type #{type.name.to_sql_name}, "
+          stream.puts "#{ type.columns.collect{|column, type| "[#{ActiveSupport::Inflector.symbolize(column)}, #{get_type(type)}]"}.join(", ") }"
+        }
+      end
+
+      alias_method :procless_tables, :tables
+      def tables(stream)
+        schemas(stream)
+        types(stream)
+        procedures(stream, "!= 'sql'")
+        procless_tables(stream)
+        procedures(stream, "= 'sql'")
+      end
+
+      alias_method :schemaless_table, :table
+      def table table, stream
+        schemaless_table table, stream
+      end
+
+      alias_method :indexes_before_triggers, :indexes
+      def indexes(table, stream)
+#        schema, table = table.split '.'
+        indexes_before_triggers(table, stream)
+        triggers(table, stream)
+      end
+
+  end
+end

data/lib/schema_procs.rb

@@ -0,0 +1,19 @@
+module SchemaProcs
+  @@_cascade_or_restrict = Proc.new {|which| which     ? 'CASCADE' : 'RESTRICT' }
+  @@_strict_or_null      = Proc.new {|strict| strict   ? 'STRICT' : 'CALLED ON NULL INPUT' }
+  @@_definer_or_invoker  = Proc.new {|definer| definer ? 'DEFINER' : 'INVOKER' }
+  @@_behavior            = Proc.new {|volatile| %w{immutable stable volatile}.grep(/^#{volatile[0,1]}.+/).to_s }
+
+  def cascade_or_restrict(cascade=false)
+    @@_cascade_or_restrict.call(cascade)
+  end
+  def strict_or_null(is_strict=false)
+    @@_strict_or_null.call(is_strict)
+  end
+  def definer_or_invoker(definer=false)
+    @@_definer_or_invoker.call(definer)
+  end
+  def behavior(volatile='v')
+    @@_behavior.call(volatile)
+  end
+end

data/lib/sql_format.rb

@@ -0,0 +1,17 @@
+module SqlFormat
+  def to_sql_name
+    '"' + self.to_s + '"'
+  end
+
+  def to_sql_value
+    "'#{self}'"
+  end
+end
+
+class Symbol
+  include SqlFormat
+end
+
+class String
+  include SqlFormat
+end

data/tasks/rails_pg_procs.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rails_pg_procs do
+#   # Task goes here
+# end

data/test/connection.rb

@@ -0,0 +1,16 @@
+print "Using native PostgreSQL\n"
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'rails_pg_procs' => {
+    :adapter  => 'postgresql',
+    :username => 'postgres',
+    :database => 'activerecord_unittest',
+    :min_messages => 'warning',
+    :allow_concurrency => false
+  }
+}
+
+ActiveRecord::Base.establish_connection('rails_pg_procs') unless ActiveRecord::Base.connected?

data/test/procedure_test.rb

@@ -0,0 +1,78 @@
+require 'test_helper'
+
+class ProcedureTest < Test::Unit::TestCase
+  def test_create_proc
+    [
+      /logf()/,
+      /\'resource\/file\',\s\'method\'/,
+      /LANGUAGE C/
+    ].each {|re| 
+      assert_match(re, @connection.send("get_proc_query", "logf", [], :return => nil, :resource => ['resource/file', 'method'], :lang => "C"))
+    }
+
+    [
+      /logf()/,
+      /\'resource\/file\',\s\'logf\'/,
+      /LANGUAGE C/
+    ].each {|re| 
+      assert_match(re, @connection.send("get_proc_query", "logf", [], :return => nil, :resource => ['resource/file'], :lang => "C"))
+    }
+
+    [
+      /CREATE OR REPLACE FUNCTION "logf"()/,
+      /RETURNS VOID/,
+      /\$logf_body\$/,
+      Regexp.new(@query_body),
+      /LANGUAGE plpgsql/,
+      /IMMUTABLE/,
+      /STRICT/,
+      /EXTERNAL SECURITY DEFINER/
+    ].each {|re| 
+      assert_match(re, @connection.send("get_proc_query", "logf", [], :return => nil, :definer => true, :strict => true, :behavior => 'immutable') { @query_body })
+    }
+
+    [
+      /update_trade_materials_statuses_logf()/,
+      /RETURNS VOID/,
+      /\$update_trade_materials_statuses_logf_body\$/,
+      Regexp.new(@query_body),
+      /LANGUAGE SQL/,
+    ].each {|re| 
+      assert_match(re, @connection.send("get_proc_query", "update_trade_materials_statuses_logf", [], :return => nil, :lang => :SQL) { @query_body })
+    }
+
+    [
+      /update_trade_materials_statuses_logf()/,
+      /RETURNS trigger/,
+      /\$update_trade_materials_statuses_logf_body\$/,
+      Regexp.new(@query_body),
+      /LANGUAGE plpgsql/,
+      /VOLATILE/,
+      /CALLED ON NULL INPUT/,
+      /EXTERNAL SECURITY INVOKER/
+    ].each {|re| 
+      assert_match(re, @connection.send("get_proc_query", "update_trade_materials_statuses_logf", [], :return => "trigger") { @query_body })
+    }
+
+    assert_exception(ActiveRecord::StatementInvalid, "Missing block or library file.") {
+      @connection.create_proc("update_trade_materials_statuses_logf", [], :return => "trigger")
+    }
+
+    assert_nothing_raised {
+      @connection.create_proc(:update_trade_materials_statuses_logf, [], :return => :trigger) {
+        @query_body
+      }
+    }
+    count = @connection.select_value("select count(*) from pg_proc where proname = 'update_trade_materials_statuses_logf'", "count")
+    assert_equal("1", count)
+    assert_nothing_raised {
+      @connection.drop_proc("update_trade_materials_statuses_logf", [])
+    }
+    count = @connection.select_value("select count(*) from pg_proc where proname = 'update_trade_materials_statuses_logf'", "count")
+    assert_equal("0", count)
+
+    assert_equal('CASCADE',  @connection.send("cascade_or_restrict", true))
+    assert_equal('RESTRICT', @connection.send("cascade_or_restrict"))
+    assert_equal('RESTRICT', @connection.send("cascade_or_restrict", false))
+  end
+end

data/test/rails_pg_procs_test.rb

@@ -0,0 +1,246 @@
+require 'test_helper'
+
+
+class RailsPgProcsTest < Test::Unit::TestCase
+#  include ActiveRecord::ConnectionAdapters::SchemaStatements
+
+  def test_complicated_schema_dumper
+    with_proc(:update_trade_materials_statuses_logf, [], :return => :trigger) {
+      with_trigger(:test_table, [:insert, :update], :before => true, :name => :update_trade_materials_statuses_logt, :function => :update_trade_materials_statuses_logf) {
+        assert_no_exception(NoMethodError) do 
+          stream = StringIO.new
+          dumper = ActiveRecord::SchemaDumper.new(@connection)
+          dumper.send(:triggers, :test_table, stream)
+          stream.rewind
+          assert_match /add_trigger "test_table", [:insert, :update], :before => true, :name => :update_trade_materials_statuses_logt, :function => :update_trade_materials_statuses_logf/, stream.read
+
+          stream = StringIO.new
+          dumper.send(:procedures, stream)
+          stream.rewind
+          received_sql = stream.string
+          assert_match "  create_proc(\"update_trade_materials_statuses_logf\", [], :return => :trigger, :lang => 'plpgsql') {\n    <<-update_trade_materials_statuses_logf_sql\n\n#{@query_body}\n    update_trade_materials_statuses_logf_sql\n  }".to_regex, received_sql
+        end
+      }
+    }
+  end
+
+  def test_functional_dump
+    @connection.create_proc(:f_commacat, [:text, :text], :return => :text) { "BEGIN
+  IF (LENGTH($1) > 0 ) THEN
+     RETURN $1 || ', ' || $2;
+  ELSE
+     RETURN $2;
+  END IF;
+END;" }
+    begin
+      @connection.execute "DROP AGGREGATE comma(text);"
+      @connection.execute "CREATE AGGREGATE comma(BASETYPE=text, SFUNC=f_commacat, STYPE=text)"
+    rescue ActiveRecord::StatementInvalid
+    end
+
+    @connection.create_schema :somewhere, "postgres"
+    @connection.create_proc('somewhere_else.afunc', []) { "BEGIN\nEND;" }
+
+    @connection.create_schema :somewhere_else
+
+    @connection.create_type(:qualitysmith_user, [:name, :varchar], {:address => "varchar(20)"}, [:zip, "varchar(5)"], [:phone, "numeric(10,0)"])
+    @connection.create_proc("name-with-hyphen", [], :return => :trigger) { "  BEGIN\n--Something else goes here\nEND;\n" }
+    @connection.create_proc(:update_trade_materials_statuses_logf, [], :return => :trigger) { "  BEGIN\n--Something else goes here\nEND;\n" }
+    @connection.create_proc(:levenshtein, [], :return => :trigger, :resource => ['$libdir/fuzzystrmatch'], :lang => "c")
+    @connection.add_trigger(:test_table, [:insert, :update], :row => true, :name => "update_trade-materials_statuses_logt", :function => :update_trade_materials_statuses_logf)
+    @connection.add_trigger(:test_table, [:insert, :update], :function => :levenshtein)
+    @connection.create_table("a_table_defined_after_the_stored_proc", :force => true) {|t|
+      t.column :name, :varchar
+    }
+    @connection.drop_table "somewhere.table_in_a_specific_schema"
+    @connection.create_table "somewhere.table_in_a_specific_schema" do |t|
+      t.column :name, :text
+    end
+    @connection.create_proc(:sql_proc_with_table_reference, [:integer], :return => :integer, :lang => "SQL") { "SELECT id FROM a_table_defined_after_the_stored_proc WHERE id = $1;" }
+
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.ignore_tables = []
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+    received_sql = stream.string
+
+    assert_match(%q|create_schema(:somewhere_else, "postgres")|.to_regex, received_sql)
+    assert_match(%q|create_type(:qualitysmith_user, [:name, "character varying"], [:address, "character varying(20)"], [:zip, "character varying(5)"], [:phone, "numeric(10,0)"])|.to_regex, received_sql)
+    assert_match(%q|create_proc('name-with-hyphen'|.to_regex, received_sql)
+    assert_match(%q|create_proc(:update_trade_materials_statuses_logf|.to_regex, received_sql)
+    assert_match(%q|create_proc("levenshtein", []|.to_regex, received_sql)
+    assert_match(%q|add_trigger(:test_table, [:insert, :update], :function => :levenshtein)|.to_regex, received_sql)
+    assert_match(%q|add_trigger(:test_table, [:insert, :update], :row => true, :name => 'update_trade-materials_statuses_logt', :function => :update_trade_materials_statuses_logf)|.to_regex, received_sql)
+    assert_match(%q|create_table "a_table_defined_after_the_stored_proc"|.to_regex, received_sql)
+    assert_match(%q|create_table("somewhere.schema_in_a_specific_table"|.to_regex, received_sql)
+    assert_match(%q|create_proc(:sql_proc_with_table_reference, [:int4], :return => :int4, :lang => 'sql') {\n    <<-sql_proc_with_table_reference_sql\n\nSELECT id FROM a_table_defined_after_the_stored_proc WHERE id = $1;\n    sql_proc_with_table_reference_sql\n  }|.to_regex, received_sql.split("\n")[-9..-2].join("\n"))
+    assert_match(%q|create_proc(:f_commacat, [:text, :text]|.to_regex, received_sql)
+    assert_no_match(%q|lang => 'internal'|.to_regex, received_sql)
+    assert_no_match(%q|create_proc(:comma|.to_regex, received_sql)
+    assert_no_match(%q|create_proc(:afunc|.to_regex, received_sql)
+
+    @connection.drop_proc(:sql_proc_with_table_reference, [:int4])
+    @connection.drop_table("a_table_defined_after_the_stored_proc")
+    @connection.remove_trigger(:test_table, :insert_or_update_after_test_table_trigger)
+    @connection.remove_trigger(:test_table, "update_trade-materials_statuses_logt")
+    @connection.drop_proc(:levenshtein)
+    @connection.drop_proc(:update_trade_materials_statuses_logf)
+    @connection.drop_proc('name-with-hyphen')
+    @connection.drop_type(:qualitysmith_user)
+    begin
+      @connection.execute "DROP AGGREGATE comma(text)"
+    rescue ActiveRecord::StatementInvalid
+    end
+    @connection.drop_proc('somewhere_else.afunc', []) { "BEGIN\nEND;" }
+    @connection.drop_schema "somewhere", :cascade => true
+    @connection.drop_schema "somewhere_else", :cascade => true
+    @connection.drop_proc(:f_commacat, [:text, :text])
+  end
+
+  def test_methods
+    %w(procs types views schemas).each {|meth|
+      %w(create drop).each {|action| 
+        assert_respond_to "#{action}_#{meth.singularize}", @connection
+      }
+      assert_respond_to meth, @connection unless meth == 'procs'
+    }
+    %w(procedures triggers add_trigger remove_trigger).each {|meth|
+      assert_respond_to meth, @connection
+    }
+
+    assert !@connection.procedures().nil?, "@connection#procedures returns nil"
+    procedures_count = @connection.procedures.size
+    trigger_count = @connection.triggers(:test_table).size
+    with_proc(:insert_after_test_table_trigger, [], :return => :trigger) {
+      assert_equal 0, trigger_count
+      assert_equal procedures_count + 1, @connection.procedures.size
+      with_trigger(:test_table, [:insert], :row => true) {
+        assert !@connection.triggers(:test_table).nil?, "Triggers for table :test_table returns nil"
+        received = @connection.triggers(:test_table)
+        assert_equal trigger_count + 1, received.size
+        assert_equal "insert_after_test_table_trigger", received.last.name
+      }
+    }
+    assert_equal procedures_count, @connection.procedures.size
+  end
+
+  def test_more_complicated_schema_dumper
+    with_proc(:levenshtein, [:text, :text], :return => nil, :resource => ['$libdir/fuzzystrmatch'], :strict => true, :behavior => 'immutable', :lang => "C") {
+      assert_no_exception(NoMethodError) do 
+        dumper = ActiveRecord::SchemaDumper.new(@connection)
+        stream = StringIO.new
+        dumper.send(:procedures, stream)
+        stream.rewind
+        received = stream.read
+        assert_equal "  create_proc(\"levenshtein\", [:text, :text], :return => nil, :resource => ['$libdir/fuzzystrmatch', 'levenshtein'], :strict => true, :behavior => 'immutable', :lang => 'c')", received.split("\n")[-1]
+      end
+    }
+  end
+
+  def test_schema_definition_class
+    schema = ActiveRecord::ConnectionAdapters::SchemaDefinition.new('rails', 'postgres')
+    assert_match(/CREATE SCHEMA "rails" AUTHORIZATION "postgres"/, schema.to_sql)
+    assert_equal('DROP SCHEMA "rails" RESTRICT', schema.to_sql(:drop))
+    assert_match(/create_schema\ "rails", "postgres"$/, schema.to_rdl)
+
+    count_query = "SELECT count(*) FROM pg_namespace WHERE nspname = 'rails'"
+    assert_nil @connection.schemas.find {|schema| schema.name.to_s == 'rails' }
+    assert_nothing_raised {
+      @connection.create_schema "rails"
+    }
+#    assert_equal 'rails,"$user",public', @connection.schema_search_path
+    assert_equal('"$user",public,rails', @connection.schema_search_path)
+    assert_not_nil @connection.schemas.find {|schema| schema.name.to_s == 'rails' }
+    assert_nothing_raised {
+      @connection.drop_schema "rails"
+    }
+    assert_nil @connection.schemas.find {|schema| schema.name.to_s == 'rails' }
+  end
+
+  def test_schema_dumper_schema
+    @connection.create_schema "rails"
+    assert_no_exception(NoMethodError) do 
+      dumper = ActiveRecord::SchemaDumper.new(@connection)
+      stream = StringIO.new
+      dumper.send(:schemas, stream)
+      stream.rewind
+      assert_match /create_schema\ "rails", "postgres"$/, stream.read.chomp 
+    end
+    @connection.drop_schema("rails", :cascade => true)
+  end
+
+  def test_schema_dumper_exceptions
+    proc_name, columns = "test_sql_type_proc_with_table_reference", [:integer]
+    assert_equal [], @connection.procedures
+    assert_raise ActiveRecord::StatementInvalid do
+      @connection.create_proc(proc_name, columns, :return => nil, :lang => :sql) { 
+        <<-sql
+          SELECT * FROM a_table_that_doesnt_yet_exist WHERE id = '$1';
+        sql
+      }
+    end
+    assert_equal [], @connection.procedures
+    @connection.create_table(:a_table_that_doesnt_yet_exist, :force => true) { |t|
+      t.column :name, :varchar
+    }
+
+    assert_equal [], @connection.procedures
+    assert_nothing_raised do
+      @connection.create_proc(proc_name, columns, :return => :integer, :lang => :sql, :force => true) { 
+        <<-sql
+          SELECT id FROM a_table_that_doesnt_yet_exist WHERE id = $1;
+        sql
+      }
+    end
+    @connection.drop_table(:a_table_that_doesnt_yet_exist)
+    @connection.drop_proc(proc_name, columns)
+    assert_equal [], @connection.procedures
+  end
+
+  def test_simple_schema_dumper
+    with_proc(:insert_after_test_table_trigger, [], :return => :trigger) {
+      with_trigger(:test_table, [:insert], :row => true) {
+        assert_no_exception(NoMethodError) do 
+          stream = StringIO.new
+          dumper = ActiveRecord::SchemaDumper.new(@connection)
+          dumper.send(:triggers, :test_table, stream)
+          stream.rewind
+          assert_match %q|add_trigger "test_table", [:insert], :row => true|.to_regex, stream.read
+
+          stream = StringIO.new
+          dumper.send(:procedures, stream)
+          stream.rewind
+          assert_match %Q|create_proc(\"insert_after_test_table_trigger\", [], :return => :trigger, :lang => 'plpgsql') {\n    <<-insert_after_test_table_trigger_sql\n\n#{@query_body}\n    insert_after_test_table_trigger_sql\n  }\n|.to_regex, stream.read
+        end
+      }
+    }
+  end
+
+  def test_sym_to_str
+    assert_equal '"abc"', "abc".to_sql_name
+    assert_equal '"abc"', "abc".to_sym.to_sql_name
+    assert_equal "'abc'", "abc".to_sym.to_sql_value
+  end
+
+  private
+    def with_proc(name, columns=[], options={}, &block)
+#        assert_equal [], @connection.procedures
+
+        assert_nil @connection.procedures.find {|procedure| procedure[1] == name }
+        if options[:resource]
+            @connection.create_proc(name, columns, options)
+        else
+            @connection.create_proc(name, columns, options) { @query_body }
+        end
+        assert_equal name.to_s, @connection.procedures.last[1]
+            yield
+        @connection.drop_proc(name, columns)
+#        assert_equal [], @connection.procedures
+        assert_nil @connection.procedures.find {|procedure| procedure[1] == name }
+    end
+
+    def with_trigger(table, events=[], options={}, &block)
+        @connection.add_trigger(table, events, options) 
+            yield
+        @connection.remove_trigger(table, options[:name] || ActiveSupport::Inflector.triggerize(table, events, options.has_key?(:before)))
+    end
+end