activerecord-postgresql-extensions 0.1.0 → 0.2.0

data/lib/active_record/postgresql_extensions/features.rb

@@ -0,0 +1,46 @@
+
+module ActiveRecord
+  module PostgreSQLExtensions
+  	class FeatureNotSupportedError < Exception
+  		def initialize(feature)
+  			super(%{The feature "#{feature}" is not supported by server. (Server version #{ActiveRecord::PostgreSQLExtensions.SERVER_VERSION}.)"})
+  		end
+  	end
+
+  	module Features
+  		class << self
+	  		def extensions?
+	  			if defined?(@has_extensions)
+	  				@has_extensions
+	  			else
+	  				@has_extensions = ActiveRecord::PostgreSQLExtensions.SERVER_VERSION >= '9.1'
+	  			end
+	  		end
+
+	  		def foreign_tables?
+	  			if defined?(@has_foreign_tables)
+	  				@has_foreign_tables
+	  			else
+	  				@has_foreign_tables = ActiveRecord::PostgreSQLExtensions.SERVER_VERSION >= '9.1'
+	  			end
+	  		end
+
+	  		def modify_mass_privileges?
+	  			if defined?(@has_modify_mass_privileges)
+	  				@has_modify_mass_privileges
+	  			else
+	  				@has_modify_mass_privileges = ActiveRecord::PostgreSQLExtensions.SERVER_VERSION >= '9.0'
+	  			end
+	  		end
+
+	  		def postgis?
+	  			if defined?(@has_postgis)
+	  				@has_postgis
+	  			else
+	  				@has_postgis = !!ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION
+	  			end
+	  		end
+	  	end
+  	end
+  end
+end

data/lib/active_record/postgresql_extensions/indexes.rb

@@ -117,12 +117,28 @@ module ActiveRecord
       # name with drop_index. See create_index for the particulars on
       # why.
       #
+      # You can specify multiple INDEXes with an Array when using drop_index,
+      # but you may need to use the method directly through the ActiveRecord
+      # connection rather than the Migration method, as the Migration method
+      # likes to escape the Array to a String.
+      #
       # ==== Options
       #
       # * <tt>:if_exists</tt> - adds IF EXISTS.
       # * <tt>:cascade</tt> - adds CASCADE.
+      # * <tt>:concurrently</tt> - adds the CONCURRENTLY option when dropping
+      #   the INDEX. When using the :concurrently option, only one INDEX can
+      #   specified and the :cascade option cannot be used. See the PostgreSQL
+      #   documentation for details.
       def drop_index(name, options = {})
+        if options[:concurrently] && options[:cascade]
+          raise ArgumentError.new("The :concurrently and :cascade options cannot be used together.")
+        elsif options[:concurrently] && name.is_a?(Array) && name.length > 1
+          raise ArgumentError.new("The :concurrently option can only be used on a single INDEX.")
+        end
+
         sql = 'DROP INDEX '
+        sql << 'CONCURRENTLY ' if options[:concurrently]
         sql << 'IF EXISTS ' if options[:if_exists]
         sql << Array(name).collect { |i| quote_generic(i) }.join(', ')
         sql << ' CASCADE' if options[:cascade]

data/lib/active_record/postgresql_extensions/permissions.rb

@@ -200,7 +200,9 @@ module ActiveRecord
     #
     # When using the grant_*_privileges methods, you can specify multiple
     # permissions, objects and roles by using Arrays for the appropriate
-    # argument.
+    # argument. You can also apply the privileges to all objects within a
+    # schema by using the :all option in the options Hash and supply the schema
+    # name as the first argument.
     #
     # ==== Examples
     #
@@ -210,6 +212,9 @@ module ActiveRecord
     #   grant_sequence_privileges(:my_seq, [ :select, :update ], :public)
     #   # => GRANT SELECT, UPDATE ON SEQUENCE "my_seq" TO PUBLIC
     #
+    #   grant_sequence_privileges(:public, [ :select, :update ], :joe, :all => true)
+    #   # => GRANT SELECT, UPDATE ON ALL SEQUENCES IN SCHEMA PUBLIC TO "joe"
+    #
     # You can specify the <tt>:with_grant_option</tt> in any of the
     # grant_*_privilege methods to add a WITH GRANT OPTION clause to
     # the command.
@@ -219,19 +224,28 @@ module ActiveRecord
           :quote_objects => true
         }.merge query_options
 
-        sql = "GRANT #{Array(privileges).collect(&:to_s).collect(&:upcase).join(', ')} ON #{type.to_s.upcase} "
+        sql = "GRANT #{Array(privileges).collect(&:to_s).collect(&:upcase).join(', ')} ON "
+
+        if options[:all]
+          if !ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+            raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('modify mass privileges')
+          end
 
-        sql << Array(objects).collect do |t|
-          if my_query_options[:quote_objects]
-            if my_query_options[:ignore_schema]
-              base.quote_generic_ignore_scoped_schema(t)
+          sql << "ALL #{type.to_s.upcase}S IN SCHEMA #{base.quote_schema(objects)}"
+        else
+          sql << "#{type.to_s.upcase} "
+          sql << Array(objects).collect do |t|
+            if my_query_options[:quote_objects]
+              if my_query_options[:ignore_schema]
+                base.quote_generic_ignore_scoped_schema(t)
+              else
+                base.quote_table_name(t)
+              end
             else
-              base.quote_table_name(t)
+              t
             end
-          else
-            t
-          end
-        end.join(', ')
+          end.join(', ')
+        end
 
         sql << ' TO ' << Array(roles).collect do |r|
           r = r.to_s
@@ -259,7 +273,9 @@ module ActiveRecord
     #
     # When using the revoke_*_privileges methods, you can specify multiple
     # permissions, objects and roles by using Arrays for the appropriate
-    # argument.
+    # argument. You can also apply the privileges to all objects within a
+    # schema by using the :all option in the options Hash and supply the schema
+    # name as the first argument.
     #
     # ==== Examples
     #
@@ -288,19 +304,28 @@ module ActiveRecord
 
         sql = 'REVOKE '
         sql << 'GRANT OPTION FOR ' if options[:grant_option_for]
-        sql << "#{Array(privileges).collect(&:to_s).collect(&:upcase).join(', ')} ON #{type.to_s.upcase} "
+        sql << "#{Array(privileges).collect(&:to_s).collect(&:upcase).join(', ')} ON "
 
-        sql << Array(objects).collect do |t|
-          if my_query_options[:quote_objects]
-            if my_query_options[:ignore_schema]
-              base.quote_generic_ignore_scoped_schema(t)
+        if options[:all]
+          if !ActiveRecord::PostgreSQLExtensions::Features.modify_mass_privileges?
+            raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('modify mass privileges')
+          end
+
+          sql << "ALL #{type.to_s.upcase}S IN SCHEMA #{base.quote_schema(objects)}"
+        else
+          sql << "#{type.to_s.upcase} "
+          sql << Array(objects).collect do |t|
+            if my_query_options[:quote_objects]
+              if my_query_options[:ignore_schema]
+                base.quote_generic_ignore_scoped_schema(t)
+              else
+                base.quote_table_name(t)
+              end
             else
-              base.quote_table_name(t)
+              t
             end
-          else
-            t
-          end
-        end.join(', ')
+          end.join(', ')
+        end
 
         sql << ' FROM ' << Array(roles).collect do |r|
           r = r.to_s

data/lib/active_record/postgresql_extensions/postgis.rb

@@ -29,7 +29,9 @@ module ActiveRecord
         def UNKNOWN_SRIDS
           return @UNKNOWN_SRIDS if defined?(@UNKNOWN_SRIDS)
 
-          @UNKNOWN_SRIDS = if self.VERSION[:lib] >= '2.0'
+          @UNKNOWN_SRIDS = if !self.VERSION
+            nil
+          elsif self.VERSION[:lib] >= '2.0'
             {
               :geography => 0,
               :geometry  => 0
@@ -45,7 +47,9 @@ module ActiveRecord
         def UNKNOWN_SRID
           return @UNKNOWN_SRID if defined?(@UNKNOWN_SRID)
 
-          @UNKNOWN_SRID = self.UNKNOWN_SRIDS[:geometry]
+          @UNKNOWN_SRID = if self.UNKNOWN_SRIDS
+            self.UNKNOWN_SRIDS[:geometry]
+          end
         end
       end
     end

data/lib/active_record/postgresql_extensions/tables.rb

@@ -178,27 +178,48 @@ module ActiveRecord
         @table_constraints = Array.new
         @table_name, @options = table_name, options
         super(base)
-
-        self.primary_key(
-          options[:primary_key] || Base.get_primary_key(table_name)
-        ) unless options[:id] == false
       end
 
       def to_sql #:nodoc:
+        if self.options[:of_type]
+          if !@columns.empty?
+            raise ArgumentError.new("Cannot specify columns while using the :of_type option")
+          elsif options[:like]
+            raise ArgumentError.new("Cannot specify both the :like and :of_type options")
+          elsif options[:inherits]
+            raise ArgumentError.new("Cannot specify both the :inherits and :of_type options")
+          else
+            options[:id] = false
+          end
+        end
+
+        unless options[:id] == false
+          self.primary_key(options[:primary_key] || Base.get_primary_key(table_name))
+
+          # ensures that the primary key column is first.
+          @columns.unshift(@columns.pop)
+        end
+
         sql = 'CREATE '
         sql << 'TEMPORARY ' if options[:temporary]
         sql << 'UNLOGGED ' if options[:unlogged]
         sql << 'TABLE '
         sql << 'IF NOT EXISTS ' if options[:if_not_exists]
-        sql << "#{base.quote_table_name(table_name)} "
-        sql << "OF #{base.quote_table_name(options[:of_type])} " if options[:of_type]
-        sql << "(\n  "
+        sql << "#{base.quote_table_name(table_name)}"
+        sql << " OF #{base.quote_table_name(options[:of_type])}" if options[:of_type]
 
-        ary = @columns.collect(&:to_sql)
-        ary << @like if defined?(@like) && @like
+        ary = []
+        if !options[:of_type]
+          ary << @columns.collect(&:to_sql)
+          ary << @like if defined?(@like) && @like
+        end
         ary << @table_constraints unless @table_constraints.empty?
-        sql << ary * ",\n  "
-        sql << "\n)"
+
+        unless ary.empty?
+          sql << " (\n  "
+          sql << ary * ",\n  "
+          sql << "\n)"
+        end
 
         sql << "\nINHERITS (" << Array(options[:inherits]).collect { |i| base.quote_table_name(i) }.join(', ') << ')' if options[:inherits]
         sql << "\nON COMMIT #{options[:on_commit].to_s.upcase.gsub(/_/, ' ')}" if options[:on_commit]
@@ -265,11 +286,16 @@ module ActiveRecord
         @table_constraints << PostgreSQLExcludeConstraint.new(@base, table_name, excludes, options)
       end
 
+      def primary_key_constraint(columns, options = {})
+        @table_constraints << PostgreSQLPrimaryKeyConstraint.new(@base, columns, options)
+      end
+
       def column_with_constraints(name, type, *args) #:nodoc:
         options = args.extract_options!
         check = options.delete(:check)
         references = options.delete(:references)
         unique = options.delete(:unique)
+        primary_key = options.delete(:primary_key)
         column_without_constraints(name, type, options)
 
         if check
@@ -309,6 +335,14 @@ module ActiveRecord
           end
           @table_constraints << PostgreSQLUniqueConstraint.new(@base, name, unique)
         end
+
+        if primary_key
+          unless primary_key.is_a?(Hash)
+            primary_key = {}
+          end
+          @table_constraints << PostgreSQLPrimaryKeyConstraint.new(@base, name, primary_key)
+        end
+
         self
       end
       alias_method_chain :column, :constraints

data/lib/active_record/postgresql_extensions/vacuum.rb

@@ -0,0 +1,101 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      # VACUUMs a database, table or columns on a table. See
+      # PostgreSQLVacuum for details.
+      def vacuum(*args)
+        vacuumer = PostgreSQLVacuum.new(self, *args)
+        execute("#{vacuumer};")
+      end
+    end
+
+    # Creates queries for invoking VACUUM.
+    #
+    # This class is meant to be used by the PostgreSQLAdapter#vacuum method.
+    # VACUUMs can be performed against the database as a whole, on specific
+    # tables or on specific columns.
+    #
+    # ==== Examples
+    #
+    #   ActiveRecord::Base.connection.vacuum
+    #   # => VACUUM;
+    #
+    #   ActiveRecord::Base.connection.vacuum(:full => true, :analyze => true)
+    #   # => VACUUM FULL; # PostgreSQL < 9.0
+    #   # => VACUUM (FULL); # PostgreSQL >= 9.0
+    #
+    #   ActiveRecord::Base.connection.vacuum(:foos)
+    #   # => VACUUM "foos";
+    #
+    #   ActiveRecord::Base.connection.vacuum(:foos, :columns => [ :bar, :baz ])
+    #   # => VACUUM (ANALYZE) "foos" ("bar", "baz");
+    #
+    # ==== Options
+    #
+    # * <tt>:full</tt>, <tt>:freeze</tt>, <tt>:verbose</tt> and
+    #   <tt>:analyze</tt> are all supported.
+    # * <tt>:columns</tt> - specifies the columns to VACUUM. You must specify
+    #   a table when using this option. This option also forces the :analyze
+    #   option to true, as PostgreSQL doesn't like to try and VACUUM a column
+    #   without analyzing it.
+    class PostgreSQLVacuum
+      VACUUM_OPTIONS = %w{
+        FULL FREEZE VERBOSE ANALYZE
+      }.freeze
+
+      attr_accessor :base, :table, :options
+
+      def initialize(base, *args)
+        if !args.length.between?(0, 2)
+          raise ArgumentError.new("Wrong number of arguments #{args.length} for 0-2")
+        end
+
+        options = args.extract_options!
+        table = args.first
+
+        if options[:columns]
+          if !table
+            raise ArgumentError.new("You must specify a table when using the :columns option.")
+          end
+
+          options[:analyze] = true
+        end
+
+        @base, @table, @options = base, table, options
+      end
+
+      def to_sql
+        vacuum_options = VACUUM_OPTIONS.select { |o|
+          o = o.downcase.to_sym
+          self.options[o.to_sym]
+        }
+
+        sql = 'VACUUM'
+
+        if !vacuum_options.empty?
+          sql << if ActiveRecord::PostgreSQLExtensions.SERVER_VERSION.to_f >= 9.0
+            " (#{vacuum_options.join(', ')})"
+          else
+            ' ' << VACUUM_OPTIONS.collect { |v|
+              v.upcase if vacuum_options.include?(v)
+            }.compact.join(' ')
+          end
+        end
+
+        sql << " #{base.quote_table_name(table)}" if self.table
+
+        if options[:columns]
+          sql << ' (' << Array(options[:columns]).collect { |column|
+            base.quote_column_name(column)
+          }.join(', ') << ')'
+        end
+
+        sql
+      end
+      alias :to_s :to_sql
+    end
+  end
+end

data/lib/active_record/postgresql_extensions/version.rb

@@ -1,7 +1,7 @@
 
 module ActiveRecord
   module PostgreSQLExtensions
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end
 

data/lib/activerecord-postgresql-extensions.rb

@@ -3,12 +3,23 @@ require 'active_record/connection_adapters/postgresql_adapter'
 
 module ActiveRecord
   module PostgreSQLExtensions
+    class << self
+      def SERVER_VERSION
+        return @SERVER_VERSION if defined?(@SERVER_VERSION)
+
+        @SERVER_VERSION = if (version_string = ::ActiveRecord::Base.connection.select_rows("SELECT pg_catalog.version()").flatten.first).present?
+          version_string =~ /^\s*PostgreSQL\s+([^\s]+)/
+          $1
+        end
+      end
+    end
   end
 end
 
 dirname = File.join(File.dirname(__FILE__), *%w{ active_record postgresql_extensions })
 
 %w{
+  features
   adapter_extensions
   constraints
   tables
@@ -28,6 +39,7 @@ dirname = File.join(File.dirname(__FILE__), *%w{ active_record postgresql_extens
   text_search
   extensions
   foreign_key_associations
+  vacuum
 }.each do |file|
   require File.join(dirname, file)
 end

data/test/adapter_tests.rb

@@ -2,7 +2,7 @@
 $: << File.dirname(__FILE__)
 require 'test_helper'
 
-class AdapterExtensionTests < Test::Unit::TestCase
+class AdapterExtensionTests < MiniTest::Unit::TestCase
   include PostgreSQLExtensionsTestHelper
 
   def test_quote_table_name_with_schema_string
@@ -62,7 +62,7 @@ class AdapterExtensionTests < Test::Unit::TestCase
       %{SET SESSION ROLE "foo";}
     ], statements)
 
-    assert_raise(ArgumentError) do
+    assert_raises(ArgumentError) do
       ARBC.set_role('foo', :duration => :nonsense)
     end
   end
@@ -141,4 +141,56 @@ class AdapterExtensionTests < Test::Unit::TestCase
       %{ALTER TABLE "foo" ENABLE TRIGGER "baz";}
     ], statements)
   end
+
+  def test_add_column_with_expression
+    Mig.add_column(:foo, :bar, :integer, :default => 100)
+    Mig.add_column(:foo, :bar, :integer, :default => {
+      :expression => '1 + 1'
+    })
+
+    Mig.add_column(:foo, :bar, :integer, :null => false, :default => {
+      :expression => '1 + 1'
+    })
+
+    if RUBY_PLATFORM == 'java' || ActiveRecord::VERSION::MAJOR <= 2
+      assert_equal([
+        %{ALTER TABLE "foo" ADD COLUMN "bar" integer},
+        %{ALTER TABLE "foo" ALTER COLUMN "bar" SET DEFAULT 100},
+        %{ALTER TABLE "foo" ADD COLUMN "bar" integer},
+        %{ALTER TABLE "foo" ALTER COLUMN "bar" SET DEFAULT 1 + 1;},
+        %{ALTER TABLE "foo" ADD COLUMN "bar" integer},
+        %{ALTER TABLE "foo" ALTER COLUMN "bar" SET DEFAULT 1 + 1;},
+        %{UPDATE "foo" SET "bar" = 1 + 1 WHERE "bar" IS NULL},
+        %{ALTER TABLE "foo" ALTER "bar" SET NOT NULL},
+      ], statements)
+    else
+      assert_equal([
+        %{ALTER TABLE "foo" ADD COLUMN "bar" integer DEFAULT 100},
+        %{ALTER TABLE "foo" ADD COLUMN "bar" integer DEFAULT 1 + 1},
+        %{ALTER TABLE "foo" ADD COLUMN "bar" integer DEFAULT 1 + 1 NOT NULL}
+      ], statements)
+    end
+  end
+
+  def test_change_column_with_expression
+    Mig.change_column(:foo, :bar, :integer, :default => 100)
+    Mig.change_column(:foo, :bar, :integer, :default => {
+      :expression => '1 + 1'
+    })
+
+    Mig.change_column(:foo, :bar, :integer, :null => false, :default => {
+      :expression => '1 + 1'
+    })
+
+    assert_equal([
+      %{ALTER TABLE "foo" ALTER COLUMN "bar" TYPE integer},
+      %{ALTER TABLE "foo" ALTER COLUMN "bar" SET DEFAULT 100},
+      %{ALTER TABLE "foo" ALTER COLUMN "bar" TYPE integer},
+      %{ALTER TABLE "foo" ALTER COLUMN "bar" SET DEFAULT 1 + 1;},
+      %{ALTER TABLE "foo" ALTER COLUMN "bar" TYPE integer},
+      %{ALTER TABLE "foo" ALTER COLUMN "bar" SET DEFAULT 1 + 1;},
+      %{UPDATE "foo" SET "bar" = 1 + 1 WHERE "bar" IS NULL},
+      %{ALTER TABLE "foo" ALTER "bar" SET NOT NULL},
+    ], statements)
+  end
 end