activerecord-postgresql-extensions 0.0.7

data/lib/postgresql_extensions/postgresql_indexes.rb

@@ -0,0 +1,219 @@
+
+module ActiveRecord
+  class InvalidIndexColumnDefinition < ActiveRecordError #:nodoc:
+    def initialize(msg, column)
+      super("#{msg} - #{column.inspect}")
+    end
+  end
+
+  class InvalidIndexFillFactory < ActiveRecordError #:nodoc:
+    def initialize(fill_factor)
+      super("Invalid index fill factor - #{fill_factor}")
+    end
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates an index. This method is an alternative to the standard
+      # ActiveRecord add_index method and includes PostgreSQL-specific
+      # options.
+      #
+      # === Differences to add_index
+      #
+      # * With the standard ActiveRecord add_index method, ActiveRecord
+      #   will automatically generate an index name. With create_index,
+      #   you need to supply a name yourself. This is due to the fact
+      #   that PostgreSQL's indexes can include things like expressions
+      #   and special index types, so we're not going to try and parse
+      #   your expressions for you. You'll have to supply your own
+      #   index name.
+      # * Several PostgreSQL-specific options are included. See below
+      #   for details.
+      # * The +columns+ argument supports Hashes to allow for
+      #   expressions. See examples below.
+      #
+      # ==== Options
+      #
+      # * <tt>:unique</tt> - adds UNIQUE to the index definition.
+      # * <tt>:concurrently</tt> - adds CONCURRENTLY to the index
+      #   definition. See the PostgreSQL documentation for a discussion
+      #   on concurrently reindexing tables.
+      # * <tt>:using</tt> - the indexing method to use. PostgreSQL
+      #   supports serveral indexing methods out of the box, the default
+      #   being a binary tree method. For certain column types,
+      #   alternative indexing methods produce better indexing results.
+      #   In some cases, a btree index would be pointless given certain
+      #   datatypes and queries. For instance, PostGIS' geometry
+      #   datatypes should generally be indexed with GiST indexes, while
+      #   the tsvector full text search datatype should generally be
+      #   indexed with a GiN index. See the PostgreSQL documentation
+      #   for details.
+      # * <tt>:fill_factor</tt> - sets the FILLFACTOR value for the
+      #   index. This option tells PostgreSQL how to pack its index
+      #   pages on disk. As indexes grow, they begin to get spread out
+      #   over multiple disk pages, thus reducing efficiency. This option
+      #   allows you to control some of that behaviour. The default
+      #   value for btree indexes is 90, and any value from 10 to
+      #   100 can be used. See the PostgreSQL documentation for more
+      #   details.
+      # * <tt>:tablespace</tt> - sets the tablespace for the index.
+      # * <tt>:conditions</tt> - adds an optional WHERE clause to the
+      #   index. (You can alternatively use the option <tt>:where</tt>
+      #   instead.)
+      #
+      # ==== Column Options
+      #
+      # You can specify a handful of options on each index
+      # column/expression definition by supplying a Hash for the
+      # definition rather than a Symbol/String.
+      #
+      # * <tt>:column</tt> or <tt>:expression</tt> - you can specify
+      #   either <tt>:column</tt> or <tt>:expression</tt> in the column
+      #   definition, but not both. When using <tt>:column</tt>, the
+      #   column name is quoted properly using PostgreSQL's quoting
+      #   rules, while using <tt>:expression</tt> leaves you on your
+      #   own.
+      # * <tt>:opclass</tt> - an "opclass" (a.k.a. "operator class")
+      #   provides hints to the PostgreSQL query planner that allow it
+      #   to more effectively take advantage of indexes. An opclass
+      #   effectively tells the planner what operators can be used by an
+      #   index when searching a column or expression. When creating
+      #   an index, PostgreSQL generally uses an opclass equivalent to
+      #   the column datatype (i.e. +int4_ops+ for an integer column).
+      #   You can override this behaviour when necessary. For instance,
+      #   in queries involving the LIKE operator on a text column,
+      #   PostgreSQL will usually only take advantage of an index if the
+      #   database has been created in the C locale. You can override
+      #   this behaviour by forcing the index to be created using the
+      #   +text_pattern_ops+ opclass
+      # * <tt>:order</tt> - the order to index the column in. This can
+      #   be one of <tt>:asc</tt> or <tt>:desc</tt>.
+      # * <tt>:nulls</tt> - specify whether NULL values should be placed
+      #   <tt>:first</tt> or <tt>:last</tt> in the index.
+      #
+      # ==== Examples
+      #
+      #  ### ruby
+      #  # using multiple columns
+      #  create_index('this_is_my_index', :foo, [ :id, :ref_id ], :using => :gin)
+      #  # => CREATE INDEX "this_is_my_index" ON "foo"("id", "ref_id");
+      #
+      #  # using expressions
+      #  create_index('this_is_another_idx', :foo, { :expression => 'COALESCE(ref_id, 0)' })
+      #  # => CREATE INDEX "this_is_another_idx" ON "foo"((COALESCE(ref_id, 0)));
+      #
+      #  # 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
+      end
+
+      # PostgreSQL-specific version of the standard ActiveRecord
+      # remove_index method.
+      #
+      # Unlike remove_index, you'll have to specify an actual index
+      # name with drop_index. See create_index for the particulars on
+      # why.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_index(name, options = {})
+        sql = 'DROP INDEX '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << Array(name).collect { |i| quote_generic(i) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+
+      # Renames an index.
+      def rename_index(name, new_name, options = {})
+        execute "ALTER INDEX #{quote_generic(name)} RENAME TO #{quote_generic(new_name)}"
+      end
+
+      # Changes an index's tablespace.
+      def alter_index_tablespace(name, tablespace, options = {})
+        execute "ALTER INDEX #{quote_generic(name)} SET TABLESPACE #{quote_tablespace(tablespace)}"
+      end
+    end
+
+    # Creates a PostgreSQL index definition. This class isn't really meant
+    # to be used directly. Instead, see PostgreSQLAdapter#create_index
+    # for usage.
+    class PostgreSQLIndexDefinition
+      attr_accessor :base, :name, :table, :columns, :options
+
+      def initialize(base, name, table, columns, options = {}) #:nodoc:
+        assert_valid_columns(columns)
+        assert_valid_fill_factor(options[:fill_factor])
+
+        @base, @name, @table, @columns, @options = base, name, table, columns, options
+      end
+
+      def to_sql #:nodoc:
+        sql = 'CREATE '
+        sql << 'UNIQUE ' if options[:unique]
+        sql << 'INDEX '
+        sql << 'CONCURRENTLY ' if options[:concurrently]
+        sql << "#{base.quote_generic(name)} ON #{base.quote_table_name(table)}"
+        sql << " USING #{base.quote_generic(options[:using])}" if options[:using]
+        sql << '('
+        sql << [ columns ].flatten.collect do |column|
+          column_def = String.new
+          if column.is_a?(Hash)
+            column_def << if column[:column]
+              "#{base.quote_column_name(column[:column])}"
+            else
+              "(#{column[:expression]})"
+            end
+
+            column_def << " #{base.quote_generic(column[:opclass])}" if column[:opclass]
+            column_def << " #{column[:order].to_s.upcase}" if column[:order]
+            column_def << " NULLS #{column[:nulls].to_s.upcase}" if column[:nulls]
+            column_def
+          else
+            base.quote_column_name(column.to_s)
+          end
+        end.join(', ')
+        sql << ')'
+        sql << " WITH (FILLFACTOR = #{options[:fill_factor].to_i})" if options[:fill_factor]
+        sql << " TABLESPACE #{base.quote_tablespace(options[:tablespace])}" if options[:tablespace]
+        sql << " WHERE #{options[:conditions] || options[:where]}" if options[:conditions] || options[:where]
+        sql
+      end
+      alias :to_s :to_sql
+
+      private
+        def assert_valid_columns(columns) #:nodoc:
+          Array(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)
+              elsif !(column.has_key?(:column) || column.has_key?(:expression))
+                raise ActiveRecord::InvalidIndexColumnDefinition.new("You must specify either :column or :expression in a column definition", column)
+              end
+
+              if ![ 'asc', 'desc' ].include?(column[:order].to_s.downcase)
+                raise ActiveRecord::InvalidIndexColumnDefinition.new("Invalid :order value", column)
+              end if column[:order]
+
+              if ![ 'first', 'last' ].include?(column[:nulls].to_s.downcase)
+                raise ActiveRecord::InvalidIndexColumnDefinition.new("Invalid :nulls value", column)
+              end if column[:nulls]
+            end
+          end
+        end
+
+        def assert_valid_fill_factor(fill_factor) #:nodoc:
+          if !fill_factor.nil?
+            ff = fill_factor.to_i
+            if ff < 0 || ff > 100
+              raise ActiveRecord::InvalidIndexFillFactor.new(fill_factor)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_languages.rb

@@ -0,0 +1,80 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Creates a PostgreSQL procedural language.
+      #
+      # Note that you can grant privileges on languages using the
+      # grant_language_privileges method and revoke them using
+      # revoke_language_privileges.
+      #
+      # ==== Options
+      #
+      # * <tt>:trusted</tt> - adds a TRUSTED clause. Trusted languages
+      #   in PostgreSQL are given a couple of extra abilities that
+      #   their untrusted counterparts lust for, such as the ability
+      #   to touch the server's local file system. This can be rather
+      #   important if you need to access external libraries in your
+      #   language's functions, such as importing CPAN libraries in
+      #   plperl. The default is untrusted.
+      # * <tt>:handler</tt> - this option is used to point the server
+      #   in the direction of the procedural language's hooks and such.
+      #   It's generally not required now unless you for some reason
+      #   need to access a langauge that isn't currently held in the
+      #   <tt>pg_pltemplate</tt> system table.
+      # * <tt>:validator</tt> - this option provides a previously
+      #   declared test function that will be used to test the
+      #   functionality of the newly-installed procedural language.
+      #
+      # You don't often see people using the <tt>:handler</tt> and
+      # <tt>:validator</tt> options, and they're really just kind of
+      # here for the sake of completeness.
+      def create_language language, options = {}
+        sql = 'CREATE '
+        sql << 'TRUSTED ' if options[:trusted]
+        sql << "PROCEDURAL LANGUAGE #{quote_language(language)}"
+        sql << " HANDLER #{quote_language(options[:call_handler])}" if options[:call_handler]
+        sql << " VALIDATOR #{options[:validator]}" if options[:validator]
+        execute sql
+      end
+
+      # Drops a language.
+      #
+      # ==== Options
+      #
+      # * <tt>:if_exists</tt> - adds IF EXISTS.
+      # * <tt>:cascade</tt> - adds CASCADE.
+      def drop_language language, options = {}
+        sql = 'DROP PROCEDURAL LANGUAGE '
+        sql << 'IF EXISTS ' if options[:if_exists]
+        sql << quote_language(language)
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+
+      # Renames a language.
+      def alter_language_name old_language, new_language, options = {}
+        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(old_language)} RENAME TO #{quote_language(new_language)}"
+      end
+
+      # Changes a language's owner.
+      def alter_language_owner language, role, options = {}
+        execute "ALTER PROCEDURAL LANGUAGE #{quote_language(language)} OWNER TO #{quote_language(role)}"
+      end
+
+      # Returns an Array of available languages.
+      def languages(name = nil)
+        query(<<-SQL, name).map { |row| row[0] }
+          SELECT lanname
+          FROM pg_language;
+        SQL
+      end
+
+      def language_exists?(name)
+        languages.include?(name.to_s)
+      end
+    end
+  end
+end

data/lib/postgresql_extensions/postgresql_permissions.rb

@@ -0,0 +1,322 @@
+
+require 'active_record/connection_adapters/postgresql_adapter'
+
+module ActiveRecord
+  class InvalidPrivilegeTypes < ActiveRecordError #:nodoc:
+    def initialize(type, privileges)
+      super("Invalid privileges for #{type} - #{privileges.inspect}")
+    end
+  end
+
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+      # Grants privileges on tables. You can specify multiple tables,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_table_privileges(tables, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :table, tables, privileges, roles, options).to_sql
+      end
+
+      # Grants privileges on sequences. You can specify multiple
+      # sequences, roles and privileges all at once using Arrays for each
+      # of the desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_sequence_privileges(sequences, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :sequence, sequences, privileges, roles, options).to_sql
+      end
+
+      # Grants privileges on databases. You can specify multiple
+      # databases, roles and privileges all at once using Arrays for
+      # each of the desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_database_privileges(databases, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :database, databases, privileges, roles, options).to_sql
+      end
+
+      # Grants privileges on functions. You can specify multiple
+      # functions, roles and privileges all at once using Arrays for
+      # each of the desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_function_privileges(function_prototypes, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :function, function_prototypes, privileges, roles, options, :quote_objects => false).to_sql
+      end
+
+      # Grants privileges on procedural languages. You can specify
+      # multiple languages, roles and privileges all at once using
+      # Arrays for each of the desired parameters. See
+      # PostgreSQLGrantPrivilege for usage.
+      def grant_language_privileges(languages, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :language, languages, privileges, roles, options).to_sql
+      end
+
+      # Grants privileges on schemas. You can specify multiple schemas,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_schema_privileges(schemas, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :schema, schemas, privileges, roles, options, :ignore_schema => true).to_sql
+      end
+
+      # Grants privileges on tablespaces. You can specify multiple
+      # tablespaces, roles and privileges all at once using Arrays for
+      # each of the desired parameters. See PostgreSQLGrantPrivilege for
+      # usage.
+      def grant_tablespace_privileges(tablespaces, privileges, roles, options = {})
+        execute PostgreSQLGrantPrivilege.new(self, :tablespace, tablespaces, privileges, roles, options).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.
+      #
+      # ==== Options
+      #
+      # * <tt>:with_admin_option</tt> - adds the WITH ADMIN OPTION
+      #   clause to the command.
+      def grant_role_membership(roles, role_names, options = {})
+        sql = "GRANT "
+        sql << Array(roles).collect { |r| quote_role(r) }.join(', ')
+        sql << ' TO '
+        sql << Array(role_names).collect { |r| quote_role(r) }.join(', ')
+        sql << ' WITH ADMIN OPTION' if options[:with_admin_option]
+        execute sql
+      end
+
+      # Revokes table privileges. You can specify multiple tables,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_table_privileges(tables, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :table, tables, privileges, roles, options).to_sql
+      end
+
+      # Revokes sequence privileges. You can specify multiple sequences,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_sequence_privileges(sequences, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :sequence, sequences, privileges, roles, options).to_sql
+      end
+
+      # Revokes database privileges. You can specify multiple databases,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_database_privileges(databases, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :database, databases, privileges, roles, options).to_sql
+      end
+
+      # Revokes function privileges. You can specify multiple functions,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_function_privileges(function_prototypes, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :function, function_prototypes, privileges, roles, options, :quote_objects => false).to_sql
+      end
+
+      # Revokes language privileges. You can specify multiple languages,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_language_privileges(languages, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :language, languages, privileges, roles, options).to_sql
+      end
+
+      # Revokes schema privileges. You can specify multiple schemas,
+      # roles and privileges all at once using Arrays for each of the
+      # desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_schema_privileges(schemas, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :schema, schemas, privileges, roles, options, :ignore_schema => true).to_sql
+      end
+
+      # Revokes tablespace privileges. You can specify multiple
+      # tablespaces, roles and privileges all at once using Arrays for
+      # each of the desired parameters. See PostgreSQLRevokePrivilege for
+      # usage.
+      def revoke_tablespace_privileges(tablespaces, privileges, roles, options = {})
+        execute PostgreSQLRevokePrivilege.new(self, :tablespace, tablespaces, privileges, roles, options).to_sql
+      end
+
+      # Revokes role membership. You can specify multiple
+      # roles for both the roles and the role_names parameters using
+      # Arrays.
+      #
+      # ==== Options
+      #
+      # * <tt>:with_admin_option</tt> - adds the WITH ADMIN OPTION
+      #   clause to the command.
+      # * <tt>:cascade</tt> - adds the CASCADE option to the command.
+      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 << ' FROM '
+        sql << Array(role_names).collect { |r| quote_role(r) }.join(', ')
+        sql << ' CASCADE' if options[:cascade]
+        execute sql
+      end
+    end
+
+    # This is a base class for PostgreSQLGrantPrivilege and
+    # PostgreSQLRevokePrivilege and is not meant to be used directly.
+    class PostgreSQLPrivilege
+      attr_accessor :base, :type, :objects, :privileges, :roles, :options, :query_options
+
+      def initialize(base, type, objects, privileges, roles, options = {}, query_options = {}) #:nodoc:
+        assert_valid_privileges type, privileges
+        @base, @type, @objects, @privileges, @roles, @options, @query_options =
+          base, type, objects, privileges, roles, options, query_options
+      end
+
+      private
+        PRIVILEGE_TYPES = {
+          :table         => [ 'select', 'insert', 'update', 'delete', 'references', 'trigger', 'all' ],
+          :sequence      => [ 'usage', 'select', 'update', 'all' ],
+          :database      => [ 'create', 'connect', 'temporary', 'all' ],
+          :function      => [ 'execute', 'all' ],
+          :language      => [ 'usage', 'all' ],
+          :schema        => [ 'create', 'usage', 'all' ],
+          :tablespace    => [ 'create', 'all' ]
+        }.freeze
+
+        def assert_valid_privileges type, privileges
+          check_privileges = Array(privileges).collect(&:to_s) - PRIVILEGE_TYPES[type]
+          if !check_privileges.empty?
+            raise ActiveRecord::InvalidPrivilegeTypes.new(type, check_privileges)
+          end
+        end
+    end
+
+    # Creates queries for granting PostgreSQL role privileges.
+    #
+    # This class is meant to be used by the grant_*_privileges methods
+    # in the PostgreSQLAdapter. Different database objects have
+    # different privileges that you can apply to a role. See the
+    # PostgreSQLPrivilege PRIVILEGE_TYPES constant for usage. Generally
+    # speaking, you usually don't want to use this class directly, but
+    # rather the aforementioned wrapped methods.
+    #
+    # When using the grant_*_privileges methods, you can specify multiple
+    # permissions, objects and roles by using Arrays for the appropriate
+    # argument.
+    #
+    # ==== Examples
+    #
+    #  ### ruby
+    #  grant_table_privileges([ :table1, :table2 ], :select, :joe)
+    #  # => GRANT SELECT ON TABLE "table1", "table2" TO "joe"
+    #
+    #  grant_sequence_privileges(:my_seq, [ :select, :update ], :public)
+    #  # => GRANT SELECT, UPDATE ON SEQUENCE "my_seq" TO PUBLIC
+    #
+    # 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.
+    class PostgreSQLGrantPrivilege < PostgreSQLPrivilege
+      def to_sql #:nodoc:
+        my_query_options = {
+          :quote_objects => true
+        }.merge query_options
+
+        sql = "GRANT #{Array(privileges).collect(&:to_s).collect(&:upcase).join(', ')} ON #{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_schema(t)
+            else
+              base.quote_table_name(t)
+            end
+          else
+            t
+          end
+        end.join(', ')
+
+        sql << ' TO ' << Array(roles).collect do |r|
+          r = r.to_s
+          if r.upcase == 'PUBLIC'
+            'PUBLIC'
+          else
+            base.quote_role r
+          end
+        end.join(', ')
+
+        sql << ' WITH GRANT OPTION' if options[:with_grant_option]
+        sql
+      end
+      alias :to_s :to_sql
+    end
+
+    # Creates queries for revoking PostgreSQL role privileges.
+    #
+    # This class is meant to be used by the revoke_*_privileges methods
+    # in the PostgreSQLAdapter. Different database objects have
+    # different privileges that you can apply to a role. See the
+    # PostgreSQLPrivilege PRIVILEGE_TYPES constant for usage. Generally
+    # speaking, you usually don't want to use this class directly, but
+    # rather the aforementioned wrapped methods.
+    #
+    # When using the revoke_*_privileges methods, you can specify multiple
+    # permissions, objects and roles by using Arrays for the appropriate
+    # argument.
+    #
+    # ==== Examples
+    #
+    #  ### ruby
+    #  revoke_table_privileges([ :table1, :table2 ], :select, :joe)
+    #  # => REVOKE SELECT ON TABLE "table1", "table2" FROM "joe"
+    #
+    #  revoke_sequence_privileges(:my_seq, [ :select, :update ], :public)
+    #  # => REVOKE SELECT, UPDATE ON SEQUENCE "my_seq" FROM PUBLIC
+    #
+    # You can specify the <tt>:grant_option_for</tt> in any of the
+    # revoke_*_privilege methods to add a GRANT OPTION FOR clause to
+    # the command. Note that this option removes the role's ability to
+    # grant the privilege to other roles, but does not remove the
+    # privilege itself.
+    #
+    # You can also specify the <tt>:cascade</tt> option to cause the
+    # privilege revocation to cascade down to depedent privileges.
+    #
+    # The cascading stuff is pretty crazy, so you may want to consult the
+    # PostgreSQL docs on the subject.
+    class PostgreSQLRevokePrivilege < PostgreSQLPrivilege
+      def to_sql #:nodoc:
+        my_query_options = {
+          :quote_objects => 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 #{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_schema(t)
+            else
+              base.quote_table_name(t)
+            end
+          else
+            t
+          end
+        end.join(', ')
+
+        sql << ' FROM ' << Array(roles).collect do |r|
+          r = r.to_s
+          if r.upcase == 'PUBLIC'
+            'PUBLIC'
+          else
+            base.quote_role r
+          end
+        end.join(', ')
+
+        sql << ' CASCADE' if options[:cascade]
+        sql
+      end
+      alias :to_s :to_sql
+    end
+  end
+end