activerecord-postgresql-extensions 0.7.0 → 0.8.0

data/lib/active_record/postgresql_extensions/tables.rb

@@ -120,6 +120,18 @@ module ActiveRecord
         end
       end
 
+      alias :original_change_table :change_table
+      def change_table(table_name, options = {})
+        table = PostgreSQLTable.new(table_name, self)
+        yield table
+
+        unless table.post_processing.blank?
+          table.post_processing.each do |pp|
+            execute pp.to_s
+          end
+        end
+      end
+
       alias :original_drop_table :drop_table
       # Drops a table. This method is expanded beyond the standard
       # ActiveRecord drop_table method to allow for a couple of
@@ -387,5 +399,17 @@ module ActiveRecord
           end
         end
     end
+
+    class PostgreSQLTable < Table
+      # Add statements to execute to after a table has been created.
+      def post_processing
+        @post_processing ||= []
+      end
+
+      private
+        def table_constraints
+          @table_constraints ||= []
+        end
+    end
   end
 end

data/lib/active_record/postgresql_extensions/version.rb

@@ -1,7 +1,7 @@
 
 module ActiveRecord
   module PostgreSQLExtensions
-    VERSION = "0.7.0"
+    VERSION = "0.8.0"
   end
 end
 

data/test/constraints_tests.rb

@@ -48,6 +48,33 @@ class ConstraintTests < PostgreSQLExtensionsTestCase
     SQL
   end
 
+  def test_add_constraint
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLCheckConstraint.new(ARBC, "x = 10"))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLUniqueConstraint.new(ARBC, [ :bar_id, :baz_id ]))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLForeignKeyConstraint.new(ARBC, :bar_id, "bars"))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLExcludeConstraint.new(ARBC, :bars, { :element => :bar_id, :with => '=' }))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLPrimaryKeyConstraint.new(ARBC, [ :bar_id, :baz_id ]))
+
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLCheckConstraint.new(ARBC, "x = 10", :name => "foo_check"))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLUniqueConstraint.new(ARBC, [ :bar_id, :baz_id ], :name => "foo_uniq"))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLForeignKeyConstraint.new(ARBC, :bar_id, "bars", :name => "foo_fk"))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLExcludeConstraint.new(ARBC, :bars, { :element => :bar_id, :with => '=' }, { :name => "foo_exclude" }))
+    Mig.add_constraint(:foo, ActiveRecord::ConnectionAdapters::PostgreSQLPrimaryKeyConstraint.new(ARBC, [ :bar_id, :baz_id ], :name => "foo_pk"))
+
+    assert_equal([
+      %{ALTER TABLE "foo" ADD CHECK (x = 10);},
+      %{ALTER TABLE "foo" ADD UNIQUE ("bar_id", "baz_id");},
+      %{ALTER TABLE "foo" ADD FOREIGN KEY ("bar_id") REFERENCES "bars";},
+      %{ALTER TABLE "foo" ADD EXCLUDE (bar_id WITH =);},
+      %{ALTER TABLE "foo" ADD PRIMARY KEY ("bar_id", "baz_id");},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "foo_check" CHECK (x = 10);},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "foo_uniq" UNIQUE ("bar_id", "baz_id");},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "foo_fk" FOREIGN KEY ("bar_id") REFERENCES "bars";},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "foo_exclude" EXCLUDE (bar_id WITH =);},
+      %{ALTER TABLE "foo" ADD CONSTRAINT "foo_pk" PRIMARY KEY ("bar_id", "baz_id");}
+    ], statements)
+  end
+
   def test_add_unique_constraint
     Mig.add_unique_constraint(:foo, :bar_id)
     Mig.add_unique_constraint(

data/test/geometry_tests.rb

@@ -26,379 +26,7 @@ class GeometryTests < PostgreSQLExtensionsTestCase
 end
 
 if (ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] rescue '') >= '2.0'
-  class GeometryTests < PostgreSQLExtensionsTestCase
-    def test_create_geometry
-      Mig.create_table(:foo) do |t|
-        t.geometry :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry(GEOMETRY, 4326)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_spatial
-      Mig.create_table(:foo) do |t|
-        t.spatial :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry(GEOMETRY, 4326)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_spatial_and_spatial_column_type
-      Mig.create_table(:foo) do |t|
-        t.spatial :the_geom, :srid => 4326, :spatial_column_type => :geography
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geography(GEOMETRY, 4326)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geography
-      Mig.create_table(:foo) do |t|
-        t.geography :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geography(GEOMETRY, 4326)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_force_constraints
-      Mig.create_table(:foo) do |t|
-        t.geometry :the_geom, :srid => 4326, :force_constraints => true
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry(GEOMETRY, 4326),
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_schema
-      Mig.create_table('shabba.foo') do |t|
-        t.geometry :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "shabba"."foo" (
-          "id" serial primary key,
-          "the_geom" geometry(GEOMETRY, 4326)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_not_null
-      Mig.create_table(:foo) do |t|
-        t.geometry :the_geom, :srid => 4326, :null => false
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry(GEOMETRY, 4326) NOT NULL
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_null_and_type
-      Mig.create_table(:foo) do |t|
-        t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry(POLYGON, 4326)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-  end
+  require 'geometry_tests_modern_postgis'
 else
-  class GeometryTests < Test::Unit::TestCase
-    def test_create_geometry
-      Mig.create_table(:foo) do |t|
-        t.geometry :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry,
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_spatial
-      Mig.create_table(:foo) do |t|
-        t.spatial :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry,
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_spatial_and_spatial_column_type
-      Mig.create_table(:foo) do |t|
-        t.spatial :the_geom, :srid => 4326, :spatial_column_type => :geography
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geography,
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geography
-      Mig.create_table(:foo) do |t|
-        t.geography :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geography,
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_schema
-      Mig.create_table('shabba.foo') do |t|
-        t.geometry :the_geom, :srid => 4326
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "shabba"."foo" (
-          "id" serial primary key,
-          "the_geom" geometry,
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'shabba' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        INSERT INTO "geometry_columns" VALUES ('', 'shabba', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_not_null
-      Mig.create_table(:foo) do |t|
-        t.geometry :the_geom, :srid => 4326, :null => false
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry NOT NULL,
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-
-    def test_create_geometry_with_null_and_type
-      Mig.create_table(:foo) do |t|
-        t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
-      end
-
-      expected = []
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE TABLE "foo" (
-          "id" serial primary key,
-          "the_geom" geometry,
-          CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
-          CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2),
-          CONSTRAINT "enforce_geotype_the_geom" CHECK (geometrytype("the_geom") = 'POLYGON'::text OR "the_geom" IS NULL)
-        );
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'POLYGON');
-      SQL
-
-      expected << strip_heredoc(<<-SQL)
-        CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");
-      SQL
-
-      assert_equal(expected, statements)
-    end
-  end
+  require 'geometry_tests_legacy_postgis'
 end