activerecord-postgresql-extensions 0.2.2 → 0.3.0

data/lib/active_record/postgresql_extensions/event_triggers.rb

@@ -0,0 +1,129 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  class InvalidEventTriggerEventType < ActiveRecordError #:nodoc:
+    def initialize(events)
+      super("Invalid trigger event(s) - #{events.inspect}")
+    end
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      # Creates a PostgreSQL event trigger. Available in PostgreSQL 9.3+.
+      #
+      # +event+ is one of the valid event trigger event names. See the
+      # PostgreSQL documentation for details.
+      #
+      # ==== Options
+      #
+      # ==== Example
+      #
+      def create_event_trigger(name, event, function, options = {})
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:event_triggers)
+
+        execute PostgreSQLEventTriggerDefinition.new(self, name, event, function, options).to_s
+      end
+
+      # Drops an event trigger.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - cascades changes down to objects referring
+      #   to the trigger.
+      def drop_event_trigger(name, options = {})
+        sql = 'DROP EVENT TRIGGER '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << quote_generic(name)
+        sql << ' CASCADE' if options[:cascade]
+        execute("#{sql};")
+      end
+
+      # Renames an event trigger.
+      def rename_event_trigger(name, new_name)
+        execute "ALTER EVENT TRIGGER #{quote_generic(name)} RENAME TO #{quote_generic(new_name)};"
+      end
+
+      # Reassigns ownership of an event trigger.
+      def alter_event_trigger_owner(name, role)
+        execute "ALTER EVENT TRIGGER #{quote_generic(name)} OWNER TO #{quote_generic(role)};"
+      end
+
+      # Enables an event trigger.
+      #
+      # ==== Options
+      #
+      # * <tt>:replica
+      def enable_event_trigger(name, options = {})
+        if options[:always] && options[:replica]
+          raise ArgumentError.new("Cannot use :replica and :always together when enabling an event trigger.")
+        end
+
+        sql = "ALTER EVENT TRIGGER #{quote_generic(name)} ENABLE"
+
+        if options[:always]
+          sql << ' ALWAYS'
+        elsif options[:replica]
+          sql << ' REPLICA'
+        end
+
+        execute "#{sql};"
+      end
+
+      # Disables an event trigger.
+      def disable_event_trigger(name)
+        execute "ALTER EVENT TRIGGER #{quote_generic(name)} DISABLE;"
+      end
+    end
+
+    # Creates a PostgreSQL event trigger definition. This class isn't really
+    # meant to be used directly. You'd be better off sticking to
+    # PostgreSQLAdapter#create_event_trigger. Honestly.
+    class PostgreSQLEventTriggerDefinition
+      attr_accessor :base, :name, :event, :function, :options
+
+      def initialize(base, name, event, function, options = {}) #:nodoc:
+        assert_valid_event_name(event)
+
+        @base, @name, @event, @function, @options =
+          base, name, event, function, options
+      end
+
+      def to_sql #:nodoc:
+        sql = "CREATE EVENT TRIGGER #{base.quote_generic(name)} ON #{base.quote_generic(event)}"
+
+        if options[:when].present?
+          sql << "\n  WHEN "
+
+          sql << options[:when].inject([]) { |memo, (k, v)|
+            memo.tap {
+              values = Array.wrap(v).collect { |value|
+                base.quote(value)
+              }.join(', ')
+
+              memo << "#{base.quote_generic(k)} IN (#{values})"
+            }
+          }.join("\n  AND ")
+
+          sql << "\n "
+        end
+
+        sql << " EXECUTE PROCEDURE #{base.quote_function(function)}()"
+
+        "#{sql};"
+      end
+      alias :to_s :to_sql
+
+
+      private
+        EVENT_NAMES = %w{ ddl_command_start ddl_command_end sql_drop }.freeze
+
+        def assert_valid_event_name(event) #:nodoc:
+          if !EVENT_NAMES.include?(event.to_s.downcase)
+            raise ActiveRecord::InvalidEventTriggerEventType.new(event)
+          end
+        end
+    end
+  end
+end

data/lib/active_record/postgresql_extensions/extensions.rb

@@ -8,8 +8,7 @@ module ActiveRecord
       # either a parser_name or a source_config option as per the PostgreSQL
       # text search docs.
       def create_extension(name, options = {})
-        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
-          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:extensions)
 
         sql = "CREATE EXTENSION "
         sql << "IF NOT EXISTS " if options[:if_not_exists]
@@ -26,22 +25,20 @@ module ActiveRecord
       # * <tt>if_exists</tt> - adds IF EXISTS.
       # * <tt>cascade</tt> - adds CASCADE.
       def drop_extension(*args)
-        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
-          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:extensions)
 
         options = args.extract_options!
 
         sql = 'DROP EXTENSION '
         sql << 'IF EXISTS ' if options[:if_exists]
-        sql << Array(args).collect { |name| quote_generic(name) }.join(', ')
+        sql << Array.wrap(args).collect { |name| quote_generic(name) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
 
         execute("#{sql};")
       end
 
       def update_extension(name, new_version = nil)
-        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
-          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:extensions)
 
         sql = "ALTER EXTENSION #{quote_generic(name)} UPDATE"
         sql << " TO #{quote_generic(new_version)}" if new_version;
@@ -49,8 +46,7 @@ module ActiveRecord
       end
 
       def alter_extension_schema(name, schema)
-        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
-          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:extensions)
 
         execute "ALTER EXTENSION #{quote_generic(name)} SET SCHEMA #{quote_schema(schema)};"
       end
@@ -124,8 +120,7 @@ module ActiveRecord
       # * <tt>:operator_class</tt> and <tt>:operator_family</tt> - <tt>:name</tt>
       #   and <tt>:indexing_method</tt>.
       def alter_extension(name, options = {})
-        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
-          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:extensions)
 
         alterer = PostgreSQLExtensionAlterer.new(self, name, options)
 
@@ -139,8 +134,7 @@ module ActiveRecord
 
     class PostgreSQLExtensionAlterer
       def initialize(base, name, options = {}) #:nodoc:
-        raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new('extensions') if
-          !ActiveRecord::PostgreSQLExtensions::Features.extensions?
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:extensions)
 
         @base, @name, @options = base, name, options
         @sql = options.collect { |k, v| build_statement(k, v) }
@@ -187,6 +181,8 @@ module ActiveRecord
             action = :add
           end
 
+          assert_valid_action(action)
+
           sql = "ALTER EXTENSION #{@base.quote_generic(@name || name)} #{action.to_s.upcase} "
           sql << case option
             when 'aggregate'
@@ -199,7 +195,7 @@ module ActiveRecord
 
               "AGGREGATE %s (%s)" % [
                 @base.quote_generic(name),
-                Array(types).collect { |t|
+                Array.wrap(types).collect { |t|
                   @base.quote_generic(t)
                 }.join(', ')
               ]
@@ -223,7 +219,7 @@ module ActiveRecord
                   [ args.shift, *args ]
               end
 
-              "FUNCTION #{@base.quote_function(name)}(#{Array(arguments).join(', ')})"
+              "FUNCTION #{@base.quote_function(name)}(#{Array.wrap(arguments).join(', ')})"
             when 'operator'
               name, left_type, right_type =
                 extract_hash_or_array_options(args, :name, :left_type, :right_type)
@@ -234,6 +230,9 @@ module ActiveRecord
                 extract_hash_or_array_options(args, :name, :indexing_method)
 
               "#{option.upcase.gsub('_', ' ')} #{@base.quote_generic(object_name)} USING #{@base.quote_generic(indexing_method)})"
+
+            else
+              raise ArgumentError.new("Unknown operation #{option}")
           end
           sql
         end

data/lib/active_record/postgresql_extensions/features.rb

@@ -1,46 +1,85 @@
 
 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
+    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
+        %w{
+          copy_from_encoding
+          copy_from_freeze
+          copy_from_program
+          create_schema_if_not_exists
+          create_table_if_not_exists
+          create_table_unlogged
+          event_triggers
+          extensions
+          foreign_tables
+          materialized_views
+          modify_mass_privileges
+          postgis
+          rename_rule
+          type_if_not_exists
+          view_if_exists
+          view_recursive
+          view_set_options
+        }.each do |feature|
+          self.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{feature}?
+              sniff_features unless sniffed?
+              !!@has_#{feature}
+            end
+          RUBY
+        end
+
+        def check_feature(feature)
+          if !self.send("#{feature}?")
+            raise ActiveRecord::PostgreSQLExtensions::FeatureNotSupportedError.new(feature)
+          end
+        end
+
+        private
+          def sniffed?
+            @sniffed
+          end
+
+          def sniff_features
+            @sniffed = true
+
+            if ActiveRecord::PostgreSQLExtensions.SERVER_VERSION >= '9.3'
+              @has_copy_from_freeze = true
+              @has_copy_from_program = true
+              @has_create_schema_if_not_exists = true
+              @has_event_triggers = true
+              @has_materialized_views = true
+              @has_rename_rule = true
+              @has_type_if_not_exists = true
+              @has_view_recursive = true
+            end
+
+            if ActiveRecord::PostgreSQLExtensions.SERVER_VERSION >= '9.1'
+              @has_copy_from_encoding = true
+              @has_create_table_if_not_exists = true
+              @has_create_table_unlogged = true
+              @has_extensions = true
+              @has_foreign_tables = true
+              @has_view_if_exists = true
+              @has_view_set_options = true
+            end
+
+            if ActiveRecord::PostgreSQLExtensions.SERVER_VERSION >= '9.0'
+              @has_modify_mass_privileges = true
+            end
+
+            if !!ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION
+              @has_postgis = true
+            end
+          end
+      end
+    end
   end
 end

data/lib/active_record/postgresql_extensions/functions.rb

@@ -228,7 +228,7 @@ module ActiveRecord
               sql << set_me
             end
           else
-            sql << Array(opts).collect do |s|
+            sql << Array.wrap(opts).collect do |s|
               "SET #{s.to_s}"
             end
           end

data/lib/active_record/postgresql_extensions/geometry.rb

@@ -134,20 +134,20 @@ module ActiveRecord
             ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0' ||
             opts[:force_constraints]
           )
-            @table_constraints << PostgreSQLCheckConstraint.new(
+            table_constraints << PostgreSQLCheckConstraint.new(
               base,
               "ST_srid(#{base.quote_column_name(column_name)}) = (#{opts[:srid].to_i})",
               :name => "enforce_srid_#{column_name}"
             )
 
-            @table_constraints << PostgreSQLCheckConstraint.new(
+            table_constraints << PostgreSQLCheckConstraint.new(
               base,
               "ST_ndims(#{base.quote_column_name(column_name)}) = #{opts[:ndims].to_i}",
               :name => "enforce_dims_#{column_name}"
             )
 
             if opts[:geometry_type].to_s.upcase != 'GEOMETRY'
-              @table_constraints << PostgreSQLCheckConstraint.new(
+              table_constraints << PostgreSQLCheckConstraint.new(
                 base,
                 "geometrytype(#{base.quote_column_name(column_name)}) = '#{opts[:geometry_type].to_s.upcase}'::text OR #{base.quote_column_name(column_name)} IS NULL",
                 :name => "enforce_geotype_#{column_name}"
@@ -167,13 +167,11 @@ module ActiveRecord
           [ schema || 'public', table_name ]
         end
 
-        @post_processing ||= Array.new
-
         if opts[:add_geometry_columns_entry] &&
           opts[:spatial_column_type].to_s != 'geography' &&
           ActiveRecord::PostgreSQLExtensions::PostGIS.VERSION[:lib] < '2.0'
 
-          @post_processing << sprintf(
+          self.post_processing << sprintf(
             "DELETE FROM \"geometry_columns\" WHERE f_table_catalog = '' AND " +
             "f_table_schema = %s AND " +
             "f_table_name = %s AND " +
@@ -183,7 +181,7 @@ module ActiveRecord
             base.quote(column_name.to_s)
           )
 
-          @post_processing << sprintf(
+          self.post_processing << sprintf(
             "INSERT INTO \"geometry_columns\" VALUES ('', %s, %s, %s, %d, %d, %s);",
             base.quote(current_scoped_schema.to_s),
             base.quote(current_table_name.to_s),
@@ -201,7 +199,7 @@ module ActiveRecord
             "#{current_table_name}_#{column_name}_gist_index"
           end
 
-          @post_processing << PostgreSQLIndexDefinition.new(
+          self.post_processing << PostgreSQLIndexDefinition.new(
             base,
             index_name,
             { current_scoped_schema => current_table_name },

data/lib/active_record/postgresql_extensions/indexes.rb

@@ -18,7 +18,8 @@ module ActiveRecord
     class PostgreSQLAdapter
       # Creates an index. This method is an alternative to the standard
       # ActiveRecord add_index method and includes PostgreSQL-specific
-      # options.
+      # options. Indexes can be created on tables as well as materialized views
+      # starting with PostgreSQL 9.3.
       #
       # === Differences to add_index
       #
@@ -62,6 +63,9 @@ module ActiveRecord
       # * <tt>:conditions</tt> - adds an optional WHERE clause to the
       #   index. (You can alternatively use the option <tt>:where</tt>
       #   instead.)
+      # * <tt>:index_parameters</tt> - a simple String or Hash used to
+      #   assign index storage parameters. See the PostgreSQL docs for
+      #   details on the various storage parameters available.
       #
       # ==== Column Options
       #
@@ -106,8 +110,8 @@ module ActiveRecord
       #   # additional options
       #   create_index('search_idx', :foo, :tsvector, :using => :gin)
       #   # => CREATE INDEX "search_idx" ON "foo" USING "gin"("tsvector");
-      def create_index(name, table, columns, options = {})
-        execute PostgreSQLIndexDefinition.new(self, name, table, columns, options).to_s
+      def create_index(name, object, columns, options = {})
+        execute PostgreSQLIndexDefinition.new(self, name, object, columns, options).to_s
       end
 
       # PostgreSQL-specific version of the standard ActiveRecord
@@ -130,17 +134,20 @@ module ActiveRecord
       #   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 = {})
+      def drop_index(*args)
+        options = args.extract_options!
+        args.flatten!
+
         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
+        elsif options[:concurrently] && args.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 << Array.wrap(args).collect { |i| quote_generic(i) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
         execute("#{sql};")
       end
@@ -160,13 +167,13 @@ module ActiveRecord
     # to be used directly. Instead, see PostgreSQLAdapter#create_index
     # for usage.
     class PostgreSQLIndexDefinition
-      attr_accessor :base, :name, :table, :columns, :options
+      attr_accessor :base, :name, :object, :columns, :options
 
-      def initialize(base, name, table, columns, options = {}) #:nodoc:
+      def initialize(base, name, object, columns, options = {}) #:nodoc:
         assert_valid_columns(columns)
         assert_valid_fill_factor(options[:fill_factor])
 
-        @base, @name, @table, @columns, @options = base, name, table, columns, options
+        @base, @name, @object, @columns, @options = base, name, object, columns, options
       end
 
       def to_sql #:nodoc:
@@ -174,7 +181,7 @@ module ActiveRecord
         sql << 'UNIQUE ' if options[:unique]
         sql << 'INDEX '
         sql << 'CONCURRENTLY ' if options[:concurrently]
-        sql << "#{base.quote_generic(name)} ON #{base.quote_table_name(table)}"
+        sql << "#{base.quote_generic(name)} ON #{base.quote_table_name(object)}"
         sql << " USING #{base.quote_generic(options[:using])}" if options[:using]
         sql << '('
         sql << [ columns ].flatten.collect do |column|
@@ -196,6 +203,7 @@ module ActiveRecord
         end.join(', ')
         sql << ')'
         sql << " WITH (FILLFACTOR = #{options[:fill_factor].to_i})" if options[:fill_factor]
+        sql << " WITH (#{ActiveRecord::PostgreSQLExtensions::Utils.options_from_hash_or_string(options[:index_parameters], base)})" if options[:index_parameters].present?
         sql << " TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
         sql << " WHERE (#{options[:conditions] || options[:where]})" if options[:conditions] || options[:where]
         "#{sql};"
@@ -204,7 +212,7 @@ module ActiveRecord
 
       private
         def assert_valid_columns(columns) #:nodoc:
-          Array(columns).each do |column|
+          Array.wrap(columns).each do |column|
             if column.is_a?(Hash)
               if column.has_key?(:column) && column.has_key?(:expression)
                 raise ActiveRecord::InvalidIndexColumnDefinition.new("You can't specify both :column and :expression in a column definition", column)