activerecord-postgresql-extensions 0.2.2 → 0.3.0

data/lib/active_record/postgresql_extensions/utils.rb

@@ -2,22 +2,44 @@
 module ActiveRecord
   module PostgreSQLExtensions
     module Utils
-      class << self
-        def hash_or_array_of_hashes(arg)
-          case arg
-            when Hash
-              [ arg ]
-            when Array
-              if arg.detect { |e| !e.is_a?(Hash) }
-                raise ArgumentError.new("Expected an Array of Hashes")
-              else
-                arg
-              end
+      def hash_or_array_of_hashes(arg)
+        case arg
+          when Hash
+            [ arg ]
+          when Array
+            if arg.detect { |e| !e.is_a?(Hash) }
+              raise ArgumentError.new("Expected an Array of Hashes")
             else
-              raise ArgumentError.new("Expected either a Hash or an Array of Hashes")
-          end
+              arg
+            end
+          else
+            raise ArgumentError.new("Expected either a Hash or an Array of Hashes")
         end
       end
+
+      def strip_heredoc(str)
+        indent = str.scan(/^[ \t]*(?=\S)/).min.try(:size) || 0
+        str.gsub(/^[ \t]{#{indent}}/, '').strip
+      end
+
+      def options_from_hash_or_string(value, base = self.base)
+        case value
+          when Hash
+            value.collect { |(k, v)|
+              "#{base.quote_generic(k)} = #{base.quote(v)}"
+            }.join(', ')
+
+          when String
+            value
+
+          else
+            value.to_s
+        end
+      end
+
+      class << self
+        include Utils
+      end
     end
   end
 end

data/lib/active_record/postgresql_extensions/vacuum.rb

@@ -88,7 +88,7 @@ module ActiveRecord
         sql << " #{base.quote_table_name(table)}" if self.table
 
         if options[:columns]
-          sql << ' (' << Array(options[:columns]).collect { |column|
+          sql << ' (' << Array.wrap(options[:columns]).collect { |column|
             base.quote_column_name(column)
           }.join(', ') << ')'
         end

data/lib/active_record/postgresql_extensions/version.rb

@@ -1,7 +1,7 @@
 
 module ActiveRecord
   module PostgreSQLExtensions
-    VERSION = "0.2.2"
+    VERSION = "0.3.0"
   end
 end
 

data/lib/active_record/postgresql_extensions/views.rb

@@ -27,6 +27,11 @@ module ActiveRecord
       #   necessary. Note that this can be an Array and that it must be
       #   the same length as the number of output columns created by
       #   +query+.
+      # * <tt>:with_options</tt> - sets view options. View options were added
+      #   in PostgreSQL 9.1. See the PostgreSQL docs for details on the
+      #   available options.
+      # * <tt>:recursive</tt> - adds the RECURSIVE clause. Available in
+      #   PostgreSQL 9.3+.
       #
       # ==== Examples
       #
@@ -49,27 +54,68 @@ module ActiveRecord
       #
       # * <tt>:if_exists</tt> - adds IF EXISTS.
       # * <tt>:cascade</tt> - adds CASCADE.
-      def drop_view(name, options = {})
+      def drop_view(*args)
+        options = args.extract_options!
+        args.flatten!
+
         sql = 'DROP VIEW '
         sql << 'IF EXISTS ' if options[:if_exists]
-        sql << Array(name).collect { |v| quote_view_name(v) }.join(', ')
+        sql << Array.wrap(args).collect { |v| quote_view_name(v) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
         execute("#{sql};")
       end
 
       # Renames a view.
       def rename_view(name, new_name, options = {})
-        execute "ALTER TABLE #{quote_view_name(name)} RENAME TO #{quote_generic_ignore_scoped_schema(new_name)};"
+        execute PostgreSQLViewAlterer.new(self, name, {
+          :rename_to => new_name
+        }, options).to_sql
       end
 
       # Change the ownership of a view.
       def alter_view_owner(name, role, options = {})
-        execute "ALTER TABLE #{quote_view_name(name)} OWNER TO #{quote_role(role)};"
+        execute PostgreSQLViewAlterer.new(self, name, {
+          :owner_to => role
+        }, options).to_sql
       end
 
       # Alter a view's schema.
       def alter_view_schema(name, schema, options = {})
-        execute "ALTER TABLE #{quote_view_name(name)} SET SCHEMA #{quote_schema(schema)};"
+        execute PostgreSQLViewAlterer.new(self, name, {
+          :set_schema => schema
+        }, options).to_sql
+      end
+
+      # Sets a view's options using a Hash.
+      def alter_view_set_options(name, set_options, options = {})
+        execute PostgreSQLViewAlterer.new(self, name, {
+          :set_options => set_options
+        }, options).to_sql
+      end
+
+      # Resets a view's options.
+      def alter_view_reset_options(name, *args)
+        options = args.extract_options!
+
+        execute PostgreSQLViewAlterer.new(self, name, {
+          :reset_options => args
+        }, options).to_sql
+      end
+
+      # Set a column default on a view.
+      def alter_view_set_column_default(name, column, expression, options = {})
+        execute PostgreSQLViewAlterer.new(self, name, {
+          :set_default => {
+            column => expression
+          }
+        }, options).to_sql
+      end
+
+      # Drop a column default from a view.
+      def alter_view_drop_column_default(name, column, options = {})
+        execute PostgreSQLViewAlterer.new(self, name, {
+          :drop_default => column
+        }, options).to_sql
       end
     end
 
@@ -77,6 +123,8 @@ module ActiveRecord
     # to be used directly. Instead, see PostgreSQLAdapter#create_view
     # for usage.
     class PostgreSQLViewDefinition
+      include ActiveRecord::PostgreSQLExtensions::Utils
+
       attr_accessor :base, :name, :query, :options
 
       def initialize(base, name, query, options = {}) #:nodoc:
@@ -87,16 +135,99 @@ module ActiveRecord
         sql = 'CREATE '
         sql << 'OR REPLACE ' if options[:replace]
         sql << 'TEMPORARY ' if options[:temporary]
+        sql << 'RECURSIVE ' if options[:recursive]
         sql << "VIEW #{base.quote_view_name(name)} "
+
         if options[:columns]
-          sql << '(' << Array(options[:columns]).collect do |c|
+          sql << '(' << Array.wrap(options[:columns]).collect do |c|
             base.quote_column_name(c)
           end.join(', ') << ') '
         end
+
+        if options[:with_options]
+          ActiveRecord::PostgreSQLExtensions::Features.check_feature(:view_set_options)
+
+          sql << "WITH (#{options_from_hash_or_string(options[:with_options])}) " if options.present?
+        end
+
         sql << "AS #{query}"
         "#{sql};"
       end
       alias :to_s :to_sql
     end
+
+    class PostgreSQLViewAlterer
+      include ActiveRecord::PostgreSQLExtensions::Utils
+
+      attr_accessor :base, :name, :actions, :options
+
+      VALID_OPTIONS = %w{
+        set_default
+        drop_default
+        owner_to
+        rename_to
+        set_schema
+        set_options
+        reset_options
+      }.freeze
+
+      def initialize(base, name, actions, options = {}) #:nodoc:
+        @base, @name, @actions, @options = base, name, actions, options
+      end
+
+      def to_sql #:nodoc:
+        all_sql = []
+
+        VALID_OPTIONS.each do |key|
+          key = key.to_sym
+
+          if actions.key?(key)
+            sql = "ALTER VIEW "
+
+            if options.key?(:if_exists)
+              ActiveRecord::PostgreSQLExtensions::Features.check_feature(:view_if_exists)
+
+              sql << "IF EXISTS " if options[:if_exists]
+            end
+
+            sql << "#{base.quote_view_name(name)} "
+
+            sql << case key
+              when :set_default
+                column, expression = actions[:set_default].flatten
+                "ALTER COLUMN #{base.quote_column_name(column)} SET DEFAULT #{expression}"
+
+              when :drop_default
+                "ALTER COLUMN #{base.quote_column_name(actions[:drop_default])} DROP DEFAULT"
+
+              when :owner_to
+                "OWNER TO #{base.quote_role(actions[:owner_to])}"
+
+              when :rename_to
+                "RENAME TO #{base.quote_generic_ignore_scoped_schema(actions[:rename_to])}"
+
+              when :set_schema
+                "SET SCHEMA #{base.quote_schema(actions[:set_schema])}"
+
+              when :set_options
+                ActiveRecord::PostgreSQLExtensions::Features.check_feature(:view_set_options)
+
+                "SET (#{options_from_hash_or_string(actions[:set_options])})" if actions[:set_options].present?
+
+              when :reset_options
+                ActiveRecord::PostgreSQLExtensions::Features.check_feature(:view_set_options)
+
+                'RESET (' << Array.wrap(actions[:reset_options]).collect { |value|
+                  base.quote_generic(value)
+                }.join(", ") << ')'
+            end
+
+            all_sql << "#{sql};"
+          end
+        end
+
+        all_sql.join("\n")
+      end
+    end
   end
 end

data/lib/activerecord-postgresql-extensions.rb

@@ -22,24 +22,26 @@ dirname = File.join(File.dirname(__FILE__), *%w{ active_record postgresql_extens
   features
   adapter_extensions
   constraints
-  tables
-  tablespaces
+  extensions
+  foreign_key_associations
+  functions
+  event_triggers
+  geometry
   indexes
-  permissions
-  schemas
   languages
+  materialized_views
+  permissions
+  roles
   rules
-  functions
+  schemas
   sequences
+  tables
+  tablespaces
+  text_search
   triggers
-  views
-  geometry
   types
-  roles
-  text_search
-  extensions
-  foreign_key_associations
   vacuum
+  views
 }.each do |file|
   require File.join(dirname, file)
 end

data/test/{adapter_tests.rb → adapter_extensions_tests.rb}

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class AdapterExtensionTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class AdapterExtensionTests < PostgreSQLExtensionsTestCase
   def test_quote_table_name_with_schema_string
     assert_equal(%{"foo"."bar"}, ARBC.quote_table_name('foo.bar'))
   end
@@ -207,4 +205,99 @@ class AdapterExtensionTests < MiniTest::Unit::TestCase
       %{ALTER TABLE "foo" ALTER "bar" DROP NOT NULL},
     ], statements)
   end
+
+  def stub_copy_from
+    if ARBC.raw_connection.respond_to?(:copy_data)
+      ARBC.raw_connection.stub(:copy_data, proc { |sql|
+        statements << sql
+      }) do
+        yield
+      end
+    else
+      yield
+    end
+  end
+
+  def test_copy_from
+    stub_copy_from do
+      Mig.copy_from(:foo, '/dev/null') rescue nil
+      Mig.copy_from(:foo, '/dev/null', :columns => :name) rescue nil
+      Mig.copy_from(:foo, '/dev/null', :columns => [ :name, :description ]) rescue nil
+      Mig.copy_from(:foo, '/dev/null', :local => true) rescue nil
+      Mig.copy_from(:foo, '/dev/null', :binary => true) rescue nil
+      Mig.copy_from(:foo, '/dev/null', :csv => true) rescue nil
+      Mig.copy_from(:foo, '/dev/null', :csv => { :header => true, :quote => '|', :escape => '&' }) rescue nil
+      Mig.copy_from(:foo, '/dev/null', :local => false)
+    end
+
+    assert_equal([
+      %{COPY "foo" FROM STDIN;},
+      %{COPY "foo" ("name") FROM STDIN;},
+      %{COPY "foo" ("name", "description") FROM STDIN;},
+      %{COPY "foo" FROM STDIN;},
+      %{COPY "foo" FROM STDIN BINARY;},
+      %{COPY "foo" FROM STDIN CSV;},
+      %{COPY "foo" FROM STDIN CSV HEADER QUOTE AS '|' ESCAPE AS '&';},
+      %{COPY "foo" FROM '/dev/null';}
+    ], statements)
+  end
+
+  def test_copy_from_with_freeze_option
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.copy_from_freeze?
+
+    stub_copy_from do
+      Mig.copy_from(:foo, '/dev/null', :freeze => true) rescue nil
+    end
+
+    assert_equal([
+      %{COPY "foo" FROM STDIN FREEZE;}
+    ], statements)
+  end
+
+  def test_copy_from_with_encoding_option
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.copy_from_encoding?
+
+    stub_copy_from do
+      Mig.copy_from(:foo, '/dev/null', :encoding => 'UTF-8') rescue nil
+    end
+
+    assert_equal([
+      %{COPY "foo" FROM STDIN ENCODING 'UTF-8';}
+    ], statements)
+  end
+
+  def test_copy_from_program
+    skip unless ActiveRecord::PostgreSQLExtensions::Features.copy_from_program?
+
+    Mig.copy_from(:foo, 'cat /dev/null', :program => true) rescue nil
+
+    assert_equal([
+      %{COPY "foo" FROM PROGRAM 'cat /dev/null';}
+    ], statements)
+  end
+
+  def test_cluster_all
+    ARBC.cluster_all
+    ARBC.cluster_all(:verbose => true)
+
+    assert_equal([
+      %{CLUSTER;},
+      %{CLUSTER VERBOSE;}
+    ], statements)
+  end
+
+
+  def test_cluster_table
+    Mig.cluster(:foo)
+    Mig.cluster(:foo, :verbose => true)
+    Mig.cluster(:foo, :using => "bar_idx")
+    ARBC.cluster(:foo => :bar)
+
+    assert_equal([
+      %{CLUSTER "foo";},
+      %{CLUSTER VERBOSE "foo";},
+      %{CLUSTER "foo" USING "bar_idx";},
+      %{CLUSTER "foo"."bar";}
+    ], statements)
+  end
 end

data/test/constraints_tests.rb

@@ -2,9 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class ConstraintTests < MiniTest::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
-
+class ConstraintTests < PostgreSQLExtensionsTestCase
   def setup
     clear_statements!
   end
@@ -16,18 +14,24 @@ class ConstraintTests < MiniTest::Unit::TestCase
       t.text :email
       t.unique_constraint [ :id, :bar_id ]
       t.unique_constraint [ :name, :email ], :tablespace => 'fubar'
+      t.unique_constraint :name, :storage_parameters => {
+        :fillfactor => 10
+      }
+      t.unique_constraint :email, :storage_parameters => 'FILLFACTOR = 10'
     end
 
-    assert_equal((<<-EOF).strip, statements[0])
-CREATE TABLE "foo" (
-  "id" serial primary key,
-  "bar_id" integer,
-  "name" text,
-  "email" text,
-  UNIQUE ("id", "bar_id"),
-  UNIQUE ("name", "email") USING INDEX TABLESPACE "fubar"
-);
-EOF
+    assert_equal(strip_heredoc(<<-SQL), statements[0])
+      CREATE TABLE "foo" (
+        "id" serial primary key,
+        "bar_id" integer,
+        "name" text,
+        "email" text,
+        UNIQUE ("id", "bar_id"),
+        UNIQUE ("name", "email") USING INDEX TABLESPACE "fubar",
+        UNIQUE ("name") WITH ("fillfactor" = 10),
+        UNIQUE ("email") WITH (FILLFACTOR = 10)
+      );
+    SQL
   end
 
   def test_create_table_with_unique_constraint_on_column
@@ -35,13 +39,13 @@ EOF
       t.integer :bar_id, :unique => true
     end
 
-    assert_equal((<<-EOF).strip, statements[0])
-CREATE TABLE "foo" (
-  "id" serial primary key,
-  "bar_id" integer,
-  UNIQUE ("bar_id")
-);
-EOF
+    assert_equal(strip_heredoc(<<-SQL), statements[0])
+      CREATE TABLE "foo" (
+        "id" serial primary key,
+        "bar_id" integer,
+        UNIQUE ("bar_id")
+      );
+    SQL
   end
 
   def test_add_unique_constraint
@@ -55,8 +59,8 @@ EOF
     )
 
     assert_equal([
-      "ALTER TABLE \"foo\" ADD UNIQUE (\"bar_id\");",
-      "ALTER TABLE \"foo\" ADD CONSTRAINT \"bar_id_unique\" UNIQUE (\"bar_id\") WITH (FILLFACTOR=10) USING INDEX TABLESPACE \"fubar\";"
+      %{ALTER TABLE "foo" ADD UNIQUE ("bar_id");},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "bar_id_unique" UNIQUE ("bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";}
     ], statements)
   end
 
@@ -73,16 +77,17 @@ EOF
       t.integer :baz_id, :references => [ :baz ]
     end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
-  "id" serial primary key,
-  "foo_id" integer,
-  "bar_id" integer,
-  "baz_id" integer,
-  FOREIGN KEY ("foo_id") REFERENCES "foo" ON DELETE SET NULL ON UPDATE CASCADE,
-  FOREIGN KEY ("bar_id") REFERENCES "bar",
-  FOREIGN KEY ("baz_id") REFERENCES "baz"
-);} ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TABLE "foo" (
+        "id" serial primary key,
+        "foo_id" integer,
+        "bar_id" integer,
+        "baz_id" integer,
+        FOREIGN KEY ("foo_id") REFERENCES "foo" ON DELETE SET NULL ON UPDATE CASCADE,
+        FOREIGN KEY ("bar_id") REFERENCES "bar",
+        FOREIGN KEY ("baz_id") REFERENCES "baz"
+      );
+    SQL
   end
 
   def test_foreign_key_in_table_definition
@@ -95,15 +100,16 @@ EOF
       t.foreign_key [ :schabba_id, :doo_id ], :bar, [ :schabba_id, :doo_id ]
     end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
-  "id" serial primary key,
-  "schabba_id" integer,
-  "doo_id" integer,
-  FOREIGN KEY ("schabba_id") REFERENCES "bar",
-  FOREIGN KEY ("doo_id") REFERENCES "baz",
-  FOREIGN KEY ("schabba_id", "doo_id") REFERENCES "bar" ("schabba_id", "doo_id")
-);} ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TABLE "foo" (
+        "id" serial primary key,
+        "schabba_id" integer,
+        "doo_id" integer,
+        FOREIGN KEY ("schabba_id") REFERENCES "bar",
+        FOREIGN KEY ("doo_id") REFERENCES "baz",
+        FOREIGN KEY ("schabba_id", "doo_id") REFERENCES "bar" ("schabba_id", "doo_id")
+      );
+    SQL
   end
 
   def test_add_foreign_key
@@ -114,11 +120,11 @@ EOF
     Mig.add_foreign_key(:foo, :bar_id, :bar, :deferrable => :immediate)
 
     assert_equal([
-      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\";",
-      "ALTER TABLE \"foo\" ADD CONSTRAINT \"bar_fk\" FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" (\"ogc_fid\");",
-      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"one_id\", \"bar_id\") REFERENCES \"bar\" (\"one_id\", \"bar_id\") MATCH FULL;",
-      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" ON DELETE SET DEFAULT;",
-      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" DEFERRABLE INITIALLY IMMEDIATE;"
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("bar_id") REFERENCES "bar";},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "bar_fk" FOREIGN KEY ("bar_id") REFERENCES "bar" ("ogc_fid");},
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("one_id", "bar_id") REFERENCES "bar" ("one_id", "bar_id") MATCH FULL;},
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("bar_id") REFERENCES "bar" ON DELETE SET DEFAULT;},
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("bar_id") REFERENCES "bar" DEFERRABLE INITIALLY IMMEDIATE;}
     ], statements)
   end
 
@@ -127,8 +133,8 @@ EOF
     Mig.drop_constraint(:foo, :bar, :cascade => true)
 
     assert_equal([
-      "ALTER TABLE \"foo\" DROP CONSTRAINT \"bar\";",
-      "ALTER TABLE \"foo\" DROP CONSTRAINT \"bar\" CASCADE;"
+      %{ALTER TABLE "foo" DROP CONSTRAINT "bar";},
+      %{ALTER TABLE "foo" DROP CONSTRAINT "bar" CASCADE;}
     ], statements)
   end
 
@@ -142,17 +148,18 @@ EOF
       } ]
     end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
-  "id" serial primary key,
-  "foo_id" integer,
-  "bar_id" integer,
-  "baz_id" integer,
-  CHECK (foo_id != 1),
-  CONSTRAINT "bar_id_not_1" CHECK (bar_id != 1),
-  CHECK (baz_id != 1),
-  CONSTRAINT "baz_id_gt_10" CHECK (baz_id > 10)
-);} ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements )
+      CREATE TABLE "foo" (
+        "id" serial primary key,
+        "foo_id" integer,
+        "bar_id" integer,
+        "baz_id" integer,
+        CHECK (foo_id != 1),
+        CONSTRAINT "bar_id_not_1" CHECK (bar_id != 1),
+        CHECK (baz_id != 1),
+        CONSTRAINT "baz_id_gt_10" CHECK (baz_id > 10)
+      );
+    SQL
   end
 
   def test_check_constraint_in_table_definition
@@ -169,17 +176,18 @@ EOF
       }
     end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
-  "id" serial primary key,
-  "foo_id" integer,
-  "bar_id" integer,
-  "baz_id" integer,
-  CHECK (foo_id != 1),
-  CONSTRAINT "bar_id_not_1" CHECK (bar_id != 1),
-  CHECK (baz_id != 1),
-  CONSTRAINT "baz_id_gt_10" CHECK (baz_id > 10)
-);} ], statements)
+    assert_equal([ strip_heredoc(<<-SQL) ], statements)
+      CREATE TABLE "foo" (
+        "id" serial primary key,
+        "foo_id" integer,
+        "bar_id" integer,
+        "baz_id" integer,
+        CHECK (foo_id != 1),
+        CONSTRAINT "bar_id_not_1" CHECK (bar_id != 1),
+        CHECK (baz_id != 1),
+        CONSTRAINT "baz_id_gt_10" CHECK (baz_id > 10)
+      );
+    SQL
   end
 
   def test_add_check_constraint
@@ -187,8 +195,8 @@ EOF
     Mig.add_check_constraint(:foo, 'length(name) < 100', :name => 'name_length_check')
 
     assert_equal([
-      "ALTER TABLE \"foo\" ADD CHECK (length(name) < 100);",
-      "ALTER TABLE \"foo\" ADD CONSTRAINT \"name_length_check\" CHECK (length(name) < 100);"
+      %{ALTER TABLE "foo" ADD CHECK (length(name) < 100);},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "name_length_check" CHECK (length(name) < 100);}
     ], statements)
   end
 
@@ -235,6 +243,16 @@ EOF
       :index_parameters => 'FILLFACTOR=10'
     })
 
+    Mig.add_exclude_constraint(:foo, {
+      :element => 'length(name)',
+      :with => '='
+    }, {
+      :tablespace => 'fubar',
+      :index_parameters => {
+        :fillfactor => 10
+      }
+    })
+
     escaped_array = if ActiveRecord::VERSION::STRING >= "3.0"
       "(1, 2, 3, 4)"
     else
@@ -247,7 +265,8 @@ EOF
       %{ALTER TABLE "foo" ADD CONSTRAINT "exclude_name_length" EXCLUDE USING "gist" (length(name) WITH =);},
       %{ALTER TABLE "foo" ADD EXCLUDE (length(name) WITH =, length(title) WITH =);},
       %{ALTER TABLE "foo" ADD EXCLUDE (length(name) WITH =) WHERE ("foos"."id" IN #{escaped_array});},
-      %{ALTER TABLE "foo" ADD EXCLUDE (length(name) WITH =) WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";}
+      %{ALTER TABLE "foo" ADD EXCLUDE (length(name) WITH =) WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";},
+      %{ALTER TABLE "foo" ADD EXCLUDE (length(name) WITH =) WITH ("fillfactor" = 10) USING INDEX TABLESPACE "fubar";}
     ], statements)
   end
 
@@ -263,16 +282,39 @@ EOF
       }
     end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
-  "foo_id" integer,
-  PRIMARY KEY ("foo_id")
-);},
-
-      %{CREATE TABLE "foo" (
-  "foo_id" integer,
-  PRIMARY KEY ("foo_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
-);}], statements)
+    Mig.create_table('foo', :id => false) do |t|
+      t.integer :foo_id, :primary_key => {
+        :tablespace => 'fubar',
+        :index_parameters => {
+          :fillfactor => 10
+        }
+      }
+    end
+
+    expected = []
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "foo_id" integer,
+        PRIMARY KEY ("foo_id")
+      );
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "foo_id" integer,
+        PRIMARY KEY ("foo_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
+      );
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "foo_id" integer,
+        PRIMARY KEY ("foo_id") WITH ("fillfactor" = 10) USING INDEX TABLESPACE "fubar"
+      );
+    SQL
+
+    assert_equal(expected, statements)
   end
 
 
@@ -299,22 +341,50 @@ EOF
       }
     end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
-  "foo_id" integer,
-  PRIMARY KEY ("foo_id")
-);},
-
-      %{CREATE TABLE "foo" (
-  "foo_id" integer,
-  PRIMARY KEY ("foo_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
-);},
-
-      %{CREATE TABLE "foo" (
-  "foo_id" integer,
-  "bar_id" integer,
-  PRIMARY KEY ("foo_id", "bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
-);}], statements)
+    Mig.create_table('foo', :id => false) do |t|
+      t.integer :foo_id
+      t.integer :bar_id
+      t.primary_key_constraint [ :foo_id, :bar_id ], {
+        :tablespace => 'fubar',
+        :index_parameters => {
+          :fillfactor => 10
+        }
+      }
+    end
+
+    expected = []
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "foo_id" integer,
+        PRIMARY KEY ("foo_id")
+      );
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "foo_id" integer,
+        PRIMARY KEY ("foo_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
+      );
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "foo_id" integer,
+        "bar_id" integer,
+        PRIMARY KEY ("foo_id", "bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar"
+      );
+    SQL
+
+    expected << strip_heredoc(<<-SQL)
+      CREATE TABLE "foo" (
+        "foo_id" integer,
+        "bar_id" integer,
+        PRIMARY KEY ("foo_id", "bar_id") WITH ("fillfactor" = 10) USING INDEX TABLESPACE "fubar"
+      );
+    SQL
+
+    assert_equal(expected, statements)
   end
 
   def test_add_primary_key
@@ -322,12 +392,16 @@ EOF
     Mig.add_primary_key(:foo, [ :bar_id, :baz_id ])
     Mig.add_primary_key(:foo, :bar_id, :name => 'foo_pk')
     Mig.add_primary_key(:foo, :bar_id, :tablespace => 'fubar', :index_parameters => 'FILLFACTOR=10')
+    Mig.add_primary_key(:foo, :bar_id, :tablespace => 'fubar', :index_parameters => {
+      :fillfactor => 10
+    })
 
     assert_equal([
       %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id");},
       %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id", "baz_id");},
       %{ALTER TABLE "foo" ADD CONSTRAINT "foo_pk" PRIMARY KEY ("bar_id");},
-      %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";}
+      %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id") WITH (FILLFACTOR=10) USING INDEX TABLESPACE "fubar";},
+      %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id") WITH ("fillfactor" = 10) USING INDEX TABLESPACE "fubar";}
     ], statements)
   end
 
@@ -336,8 +410,8 @@ EOF
     Mig.add_foreign_key(:foo, :bar_id, :bar, :not_valid => true)
 
     assert_equal([
-      "ALTER TABLE \"foo\" ADD CHECK (length(name) < 100) NOT VALID;",
-      "ALTER TABLE \"foo\" ADD FOREIGN KEY (\"bar_id\") REFERENCES \"bar\" NOT VALID;"
+      %{ALTER TABLE "foo" ADD CHECK (length(name) < 100) NOT VALID;},
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("bar_id") REFERENCES "bar" NOT VALID;}
     ], statements)
   end
 
@@ -345,7 +419,7 @@ EOF
     Mig.validate_constraint(:foo, :foo_constraint)
 
     assert_equal([
-      "ALTER TABLE \"foo\" VALIDATE CONSTRAINT \"foo_constraint\";"
+      %{ALTER TABLE "foo" VALIDATE CONSTRAINT "foo_constraint";}
     ], statements)
   end
 
@@ -353,7 +427,45 @@ EOF
     Mig.add_check_constraint(:foo, 'length(name) < 100', :no_inherit => true)
 
     assert_equal([
-      "ALTER TABLE \"foo\" ADD CHECK (length(name) < 100) NO INHERIT;",
+      %{ALTER TABLE "foo" ADD CHECK (length(name) < 100) NO INHERIT;},
+    ], statements)
+  end
+
+  def test_invalid_deferrable_option
+    assert_raises(ActiveRecord::InvalidDeferrableOption) do
+      Mig.add_foreign_key(:foo, :bar_id, :bar, :deferrable => :foo)
+    end
+  end
+
+  def test_true_deferrable_option
+    Mig.add_foreign_key(:foo, :bar_id, :bar, :deferrable => true)
+
+    assert_equal([
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("bar_id") REFERENCES "bar" DEFERRABLE;}
     ], statements)
   end
+
+  def test_false_deferrable_option
+    Mig.add_foreign_key(:foo, :bar_id, :bar, :deferrable => false)
+
+    assert_equal([
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("bar_id") REFERENCES "bar" NOT DEFERRABLE;}
+    ], statements)
+  end
+
+  def test_invalid_match_type
+    assert_raises(ActiveRecord::InvalidMatchType) do
+      Mig.add_foreign_key(:foo, :bar_id, :bar, :match => :foo)
+    end
+  end
+
+  def test_invalid_action_type
+    assert_raises(ActiveRecord::InvalidForeignKeyAction) do
+      Mig.add_foreign_key(:foo, :bar_id, :bar, :on_delete => :blort)
+    end
+
+    assert_raises(ActiveRecord::InvalidForeignKeyAction) do
+      Mig.add_foreign_key(:foo, :bar_id, :bar, :on_update => :blort)
+    end
+  end
 end