activerecord-postgresql-extensions 0.0.12 → 0.1.0

data/test/database.yml

@@ -0,0 +1,17 @@
+---
+# To modify the test database parameters, create a new file called
+# local_database.yml and go nuts with settings. The "jdbc" settings
+# are merged into the "arunit" settings as JDBC works over a TCP
+# socket and those sorts of connections generally require some user
+# credentials.
+
+arunit:
+  adapter: "postgresql"
+  database: "postgresql_extensions_unit_tests"
+  min_messages: "warning"
+  schema_search_path: "public"
+
+jdbc:
+  host: "localhost"
+  adapter: "jdbcpostgresql"
+

data/test/geometry_tests.rb

@@ -2,79 +2,251 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class GeometryTests < Test::Unit::TestCase
-  include PostgreSQLExtensionsTestHelper
+if ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION
+  if ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] >= '2.0'
+    class GeometryTests < Test::Unit::TestCase
+      include PostgreSQLExtensionsTestHelper
 
-  def test_create_geometry
-    Mig.create_table(:foo) do |t|
-      t.geometry :the_geom, :srid => 4326
+      def test_create_geometry
+        Mig.create_table(:foo) do |t|
+          t.geometry :the_geom, :srid => 4326
+        end
+
+        assert_equal([
+          %{CREATE TABLE "foo" (
+  "id" serial primary key,
+  "the_geom" geometry(GEOMETRY, 4326)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
+
+      def test_create_geometry_with_spatial
+        Mig.create_table(:foo) do |t|
+          t.spatial :the_geom, :srid => 4326
+        end
+
+        assert_equal([
+          %{CREATE TABLE "foo" (
+  "id" serial primary key,
+  "the_geom" geometry(GEOMETRY, 4326)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], 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
+
+        assert_equal([
+          %{CREATE TABLE "foo" (
+  "id" serial primary key,
+  "the_geom" geography(GEOMETRY, 4326)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
+
+      def test_create_geography
+        Mig.create_table(:foo) do |t|
+          t.geography :the_geom, :srid => 4326
+        end
+
+        assert_equal([
+          %{CREATE TABLE "foo" (
+  "id" serial primary key,
+  "the_geom" geography(GEOMETRY, 4326)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], 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
+
+        assert_equal([
+          %{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)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
+
+      def test_create_geometry_with_schema
+        Mig.create_table('shabba.foo') do |t|
+          t.geometry :the_geom, :srid => 4326
+        end
+
+        assert_equal([
+          %{CREATE TABLE "shabba"."foo" (
+  "id" serial primary key,
+  "the_geom" geometry(GEOMETRY, 4326)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
+
+      def test_create_geometry_with_not_null
+        Mig.create_table(:foo) do |t|
+          t.geometry :the_geom, :srid => 4326, :null => false
+        end
+
+        assert_equal([
+          %{CREATE TABLE "foo" (
+  "id" serial primary key,
+  "the_geom" geometry(GEOMETRY, 4326) NOT NULL
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], 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
+
+        assert_equal([
+          %{CREATE TABLE "foo" (
+  "id" serial primary key,
+  "the_geom" geometry(POLYGON, 4326)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
     end
+  else
+    class GeometryTests < Test::Unit::TestCase
+      include PostgreSQLExtensionsTestHelper
+
+      def test_create_geometry
+        Mig.create_table(:foo) do |t|
+          t.geometry :the_geom, :srid => 4326
+        end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
+        assert_equal([
+          %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry,
-  CONSTRAINT "enforce_srid_the_geom" CHECK (srid("the_geom") = (4326)),
-  CONSTRAINT "enforce_dims_the_geom" CHECK (ndims("the_geom") = 2)
+  CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
+  CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-  %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-  %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
-  %{CREATE INDEX "foo_the_geom_gist_index" ON "foo" USING "gist"("the_geom");}
-    ], statements)
-  end
+          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
 
-  def test_create_geometry_with_schema
-    Mig.create_table('public.foo') do |t|
-      t.geometry :the_geom, :srid => 4326
-    end
+      def test_create_geometry_with_spatial
+        Mig.create_table(:foo) do |t|
+          t.spatial :the_geom, :srid => 4326
+        end
 
-    assert_equal([
-      %{CREATE TABLE "public"."foo" (
+        assert_equal([
+          %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry,
-  CONSTRAINT "enforce_srid_the_geom" CHECK (srid("the_geom") = (4326)),
-  CONSTRAINT "enforce_dims_the_geom" CHECK (ndims("the_geom") = 2)
+  CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
+  CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-  %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-  %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
-  %{CREATE INDEX "foo_the_geom_gist_index" ON "foo" USING "gist"("the_geom");}
-    ], statements)
-  end
+          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
 
-  def test_create_geometry_with_not_null
-    Mig.create_table(:foo) do |t|
-      t.geometry :the_geom, :srid => 4326, :null => false
-    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
+
+        assert_equal([
+          %{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)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
+      def test_create_geography
+        Mig.create_table(:foo) do |t|
+          t.geography :the_geom, :srid => 4326
+        end
+
+        assert_equal([
+          %{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)
+);},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
+
+      def test_create_geometry_with_schema
+        Mig.create_table('shabba.foo') do |t|
+          t.geometry :the_geom, :srid => 4326
+        end
+
+        assert_equal([
+          %{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)
+);},
+          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'shabba' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+          %{INSERT INTO "geometry_columns" VALUES ('', 'shabba', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON "shabba"."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
+
+      def test_create_geometry_with_not_null
+        Mig.create_table(:foo) do |t|
+          t.geometry :the_geom, :srid => 4326, :null => false
+        end
+
+        assert_equal([
+          %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry NOT NULL,
-  CONSTRAINT "enforce_srid_the_geom" CHECK (srid("the_geom") = (4326)),
-  CONSTRAINT "enforce_dims_the_geom" CHECK (ndims("the_geom") = 2)
+  CONSTRAINT "enforce_srid_the_geom" CHECK (ST_srid("the_geom") = (4326)),
+  CONSTRAINT "enforce_dims_the_geom" CHECK (ST_ndims("the_geom") = 2)
 );},
-  %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-  %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
-  %{CREATE INDEX "foo_the_geom_gist_index" ON "foo" USING "gist"("the_geom");}
-    ], statements)
-  end
+          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'GEOMETRY');},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], 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
+      def test_create_geometry_with_null_and_type
+        Mig.create_table(:foo) do |t|
+          t.geometry :the_geom, :srid => 4326, :geometry_type => :polygon
+        end
 
-    assert_equal([
-      %{CREATE TABLE "foo" (
+        assert_equal([
+          %{CREATE TABLE "foo" (
   "id" serial primary key,
   "the_geom" geometry,
-  CONSTRAINT "enforce_srid_the_geom" CHECK (srid("the_geom") = (4326)),
-  CONSTRAINT "enforce_dims_the_geom" CHECK (ndims("the_geom") = 2),
+  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)
 );},
-  %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
-  %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'POLYGON');},
-  %{CREATE INDEX "foo_the_geom_gist_index" ON "foo" USING "gist"("the_geom");}
-    ], statements)
+          %{DELETE FROM "geometry_columns" WHERE f_table_catalog = '' AND f_table_schema = 'public' AND f_table_name = 'foo' AND f_geometry_column = 'the_geom';},
+          %{INSERT INTO "geometry_columns" VALUES ('', 'public', 'foo', 'the_geom', 2, 4326, 'POLYGON');},
+          %{CREATE INDEX "foo_the_geom_gist_index" ON PUBLIC."foo" USING "gist"("the_geom");}
+        ], statements)
+      end
+    end
   end
 end

data/test/index_tests.rb

@@ -28,13 +28,28 @@ class IndexTests < Test::Unit::TestCase
       :conditions => 'bar_id IS NOT NULL'
     })
 
+    Mig.create_index(:foo_bar_id_idx, :foo, {
+      :column => :bar_id
+    }, {
+      :conditions => Foo.send(:sanitize_sql, {
+        :id => [1, 2, 3, 4]
+      })
+    })
+
+    escaped_array = if ActiveRecord::VERSION::STRING >= "3.0"
+      "(1, 2, 3, 4)"
+    else
+      "(1,2,3,4)"
+    end
+
     assert_equal([
       "CREATE INDEX \"foo_names_idx\" ON \"foo\"(\"first_name\", \"last_name\");",
       "CREATE INDEX \"foo_bar_id_idx\" ON \"foo\"(\"bar_id\");",
       "CREATE INDEX \"foo_coalesce_bar_id_idx\" ON \"foo\"((COALESCE(bar_id, 0)));",
       "CREATE INDEX \"foo_search_idx\" ON \"foo\" USING \"gin\"(\"search\");",
       "CREATE INDEX \"foo_names_idx\" ON \"foo\"(\"name\" \"text_pattern_ops\");",
-      "CREATE UNIQUE INDEX CONCURRENTLY \"foo_bar_id_idx\" ON \"foo\"(\"bar_id\" ASC NULLS LAST) WITH (FILLFACTOR = 10) TABLESPACE \"fubar\" WHERE bar_id IS NOT NULL;"
+      "CREATE UNIQUE INDEX CONCURRENTLY \"foo_bar_id_idx\" ON \"foo\"(\"bar_id\" ASC NULLS LAST) WITH (FILLFACTOR = 10) TABLESPACE \"fubar\" WHERE (bar_id IS NOT NULL);",
+      "CREATE INDEX \"foo_bar_id_idx\" ON \"foo\"(\"bar_id\") WHERE (\"foos\".\"id\" IN #{escaped_array});",
     ], statements)
   end
 

data/test/rules_tests.rb

@@ -7,18 +7,18 @@ class RulesTests < Test::Unit::TestCase
 
   def test_create_rule
     ARBC.create_rule(
-      :ignore_root, :update, :users, :instead, :nothing, :conditions => 'user_id = 0'
+      :ignore_root, :update, :foos, :instead, :nothing, :conditions => 'user_id = 0'
     )
     ARBC.create_rule(
-      :ignore_root, :update, :users, :instead, 'SELECT * FROM non_admins', {
+      :ignore_root, :update, :foos, :instead, 'SELECT * FROM non_admins', {
         :force => true,
         :conditions => 'user_id > 0'
       }
     )
 
     assert_equal([
-      "CREATE RULE \"ignore_root\" AS ON UPDATE TO \"users\" WHERE user_id = 0 DO INSTEAD NOTHING;",
-      "CREATE  OR REPLACE RULE \"ignore_root\" AS ON UPDATE TO \"users\" WHERE user_id > 0 DO INSTEAD SELECT * FROM non_admins;"
+      "CREATE RULE \"ignore_root\" AS ON UPDATE TO \"foos\" WHERE user_id = 0 DO INSTEAD NOTHING;",
+      "CREATE  OR REPLACE RULE \"ignore_root\" AS ON UPDATE TO \"foos\" WHERE user_id > 0 DO INSTEAD SELECT * FROM non_admins;"
     ], statements)
   end
 

data/test/sequences_tests.rb

@@ -65,26 +65,4 @@ class SequenceTests < Test::Unit::TestCase
       "SELECT setval('foo', 42, false);"
     ], statements)
   end
-
-  def test_create_sequence
-    Mig.alter_sequence(
-      'what_a_sequence_of_events',
-      :restart_with => 10
-    )
-
-    Mig.alter_sequence(
-      'what_a_sequence_of_events',
-      :start => 10,
-      :increment => 2,
-      :cache => 2,
-      :min_value => nil,
-      :max_value => 10,
-      :owned_by => [ :foo, :id ]
-    )
-
-    assert_equal([
-      "ALTER SEQUENCE \"what_a_sequence_of_events\" RESTART WITH 10;",
-      "ALTER SEQUENCE \"what_a_sequence_of_events\" INCREMENT BY 2 NO MINVALUE MAXVALUE 10 START WITH 10 CACHE 2 OWNED BY \"foo\".\"id\";"
-    ], statements)
-  end
 end

data/test/tables_tests.rb

@@ -5,46 +5,27 @@ require 'test_helper'
 class TablesTests < Test::Unit::TestCase
   include PostgreSQLExtensionsTestHelper
 
-  def test_foreign_key_in_column_definition
+  def test_default_with_expression
     Mig.create_table('foo') do |t|
-      t.integer :foo_id, :references => {
-        :table => :foo,
-        :on_delete => :set_null,
-        :on_update => :cascade
-      }
-
-      t.integer :bar_id, :references => :bar
-
-      t.integer :baz_id, :references => [ :baz ]
-
-      t.foreign_key [ :schabba_id, :doo_id ], :bar, [ :schabba_id, :doo_id ]
+      t.integer :foo_id, :default => { :expression => '10 + 20' }
+      t.integer :bar_id, :default => '20 + 10'
     end
 
-    assert_equal([
+    if ActiveRecord::VERSION::STRING >= "3.2"
+      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",
-  FOREIGN KEY ("schabba_id", "doo_id") REFERENCES "bar" ("schabba_id", "doo_id")
+  "foo_id" integer DEFAULT 10 + 20,
+  "bar_id" integer DEFAULT 20
 );} ], statements)
-  end
-
-  def test_default_with_expression
-    Mig.create_table('foo') do |t|
-      t.integer :foo_id, :default => { :expression => '1 + 1' }
-      t.integer :bar_id, :default => '1 + 1'
-    end
-
-    assert_equal([
+    else
+      assert_equal([
       %{CREATE TABLE "foo" (
   "id" serial primary key,
-  "foo_id" integer DEFAULT 1 + 1,
-  "bar_id" integer DEFAULT '1 + 1'
+  "foo_id" integer DEFAULT 10 + 20,
+  "bar_id" integer DEFAULT '20 + 10'
 );} ], statements)
+    end
   end
 
   def test_like
@@ -121,4 +102,20 @@ class TablesTests < Test::Unit::TestCase
       %{CREATE TABLE "foo" OF "bar" (\n  "id" serial primary key\n);}
     ], statements)
   end
+
+  def test_exclude_constraint
+    Mig.create_table('foo') do |t|
+      t.text :blort
+      t.exclude({
+        :element => 'length(blort)',
+        :with => '='
+      }, {
+        :name => 'exclude_blort_length'
+      })
+    end
+
+    assert_equal([
+      %{CREATE TABLE "foo" (\n  "id" serial primary key,\n  "blort" text,\n  CONSTRAINT "exclude_blort_length" EXCLUDE (length(blort) WITH =)\n);}
+    ], statements)
+  end
 end