activerecord-postgresql-extensions 0.0.10 → 0.0.11

data/lib/postgresql_extensions/postgresql_triggers.rb

@@ -41,17 +41,16 @@ module ActiveRecord
       #
       # ==== Example
       #
-      #  ### ruby
-      #  create_trigger(
-      #    'willie_nelsons_trigger',
-      #    :before,
-      #    :update,
-      #    { :nylon => :guitar },
-      #    'strum_trigger',
-      #    :for_each => :row
-      #  )
-      #  # => CREATE TRIGGER "willie_nelsons_trigger" BEFORE UPDATE
-      #  #    ON "nylon"."guitar" FOR EACH ROW EXECUTE PROCEDURE "test_trigger"();
+      #   create_trigger(
+      #     'willie_nelsons_trigger',
+      #     :before,
+      #     :update,
+      #     { :nylon => :guitar },
+      #     'strum_trigger',
+      #     :for_each => :row
+      #   )
+      #   # => CREATE TRIGGER "willie_nelsons_trigger" BEFORE UPDATE
+      #   #    ON "nylon"."guitar" FOR EACH ROW EXECUTE PROCEDURE "test_trigger"();
       def create_trigger(name, called, events, table, function, options = {})
         execute PostgreSQLTriggerDefinition.new(self, name, called, events, table, function, options).to_s
       end
@@ -68,12 +67,12 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << "#{quote_generic(name)} ON #{quote_table_name(table)}"
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        execute("#{sql};")
       end
 
       # Renames a trigger.
       def rename_trigger(name, table, new_name, options = {})
-        execute "ALTER TRIGGER #{quote_generic(name)} ON #{quote_table_name(table)} RENAME TO #{quote_generic(new_name)}"
+        execute "ALTER TRIGGER #{quote_generic(name)} ON #{quote_table_name(table)} RENAME TO #{quote_generic(new_name)};"
       end
     end
 
@@ -99,7 +98,7 @@ module ActiveRecord
         sql << " ON #{base.quote_table_name(table)}"
         sql << " FOR EACH #{options[:for_each].to_s.upcase}" if options[:for_each]
         sql << " EXECUTE PROCEDURE #{base.quote_function(function)}(#{options[:args]})"
-        sql
+        "#{sql};"
       end
       alias :to_s :to_sql
 

data/lib/postgresql_extensions/postgresql_types.rb

@@ -6,7 +6,7 @@ module ActiveRecord
     class PostgreSQLAdapter < AbstractAdapter
       # Returns an Array of available languages.
       def types(name = nil)
-        query(%{SELECT typname FROM pg_type}, name).map { |row| row[0] }
+        query(%{SELECT typname FROM pg_type;}, name).map { |row| row[0] }
       end
 
       def type_exists?(name)

data/lib/postgresql_extensions/postgresql_views.rb

@@ -30,16 +30,15 @@ module ActiveRecord
       #
       # ==== Examples
       #
-      #  ### ruby
-      #  create_view(:foo_view, 'SELECT * FROM bar')
-      #  # => CREATE VIEW "foo_view" AS SELECT * FROM bar;
+      #   create_view(:foo_view, 'SELECT * FROM bar')
+      #   # => CREATE VIEW "foo_view" AS SELECT * FROM bar;
       #
-      #  create_view(
-      #    { :geospatial => :foo_view },
-      #    'SELECT * FROM bar',
-      #    :columns => [ :id, :name, :the_geom ]
-      #  )
-      #  # => CREATE VIEW "geospatial"."foo_view" ("id", "name", "the_geom") AS SELECT * FROM bar;
+      #   create_view(
+      #     { :geospatial => :foo_view },
+      #     'SELECT * FROM bar',
+      #     :columns => [ :id, :name, :the_geom ]
+      #   )
+      #   # => CREATE VIEW "geospatial"."foo_view" ("id", "name", "the_geom") AS SELECT * FROM bar;
       def create_view(name, query, options = {})
         execute PostgreSQLViewDefinition.new(self, name, query, options).to_s
       end
@@ -55,22 +54,22 @@ module ActiveRecord
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(name).collect { |v| quote_view_name(v) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
-        execute sql
+        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_schema(new_name)}"
+        execute "ALTER TABLE #{quote_view_name(name)} RENAME TO #{quote_generic_ignore_schema(new_name)};"
       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 "ALTER TABLE #{quote_view_name(name)} OWNER TO #{quote_role(role)};"
       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 "ALTER TABLE #{quote_view_name(name)} SET SCHEMA #{quote_schema(schema)};"
       end
     end
 
@@ -95,7 +94,7 @@ module ActiveRecord
           end.join(', ') << ') '
         end
         sql << "AS #{query}"
-        sql
+        "#{sql};"
       end
       alias :to_s :to_sql
     end

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

@@ -57,9 +57,9 @@ class AdapterExtensionTests < Test::Unit::TestCase
     ARBC.set_role('foo', :duration => :session)
 
     assert_equal([
-      %{SET ROLE "foo"},
-      %{SET LOCAL ROLE "foo"},
-      %{SET SESSION ROLE "foo"}
+      %{SET ROLE "foo";},
+      %{SET LOCAL ROLE "foo";},
+      %{SET SESSION ROLE "foo";}
     ], ARBC.statements)
 
     assert_raise(ArgumentError) do
@@ -69,7 +69,7 @@ class AdapterExtensionTests < Test::Unit::TestCase
 
   def test_reset_role
     ARBC.reset_role
-    assert_equal([ 'RESET ROLE' ], ARBC.statements)
+    assert_equal([ 'RESET ROLE;' ], ARBC.statements)
   end
 
   def test_current_role
@@ -77,8 +77,8 @@ class AdapterExtensionTests < Test::Unit::TestCase
     ARBC.current_user
 
     assert_equal([
-      'SELECT current_role',
-      'SELECT current_role'
+      'SELECT current_role;',
+      'SELECT current_role;'
     ], ARBC.statements)
   end
 end

data/test/{constraints_test.rb → constraints_tests.rb}

@@ -26,7 +26,7 @@ CREATE TABLE "foo" (
   "email" text,
   UNIQUE ("id", "bar_id"),
   UNIQUE ("name", "email") USING INDEX TABLESPACE "fubar"
-)
+);
 EOF
   end
 
@@ -40,7 +40,7 @@ CREATE TABLE "foo" (
   "id" serial primary key,
   "bar_id" integer,
   UNIQUE ("bar_id")
-)
+);
 EOF
   end
 
@@ -55,8 +55,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
 
@@ -68,11 +68,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
 
@@ -81,8 +81,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
 
@@ -91,8 +91,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
 end

data/test/extensions_tests.rb

@@ -0,0 +1,275 @@
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class ExtensionsTests < Test::Unit::TestCase
+  include PostgreSQLExtensionsTestHelper
+
+  def test_create_extension
+    ARBC.create_extension(:foo)
+    ARBC.create_extension(:foo, :if_not_exists => true)
+    ARBC.create_extension(:foo, :schema => :bar)
+    ARBC.create_extension(:foo, :version => '0.0.1')
+    ARBC.create_extension(:foo, :old_version => '0.0.1')
+
+    assert_equal([
+      %{CREATE EXTENSION "foo";},
+      %{CREATE EXTENSION IF NOT EXISTS "foo";},
+      %{CREATE EXTENSION "foo" SCHEMA "bar";},
+      %{CREATE EXTENSION "foo" VERSION "0.0.1";},
+      %{CREATE EXTENSION "foo" FROM "0.0.1";}
+    ], statements)
+  end
+
+  def test_drop_extension
+    ARBC.drop_extension(:foo)
+    ARBC.drop_extension(:foo, :if_exists => true)
+    ARBC.drop_extension(:foo, :cascade => true)
+    ARBC.drop_extension(:foo, :bar)
+
+    assert_equal([
+      %{DROP EXTENSION "foo";},
+      %{DROP EXTENSION IF EXISTS "foo";},
+      %{DROP EXTENSION "foo" CASCADE;},
+      %{DROP EXTENSION "foo", "bar";}
+    ], statements)
+  end
+
+  def test_update_extension
+    ARBC.update_extension(:foo)
+    ARBC.update_extension(:foo, '2.0.0')
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" UPDATE;},
+      %{ALTER EXTENSION "foo" UPDATE TO "2.0.0";}
+    ], statements)
+  end
+
+  def test_update_schema
+    ARBC.alter_extension_schema(:foo, :bar)
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" SET SCHEMA "bar";}
+    ], statements)
+  end
+
+  def test_alter_extension_empty
+    ARBC.alter_extension(:foo)
+
+    assert_equal([], statements)
+  end
+
+  def test_alter_extension_regular_options_with_hashes
+    ARBC.alter_extension(:foo, {
+      :collation => :bar,
+      :conversion => :bar,
+      :domain => :bar,
+      :foreign_data_wrapper => :bar,
+      :foreign_table => :bar,
+      :schema => :bar,
+      :sequence => :bar,
+      :server => :bar,
+      :table => :bar,
+      :text_search_configuration => :bar,
+      :text_search_dictionary => :bar,
+      :text_search_parser => :bar,
+      :text_search_template => :bar,
+      :type => :bar,
+      :view => :bar
+    })
+
+    ARBC.alter_extension(:foo, {
+      :add_collation => :bar,
+      :add_conversion => :bar,
+      :add_domain => :bar,
+      :add_foreign_data_wrapper => :bar,
+      :add_foreign_table => :bar,
+      :add_schema => :bar,
+      :add_sequence => :bar,
+      :add_server => :bar,
+      :add_table => :bar,
+      :add_text_search_configuration => :bar,
+      :add_text_search_dictionary => :bar,
+      :add_text_search_parser => :bar,
+      :add_text_search_template => :bar,
+      :add_type => :bar,
+      :add_view => :bar
+    })
+
+    ARBC.alter_extension(:foo, {
+      :drop_collation => :bar,
+      :drop_conversion => :bar,
+      :drop_domain => :bar,
+      :drop_foreign_data_wrapper => :bar,
+      :drop_foreign_table => :bar,
+      :drop_schema => :bar,
+      :drop_sequence => :bar,
+      :drop_server => :bar,
+      :drop_table => :bar,
+      :drop_text_search_configuration => :bar,
+      :drop_text_search_dictionary => :bar,
+      :drop_text_search_parser => :bar,
+      :drop_text_search_template => :bar,
+      :drop_type => :bar,
+      :drop_view => :bar
+    })
+
+    assert_equal([
+      [
+        %{ALTER EXTENSION "foo" ADD COLLATION "bar";},
+        %{ALTER EXTENSION "foo" ADD CONVERSION "bar";},
+        %{ALTER EXTENSION "foo" ADD DOMAIN "bar";},
+        %{ALTER EXTENSION "foo" ADD FOREIGN DATA WRAPPER "bar";},
+        %{ALTER EXTENSION "foo" ADD FOREIGN TABLE "bar";},
+        %{ALTER EXTENSION "foo" ADD SCHEMA "bar";},
+        %{ALTER EXTENSION "foo" ADD SEQUENCE "bar";},
+        %{ALTER EXTENSION "foo" ADD SERVER "bar";},
+        %{ALTER EXTENSION "foo" ADD TABLE "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH CONFIGURATION "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH DICTIONARY "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH PARSER "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH TEMPLATE "bar";},
+        %{ALTER EXTENSION "foo" ADD TYPE "bar";},
+        %{ALTER EXTENSION "foo" ADD VIEW "bar";}
+      ].sort,
+
+      [
+        %{ALTER EXTENSION "foo" ADD COLLATION "bar";},
+        %{ALTER EXTENSION "foo" ADD CONVERSION "bar";},
+        %{ALTER EXTENSION "foo" ADD DOMAIN "bar";},
+        %{ALTER EXTENSION "foo" ADD FOREIGN DATA WRAPPER "bar";},
+        %{ALTER EXTENSION "foo" ADD FOREIGN TABLE "bar";},
+        %{ALTER EXTENSION "foo" ADD SCHEMA "bar";},
+        %{ALTER EXTENSION "foo" ADD SEQUENCE "bar";},
+        %{ALTER EXTENSION "foo" ADD SERVER "bar";},
+        %{ALTER EXTENSION "foo" ADD TABLE "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH CONFIGURATION "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH DICTIONARY "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH PARSER "bar";},
+        %{ALTER EXTENSION "foo" ADD TEXT SEARCH TEMPLATE "bar";},
+        %{ALTER EXTENSION "foo" ADD TYPE "bar";},
+        %{ALTER EXTENSION "foo" ADD VIEW "bar";}
+      ].sort,
+
+      [
+        %{ALTER EXTENSION "foo" DROP COLLATION "bar";},
+        %{ALTER EXTENSION "foo" DROP CONVERSION "bar";},
+        %{ALTER EXTENSION "foo" DROP DOMAIN "bar";},
+        %{ALTER EXTENSION "foo" DROP FOREIGN DATA WRAPPER "bar";},
+        %{ALTER EXTENSION "foo" DROP FOREIGN TABLE "bar";},
+        %{ALTER EXTENSION "foo" DROP SCHEMA "bar";},
+        %{ALTER EXTENSION "foo" DROP SEQUENCE "bar";},
+        %{ALTER EXTENSION "foo" DROP SERVER "bar";},
+        %{ALTER EXTENSION "foo" DROP TABLE "bar";},
+        %{ALTER EXTENSION "foo" DROP TEXT SEARCH CONFIGURATION "bar";},
+        %{ALTER EXTENSION "foo" DROP TEXT SEARCH DICTIONARY "bar";},
+        %{ALTER EXTENSION "foo" DROP TEXT SEARCH PARSER "bar";},
+        %{ALTER EXTENSION "foo" DROP TEXT SEARCH TEMPLATE "bar";},
+        %{ALTER EXTENSION "foo" DROP TYPE "bar";},
+        %{ALTER EXTENSION "foo" DROP VIEW "bar";}
+      ].sort
+    ], statements.collect { |s|
+      s.split(/\n/).sort
+    })
+  end
+
+  def test_alter_extension_regular_options_with_block
+    ARBC.alter_extension(:foo) do |e|
+      e.drop_collation :bar
+      e.add_conversion :bar
+      e.domain :bar
+    end
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" DROP COLLATION "bar";
+ALTER EXTENSION "foo" ADD CONVERSION "bar";
+ALTER EXTENSION "foo" ADD DOMAIN "bar";}
+    ], statements)
+  end
+
+  def test_alter_extension_cast_option
+    ARBC.alter_extension(:foo) do |e|
+      e.cast :hello => :world
+      e.cast [ :hello, :world ]
+      e.cast :source => :hello, :target => :world
+    end
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");
+ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");
+ALTER EXTENSION "foo" ADD CAST ("hello" AS "world");}
+    ], statements)
+  end
+
+  def test_alter_extension_aggregate_option
+    ARBC.alter_extension(:foo) do |e|
+      e.aggregate :name => :bar, :types => %w{ type_a type_b type_c }
+      e.aggregate :bar, :type_a, :type_b, :type_c
+    end
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");
+ALTER EXTENSION "foo" ADD AGGREGATE "bar" ("type_a", "type_b", "type_c");}
+    ], statements)
+  end
+
+  def test_alter_extension_operator_option
+    ARBC.alter_extension(:foo) do |e|
+      e.operator :bar, :hello, :world
+      e.operator [ :bar, :hello, :world ]
+      e.operator :name => :bar, :left_type => :hello, :right_type => :world
+    end
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");
+ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");
+ALTER EXTENSION "foo" ADD OPERATOR "bar" ("hello", "world");}
+    ], statements)
+  end
+
+  def test_alter_extension_operator_class_option
+    ARBC.alter_extension(:foo) do |e|
+      e.operator_class :hello => :world
+      e.operator_class :hello, :world
+      e.operator_class [ :hello, :world ]
+      e.operator_class :name => :hello, :indexing_method => :world
+    end
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
+ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
+ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");
+ALTER EXTENSION "foo" ADD OPERATOR CLASS "hello" USING "world");}
+    ], statements)
+  end
+
+  def test_alter_extension_operator_family_option
+    ARBC.alter_extension(:foo) do |e|
+      e.operator_family :hello => :world
+      e.operator_family :hello, :world
+      e.operator_family [ :hello, :world ]
+      e.operator_family :name => :hello, :indexing_method => :world
+    end
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
+ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
+ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");
+ALTER EXTENSION "foo" ADD OPERATOR FAMILY "hello" USING "world");}
+    ], statements)
+  end
+
+  def test_alter_extension_function_option
+    ARBC.alter_extension(:foo) do |e|
+      e.function :bar, "VARIADIC hello world"
+      e.function [ :bar, "VARIADIC hello world" ]
+      e.function :name => :bar, :arguments => "VARIADIC hello world"
+    end
+
+    assert_equal([
+      %{ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);
+ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);
+ALTER EXTENSION "foo" ADD FUNCTION "bar"(VARIADIC hello world);}
+    ], statements)
+  end
+end