activerecord-postgresql-extensions 0.2.2 → 0.3.0

data/lib/active_record/postgresql_extensions/languages.rb

@@ -66,7 +66,7 @@ module ActiveRecord
 
       # Returns an Array of available languages.
       def languages(name = nil)
-        query(<<-SQL, name).map { |row| row[0] }
+        query(PostgreSQLExtensions::Utils.strip_heredoc(<<-SQL), name).map { |row| row[0] }
           SELECT lanname
           FROM pg_language;
         SQL

data/lib/active_record/postgresql_extensions/materialized_views.rb

@@ -0,0 +1,272 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter
+      # Creates a new PostgreSQL materialized view.
+      #
+      # +name+ is the name of the view. View quoting works the same as
+      # table quoting, so you can use PostgreSQLAdapter#with_schema and
+      # friends. See PostgreSQLAdapter#with_schema and
+      # PostgreSQLAdapter#quote_table_name for details.
+      #
+      # +query+ is the SELECT query to use for the view. This is just
+      # a straight-up String, so quoting rules will not apply.
+      #
+      # Note that you can grant privileges on views using the
+      # grant_view_privileges method and revoke them using
+      # revoke_view_privileges.
+      #
+      # ==== Options
+      #
+      # * <tt>:columns</tt> - you can rename the output columns as
+      #   necessary. Note that this can be an Array and that it must be
+      #   the same length as the number of output columns created by
+      #   +query+.
+      # * <tt>:tablespace</tt> - allows you to set the tablespace of a
+      #   materialized view.
+      # * <tt>:with_data</tt> - whether to populate the materialized view
+      #   upon creation. The default is true.
+      #
+      # ==== Examples
+      #
+      #   create_materialized_view(:foo_view, 'SELECT * FROM bar')
+      #   # => CREATE MATERIALIZED VIEW "foo_view" AS SELECT * FROM bar;
+      #
+      #   create_view(
+      #     { :geospatial => :foo_view },
+      #     'SELECT * FROM bar',
+      #     :columns => [ :id, :name, :the_geom ],
+      #     :with_data => false
+      #   )
+      #   # => CREATE MATERIALIZED VIEW "geospatial"."foo_view" ("id", "name", "the_geom") AS SELECT * FROM bar WITH NO DATA;
+      def create_materialized_view(name, query, options = {})
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:materialized_views)
+
+        execute PostgreSQLMaterializedViewDefinition.new(self, name, query, options).to_s
+      end
+
+      # Drops a materialized view.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_materialized_view(*args)
+        options = args.extract_options!
+        args.flatten!
+
+        sql = 'DROP MATERIALIZED VIEW '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << Array.wrap(args).collect { |v| quote_view_name(v) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+        execute("#{sql};")
+      end
+
+      # Renames a materialized view.
+      def rename_materialized_view(name, new_name, options = {})
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :rename_to => new_name
+        }, options).to_sql
+      end
+
+      # Change the default of a materialized view column. The default value can
+      # be either a straight-up value or a Hash containing an expression
+      # in the form <tt>:expression => value</tt> which will be passed
+      # through unescaped. This allows you to set expressions and use
+      # functions and the like.
+      def alter_materialized_view_set_column_default(name, column, default, options = {})
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :column => column,
+          :set_default => default
+        }, options).to_sql
+      end
+
+      # Drop the default value on a materialized view column
+      def alter_materialized_view_drop_column_default(name, column, options = {})
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :drop_default => column
+        }, options).to_sql
+      end
+
+      # Change the ownership of a materialized view.
+      def alter_materialized_view_owner(name, role, options = {})
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :owner_to => role
+        }, options).to_sql
+      end
+
+      # Alter a materialized view's schema.
+      def alter_materialized_view_schema(name, schema, options = {})
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :set_schema => schema
+        }, options).to_sql
+      end
+
+      # Sets a materialized view's options using a Hash.
+      def alter_materialized_view_set_options(name, set_options, options = {})
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :set_options => set_options
+        }, options).to_sql
+      end
+
+      # Resets a materialized view's options.
+      def alter_materialized_view_reset_options(name, *args)
+        options = args.extract_options!
+
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :reset_options => args
+        }, options).to_sql
+      end
+
+      # Cluster a materialized view on an index.
+      def cluster_materialized_view(name, index_name)
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :cluster_on => index_name
+        }).to_sql
+      end
+
+      # Remove a cluster from materialized view.
+      def remove_cluster_from_materialized_view(name)
+        execute PostgreSQLMaterializedViewAlterer.new(self, name, {
+          :remove_cluster => true
+        }).to_sql
+      end
+
+      # Refreshes the data in a materialized view.
+      #
+      # ==== Options
+      #
+      # * <tt>:with_data</tt> - whether to populate the materialized view with
+      #   data. The default is true.
+      def refresh_materialized_view(name, options = {})
+        options = {
+          :with_data => true
+        }.merge(options)
+
+        sql = "REFRESH MATERIALIZED VIEW #{quote_view_name(name)}"
+        sql << " WITH NO DATA" unless options[:with_data]
+
+        execute "#{sql};"
+      end
+    end
+
+    # Creates a PostgreSQL materialized view definition. This class isn't
+    # really meant to be used directly. Instead, see
+    # PostgreSQLAdapter#create_materialized_view for usage.
+    class PostgreSQLMaterializedViewDefinition
+      include ActiveRecord::PostgreSQLExtensions::Utils
+
+      attr_accessor :base, :name, :query, :options
+
+      def initialize(base, name, query, options = {}) #:nodoc:
+        @base, @name, @query, @options = base, name, query, options
+      end
+
+      def to_sql #:nodoc:
+        sql = "CREATE MATERIALIZED VIEW #{base.quote_view_name(name)} "
+
+        if options[:columns]
+          sql << '(' << Array.wrap(options[:columns]).collect do |c|
+            base.quote_column_name(c)
+          end.join(', ') << ') '
+        end
+
+        sql << "WITH (#{options_from_hash_or_string(options[:with_options])}) " if options[:with_options].present?
+
+        sql << "TABLESPACE #{base.quote_tablespace(options[:tablespace])} " if options[:tablespace]
+        sql << "AS #{query}"
+        sql << " WITH NO DATA" if options.key?(:with_data) && !options[:with_data]
+        "#{sql};"
+      end
+      alias :to_s :to_sql
+    end
+
+    # Alters a PostgreSQL materialized view definition. This class isn't
+    # really meant to be used directly. Instead, see the various
+    # PostgreSQLAdapter materialied views methods for usage.
+    class PostgreSQLMaterializedViewAlterer
+      include ActiveRecord::PostgreSQLExtensions::Utils
+
+      attr_accessor :base, :name, :actions, :options
+
+      VALID_OPTIONS = %w{
+        set_default
+        drop_default
+        owner_to
+        rename_to
+        set_schema
+        set_options
+        reset_options
+        cluster_on
+        remove_cluster
+      }.freeze
+
+      def initialize(base, name, actions, options = {}) #:nodoc:
+        @base, @name, @actions, @options = base, name, actions, options
+      end
+
+      def to_sql #:nodoc:
+        all_sql = []
+
+        VALID_OPTIONS.each do |key|
+          key = key.to_sym
+
+          if actions.key?(key)
+            sql = "ALTER MATERIALIZED VIEW "
+            sql << "IF EXISTS " if options[:if_exists]
+            sql << "#{base.quote_view_name(name)} "
+
+            sql << case key
+              when :set_default
+                expression = if actions[:set_default].is_a?(Hash) && actions[:set_default].key?(:expression)
+                   actions[:set_default][:expression]
+                else
+                  base.quote(actions[:set_default])
+                end
+
+                "ALTER COLUMN #{base.quote_column_name(actions[:column])} SET DEFAULT #{expression}"
+
+              when :drop_default
+                "ALTER COLUMN #{base.quote_column_name(actions[:drop_default])} DROP DEFAULT"
+
+              when :owner_to
+                "OWNER TO #{base.quote_role(actions[:owner_to])}"
+
+              when :rename_to
+                "RENAME TO #{base.quote_generic_ignore_scoped_schema(actions[:rename_to])}"
+
+              when :set_schema
+                "SET SCHEMA #{base.quote_schema(actions[:set_schema])}"
+
+              when :set_options
+                ActiveRecord::PostgreSQLExtensions::Features.check_feature(:view_set_options)
+
+                "SET (#{options_from_hash_or_string(actions[:set_options])})" if actions[:set_options].present?
+
+              when :reset_options
+                ActiveRecord::PostgreSQLExtensions::Features.check_feature(:view_set_options)
+
+                'RESET (' << Array.wrap(actions[:reset_options]).collect { |value|
+                  base.quote_generic(value)
+                }.join(", ") << ')'
+
+              when :cluster_on
+                "CLUSTER ON #{base.quote_generic(actions[:cluster_on])}"
+
+              when :remove_cluster
+                next unless actions[:remove_cluster]
+
+                "SET WITHOUT CLUSTER"
+            end
+
+            all_sql << "#{sql};"
+          end
+        end
+
+        all_sql.join("\n")
+      end
+    end
+  end
+end

data/lib/active_record/postgresql_extensions/permissions.rb

@@ -66,6 +66,24 @@ module ActiveRecord
         execute PostgreSQLGrantPrivilege.new(self, :tablespace, tablespaces, privileges, roles, options).to_sql
       end
 
+      # Grants privileges on views. You can specify multiple views,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_view_privileges(views, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :view, views, privileges, roles, options, :named_object_type => false).to_sql
+      end
+
+      # Grants privileges on views. You can specify multiple
+      # materialized views, roles and privileges all at once using Arrays for
+      # each of the desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_materialized_view_privileges(materialized_views, privileges, roles, options = {})
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:materialized_views)
+
+        execute PostgreSQLGrantPrivilege.new(self, :materialized_view, materialized_views, privileges, roles, options, :named_object_type => false).to_sql
+      end
+
       # Grants role membership to another role. You can specify multiple
       # roles for both the roles and the role_names parameters using
       # Arrays.
@@ -76,9 +94,9 @@ module ActiveRecord
       #   clause to the command.
       def grant_role_membership(roles, role_names, options = {})
         sql = "GRANT "
-        sql << Array(roles).collect { |r| quote_role(r) }.join(', ')
+        sql << Array.wrap(roles).collect { |r| quote_role(r) }.join(', ')
         sql << ' TO '
-        sql << Array(role_names).collect { |r| quote_role(r) }.join(', ')
+        sql << Array.wrap(role_names).collect { |r| quote_role(r) }.join(', ')
         sql << ' WITH ADMIN OPTION' if options[:with_admin_option]
         execute("#{sql};")
       end
@@ -139,6 +157,24 @@ module ActiveRecord
         execute PostgreSQLRevokePrivilege.new(self, :tablespace, tablespaces, privileges, roles, options).to_sql
       end
 
+      # Revokes materialized view privileges. You can specify multiple
+      # materialized views, roles and privileges all at once using Arrays for
+      # each of the desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_materialized_view_privileges(materialized_views, privileges, roles, options = {})
+        ActiveRecord::PostgreSQLExtensions::Features.check_feature(:materialized_views)
+
+        execute PostgreSQLRevokePrivilege.new(self, :materialized_view, materialized_views, privileges, roles, options, :named_object_type => false).to_sql
+      end
+
+      # Revokes view privileges. You can specify multiple views,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_view_privileges(views, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :view, views, privileges, roles, options, :named_object_type => false).to_sql
+      end
+
       # Revokes role membership. You can specify multiple
       # roles for both the roles and the role_names parameters using
       # Arrays.
@@ -151,9 +187,9 @@ module ActiveRecord
       def revoke_role_membership(roles, role_names, options = {})
         sql = 'REVOKE '
         sql << 'ADMIN_OPTION_FOR ' if options[:admin_option_for]
-        sql << Array(roles).collect { |r| quote_role(r) }.join(', ')
+        sql << Array.wrap(roles).collect { |r| quote_role(r) }.join(', ')
         sql << ' FROM '
-        sql << Array(role_names).collect { |r| quote_role(r) }.join(', ')
+        sql << Array.wrap(role_names).collect { |r| quote_role(r) }.join(', ')
         sql << ' CASCADE' if options[:cascade]
         execute("#{sql};")
       end
@@ -178,11 +214,13 @@ module ActiveRecord
           :function      => [ 'execute', 'all' ],
           :language      => [ 'usage', 'all' ],
           :schema        => [ 'create', 'usage', 'all' ],
-          :tablespace    => [ 'create', 'all' ]
+          :tablespace    => [ 'create', 'all' ],
+          :view          => [ 'select', 'insert', 'update', 'delete', 'references', 'trigger', 'all' ],
+          :materialized_view => [ 'select', 'insert', 'update', 'delete', 'references', 'trigger' ]
         }.freeze
 
         def assert_valid_privileges type, privileges
-          check_privileges = Array(privileges).collect(&:to_s) - PRIVILEGE_TYPES[type]
+          check_privileges = Array.wrap(privileges).collect(&:to_s) - PRIVILEGE_TYPES[type]
           if !check_privileges.empty?
             raise ActiveRecord::InvalidPrivilegeTypes.new(type, check_privileges)
           end
@@ -221,20 +259,20 @@ module ActiveRecord
     class PostgreSQLGrantPrivilege < PostgreSQLPrivilege
       def to_sql #:nodoc:
         my_query_options = {
-          :quote_objects => true
+          :quote_objects => true,
+          :named_object_type => true
         }.merge query_options
 
-        sql = "GRANT #{Array(privileges).collect(&:to_s).collect(&:upcase).join(', ')} ON "
+        sql = "GRANT #{Array.wrap(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
+          ActiveRecord::PostgreSQLExtensions::Features.check_feature(:modify_mass_privileges)
 
           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|
+          sql << "#{type.to_s.gsub('_', ' ').upcase} " if my_query_options[:named_object_type]
+
+          sql << Array.wrap(objects).collect do |t|
             if my_query_options[:quote_objects]
               if my_query_options[:ignore_schema]
                 base.quote_generic_ignore_scoped_schema(t)
@@ -247,7 +285,7 @@ module ActiveRecord
           end.join(', ')
         end
 
-        sql << ' TO ' << Array(roles).collect do |r|
+        sql << ' TO ' << Array.wrap(roles).collect do |r|
           r = r.to_s
           if r.upcase == 'PUBLIC'
             'PUBLIC'
@@ -299,22 +337,22 @@ module ActiveRecord
     class PostgreSQLRevokePrivilege < PostgreSQLPrivilege
       def to_sql #:nodoc:
         my_query_options = {
-          :quote_objects => true
+          :quote_objects => true,
+          :named_object_type => true
         }.merge query_options
 
         sql = 'REVOKE '
         sql << 'GRANT OPTION FOR ' if options[:grant_option_for]
-        sql << "#{Array(privileges).collect(&:to_s).collect(&:upcase).join(', ')} ON "
+        sql << "#{Array.wrap(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
+          ActiveRecord::PostgreSQLExtensions::Features.check_feature(:modify_mass_privileges)
 
           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|
+          sql << "#{type.to_s.upcase} " if my_query_options[:named_object_type]
+
+          sql << Array.wrap(objects).collect do |t|
             if my_query_options[:quote_objects]
               if my_query_options[:ignore_schema]
                 base.quote_generic_ignore_scoped_schema(t)
@@ -327,7 +365,7 @@ module ActiveRecord
           end.join(', ')
         end
 
-        sql << ' FROM ' << Array(roles).collect do |r|
+        sql << ' FROM ' << Array.wrap(roles).collect do |r|
           r = r.to_s
           if r.upcase == 'PUBLIC'
             'PUBLIC'

data/lib/active_record/postgresql_extensions/roles.rb

@@ -10,27 +10,38 @@ module ActiveRecord
 
   module ConnectionAdapters
     class PostgreSQLAdapter
+      # Creates a PostgreSQL ROLE. See PostgreSQLRole for details on options.
       def create_role(name, options = {})
         execute PostgreSQLRole.new(self, :create, name, options).to_sql
       end
       alias :create_user :create_role
 
+      # Alters a PostgreSQL ROLE. See PostgreSQLRole for details on options.
       def alter_role(name, options = {})
         execute PostgreSQLRole.new(self, :alter, name, options).to_sql
       end
       alias :alter_user :alter_role
 
-      def drop_role(name, options = {})
+      # Drop PostgreSQL ROLEs.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - don't raise an error if the ROLE doesn't
+      #   exist. The default is false.
+      def drop_role(*args)
+        options = args.extract_options!
+        args.flatten!
+
         sql = 'DROP ROLE '
         sql << 'IF EXISTS ' if options[:if_exists]
-        sql << Array(name).collect { |r| quote_role(r) }.join(', ')
+        sql << Array.wrap(args).collect { |r| quote_role(r) }.join(', ')
         execute("#{sql};")
       end
       alias :drop_user :drop_role
     end
 
-    # This is a base class for PostgreSQLGrantPrivilege and
-    # PostgreSQLRevokePrivilege and is not meant to be used directly.
+    # This is a base class for creating and altering ROLEs and is not meant to
+    # be used directly.
     class PostgreSQLRole
       attr_accessor :base, :action, :name, :options
 
@@ -99,17 +110,17 @@ module ActiveRecord
 
         if options[:in_role].present?
           sql << 'IN ROLE'
-          sql << Array(options[:in_role]).collect { |r| base.quote_role(r) }.join(', ')
+          sql << Array.wrap(options[:in_role]).collect { |r| base.quote_role(r) }.join(', ')
         end
 
         if options[:role].present?
           sql << 'ROLE'
-          sql << Array(options[:role]).collect { |r| base.quote_role(r) }.join(', ')
+          sql << Array.wrap(options[:role]).collect { |r| base.quote_role(r) }.join(', ')
         end
 
         if options[:admin].present?
           sql << 'ADMIN'
-          sql << Array(options[:admin]).collect { |r| base.quote_role(r) }.join(', ')
+          sql << Array.wrap(options[:admin]).collect { |r| base.quote_role(r) }.join(', ')
         end
 
         "#{sql.join(' ')};"