pg_saurus 2.1.1

data/lib/core_ext/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,191 @@
+module ActiveRecord # :nodoc:
+  module ConnectionAdapters # :nodoc:
+    # Patched version:  3.1.3
+    # Patched methods::
+    #   * indexes
+    class PostgreSQLAdapter
+      # Regex to find columns used in index statements
+      INDEX_COLUMN_EXPRESSION = /ON \w+(?: USING \w+ )?\((.+)\)/
+      # Regex to find where clause in index statements
+      INDEX_WHERE_EXPRESION = /WHERE (.+)$/
+
+      # Returns the list of all tables in the schema search path or a specified schema.
+      #
+      # == Patch:
+      # If current user is not `postgres` original method return all tables from all schemas
+      # without schema prefix. This disables such behavior by querying only default schema.
+      # Tables with schemas will be queried later.
+      #
+      def tables(name = nil)
+        query(<<-SQL, 'SCHEMA').map { |row| row[0] }
+            SELECT tablename
+            FROM pg_tables
+            WHERE schemaname = ANY (ARRAY['public'])
+        SQL
+      end
+
+      # Checks if index exists for given table.
+      #
+      # == Patch:
+      # Search using provided schema if table_name includes schema name.
+      #
+      def index_name_exists?(table_name, index_name, default)
+        schema, table = Utils.extract_schema_and_table(table_name)
+        schemas = schema ? "ARRAY['#{schema}']" : 'current_schemas(false)'
+
+        exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
+          SELECT COUNT(*)
+          FROM pg_class t
+          INNER JOIN pg_index d ON t.oid = d.indrelid
+          INNER JOIN pg_class i ON d.indexrelid = i.oid
+          WHERE i.relkind = 'i'
+            AND i.relname = '#{index_name}'
+            AND t.relname = '#{table}'
+            AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (#{schemas}) )
+        SQL
+      end
+
+      # Returns an array of indexes for the given table.
+      #
+      # == Patch 1 reason:
+      # Since {ActiveRecord::SchemaDumper#tables} is patched to process tables
+      # with a schema prefix, the {#indexes} method receives table_name as
+      # "<schema>.<table>". This patch allows it to handle table names with
+      # a schema prefix.
+      #
+      # == Patch 1:
+      # Search using provided schema if table_name includes schema name.
+      #
+      # == Patch 2 reason:
+      # {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter#indexes} is patched
+      # to support partial indexes using :where clause.
+      #
+      # == Patch 2:
+      # Search the postgres indexdef for the where clause and pass the output to
+      # the custom {PgSaurus::ConnectionAdapters::IndexDefinition}
+      #
+      def indexes(table_name, name = nil)
+        schema, table = Utils.extract_schema_and_table(table_name)
+        schemas = schema ? "ARRAY['#{schema}']" : 'current_schemas(false)'
+
+        result = query(<<-SQL, name)
+          SELECT distinct i.relname, d.indisunique, d.indkey,  pg_get_indexdef(d.indexrelid), t.oid, am.amname
+          FROM pg_class t
+          INNER JOIN pg_index d ON t.oid = d.indrelid
+          INNER JOIN pg_class i ON d.indexrelid = i.oid
+          INNER JOIN pg_am    am ON i.relam = am.oid
+          WHERE i.relkind = 'i'
+            AND d.indisprimary = 'f'
+            AND t.relname = '#{table}'
+            AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (#{schemas}) )
+         ORDER BY i.relname
+        SQL
+
+        result.map do |row|
+          index = {
+            :name          => row[0],
+            :unique        => row[1] == 't',
+            :keys          => row[2].split(" "),
+            :definition    => row[3],
+            :id            => row[4],
+            :access_method => row[5]
+          }
+
+          column_names = find_column_names(table_name, index)
+
+          unless column_names.empty?
+            where   = find_where_statement(index)
+            lengths = find_lengths(index)
+
+            PgSaurus::ConnectionAdapters::IndexDefinition.new(table_name, index[:name], index[:unique], column_names, lengths, where, index[:access_method])
+          end
+        end.compact
+      end
+
+      # Find column names from index attributes. If the columns are virtual (ie
+      # this is an expression index) then it will try to return the functions
+      # that represent each column
+      #
+      # @param [String] table_name the name of the table
+      # @param [Hash] index index attributes
+      # @return [Array]
+      def find_column_names(table_name, index)
+        columns = Hash[query(<<-SQL, "Columns for index #{index[:name]} on #{table_name}")]
+          SELECT a.attnum, a.attname
+          FROM pg_attribute a
+          WHERE a.attrelid = #{index[:id]}
+          AND a.attnum IN (#{index[:keys].join(",")})
+        SQL
+
+        column_names = columns.values_at(*index[:keys]).compact
+
+        if column_names.empty?
+          definition = index[:definition].sub(INDEX_WHERE_EXPRESION, '')
+          if column_expression = definition.match(INDEX_COLUMN_EXPRESSION)[1]
+            column_names = split_expression(column_expression).map do |functional_name|
+              remove_type(functional_name)
+            end
+          end
+        end
+
+        column_names
+      end
+
+      # Splits only on commas outside of parens
+      def split_expression(expression)
+        result = []
+        parens = 0
+        buffer = ""
+
+        expression.chars do |char|
+          case char
+          when ','
+            if parens == 0
+              result.push(buffer)
+              buffer = ""
+              next
+            end
+          when '('
+            parens += 1
+          when ')'
+            parens -= 1
+          end
+
+          buffer << char
+        end
+
+        result << buffer unless buffer.empty?
+        result
+      end
+
+      # Find where statement from index definition
+      #
+      # @param [Hash] index index attributes
+      # @return [String] where statement
+      def find_where_statement(index)
+        index[:definition].scan(INDEX_WHERE_EXPRESION).flatten[0]
+      end
+
+      # Find length of index
+      # TODO Update lengths once we merge in ActiveRecord code that supports it. -dresselm 20120305
+      #
+      # @param [Hash] index index attributes
+      # @return [Array]
+      def find_lengths(index)
+        []
+      end
+
+      # Remove type specification from stored Postgres index definitions
+      #
+      # @param [String] column_with_type the name of the column with type
+      # @return [String]
+      #
+      # @example
+      #   remove_type("((col)::text")
+      #   => "col"
+      def remove_type(column_with_type)
+        column_with_type.sub(/\((\w+)\)::\w+/, '\1')
+      end
+    end
+  end
+end

data/lib/core_ext/active_record/errors.rb

@@ -0,0 +1,6 @@
+module ActiveRecord
+  # Raised when an DB operation cannot be carried out because the current
+  # database user lacks the required privileges.
+  class InsufficientPrivilege < WrappedDatabaseException
+  end
+end

data/lib/core_ext/active_record/schema_dumper.rb

@@ -0,0 +1,42 @@
+module ActiveRecord #:nodoc:
+  # Patched version:  3.1.3
+  # Patched methods::
+  #   * indexes
+  class SchemaDumper #:nodoc:
+    # Writes out index-related details to the schema stream
+    #
+    # == Patch reason:
+    # {ActiveRecord::SchemaDumper#indexes} does not support writing out
+    # details related to partial indexes.
+    #
+    # == Patch:
+    # Append :where clause if there's a partial index
+    #
+    def indexes(table, stream)
+      if (indexes = @connection.indexes(table)).any?
+        add_index_statements = indexes.map do |index|
+          statement_parts = [
+            ('add_index ' + index.table.inspect),
+            index.columns.inspect,
+            (':name => ' + index.name.inspect),
+          ]
+          statement_parts << ':unique => true' if index.unique
+
+          index_lengths = (index.lengths || []).compact
+          statement_parts << (':length => ' + Hash[index.columns.zip(index.lengths)].inspect) unless index_lengths.empty?
+
+          # Patch
+          #  Append :where clause if a partial index
+          statement_parts << (':where => ' + index.where.inspect) if index.where
+
+          statement_parts << (':using => ' + index.access_method.inspect) unless index.access_method.downcase == 'btree'
+
+          '  ' + statement_parts.join(', ')
+        end
+
+        stream.puts add_index_statements.sort.join("\n")
+        stream.puts
+      end
+    end
+  end
+end

data/lib/pg_saurus/connection_adapters/abstract_adapter/comment_methods.rb

@@ -0,0 +1,80 @@
+# Extends ActiveRecord::ConnectionAdapters::AbstractAdapter with
+# empty methods for comments feature.
+module PgSaurus::ConnectionAdapters::AbstractAdapter::CommentMethods
+  def supports_comments?
+    false
+  end
+
+  # Sets a comment on the given table.
+  #
+  # ===== Example
+  # ====== Creating a comment on phone_numbers table
+  #  set_table_comment :phone_numbers, 'This table stores phone numbers that conform to the North American Numbering Plan.'
+  def set_table_comment(table_name, comment)
+    # Does nothing
+  end
+
+  # Sets a comment on a given column of a given table.
+  #
+  # ===== Example
+  # ====== Creating a comment on npa column of table phone_numbers
+  #  set_column_comment :phone_numbers, :npa, 'Numbering Plan Area Code - Allowed ranges: [2-9] for first digit, [0-9] for second and third digit.'
+  def set_column_comment(table_name, column_name, comment)
+    # Does nothing
+  end
+
+  # Sets comments on multiple columns.  'comments' is a hash of column_name => comment pairs.
+  #
+  # ===== Example
+  # ====== Setting comments on the columns of the phone_numbers table
+  #  set_column_comments :phone_numbers, :npa => 'Numbering Plan Area Code - Allowed ranges: [2-9] for first digit, [0-9] for second and third digit.',
+  #                                      :nxx => 'Central Office Number'
+  def set_column_comments(table_name, comments)
+
+  end
+
+  # Sets the comment on the given index
+  #
+  # ===== Example
+  # ====== Setting comment on the index_pets_on_breed_id index
+  #  set_index_comment 'index_pets_on_breed_id', 'Index on breed_id'
+  def set_index_comment(index_name, comment)
+
+  end
+
+  # Removes any comment from the given table.
+  #
+  # ===== Example
+  # ====== Removing comment from phone numbers table
+  #  remove_table_comment :phone_numbers
+  def remove_table_comment(table_name)
+
+  end
+
+  # Removes any comment from the given column of a given table.
+  #
+  # ===== Example
+  # ====== Removing comment from the npa column of table phone_numbers
+  #  remove_column_comment :phone_numbers, :npa
+  def remove_column_comment(table_name, column_name)
+
+  end
+
+  # Removes any comment from the given columns of a given table.
+  #
+  # ===== Example
+  # ====== Removing comment from the npa and nxx columns of table phone_numbers
+  #  remove_column_comments :phone_numbers, :npa, :nxx
+  def remove_column_comments(table_name, *column_names)
+
+  end
+
+  # Removes the comment from the given index
+  #
+  # ===== Example
+  # ====== Removing comment from the index_pets_on_breed_id index
+  #  remove_index_comment :index_pets_on_breed_id
+  def remove_index_comment(index_name)
+
+  end
+end

data/lib/pg_saurus/connection_adapters/abstract_adapter/foreigner_methods.rb

@@ -0,0 +1,67 @@
+# Extends ActiveRecord::ConnectionAdapters::AbstractAdapter with
+# empty methods for foreign keys feature.
+module PgSaurus::ConnectionAdapters::AbstractAdapter::ForeignerMethods
+  def supports_foreign_keys?
+    false
+  end
+
+  # Adds a new foreign key to the +from_table+, referencing the primary key of +to_table+
+  #
+  # The foreign key will be named after the from and to tables unless you pass
+  # <tt>:name</tt> as an option.
+  #
+  # ===== Examples
+  # ====== Creating a foreign key
+  # add_foreign_key(:comments, :posts)
+  # generates
+  # ALTER TABLE `comments` ADD CONSTRAINT
+  # `comments_post_id_fk` FOREIGN KEY (`post_id`) REFERENCES `posts` (`id`)
+  #
+  # ====== Creating a named foreign key
+  # add_foreign_key(:comments, :posts, :name => 'comments_belongs_to_posts')
+  # generates
+  # ALTER TABLE `comments` ADD CONSTRAINT
+  # `comments_belongs_to_posts` FOREIGN KEY (`post_id`) REFERENCES `posts` (`id`)
+  #
+  # ====== Creating a cascading foreign_key on a custom column
+  # add_foreign_key(:people, :people, :column => 'best_friend_id', :dependent => :nullify)
+  # generates
+  # ALTER TABLE `people` ADD CONSTRAINT
+  # `people_best_friend_id_fk` FOREIGN KEY (`best_friend_id`) REFERENCES `people` (`id`)
+  # ON DELETE SET NULL
+  #
+  # === Supported options
+  # [:column]
+  # Specify the column name on the from_table that references the to_table. By default this is guessed
+  # to be the singular name of the to_table with "_id" suffixed. So a to_table of :posts will use "post_id"
+  # as the default <tt>:column</tt>.
+  # [:primary_key]
+  # Specify the column name on the to_table that is referenced by this foreign key. By default this is
+  # assumed to be "id".
+  # [:name]
+  # Specify the name of the foreign key constraint. This defaults to use from_table and foreign key column.
+  # [:dependent]
+  # If set to <tt>:delete</tt>, the associated records in from_table are deleted when records in to_table table are deleted.
+  # If set to <tt>:nullify</tt>, the foreign key column is set to +NULL+.
+  # [:options]
+  # Any extra options you want appended to the foreign key definition.
+  def add_foreign_key(from_table, to_table, options = {})
+  end
+
+  # Remove the given foreign key from the table.
+  #
+  # ===== Examples
+  # ====== Remove the suppliers_company_id_fk in the suppliers table.
+  # remove_foreign_key :suppliers, :companies
+  # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
+  # remove_foreign_key :accounts, :column => :branch_id
+  # ====== Remove the foreign key named party_foreign_key in the accounts table.
+  # remove_foreign_key :accounts, :name => :party_foreign_key
+  def remove_foreign_key(from_table, options)
+  end
+
+  # Return the foreign keys for the schema_dumper
+  def foreign_keys(table_name)
+    []
+  end
+end

data/lib/pg_saurus/connection_adapters/abstract_adapter/index_methods.rb

@@ -0,0 +1,6 @@
+# Extends ActiveRecord::ConnectionAdapters::AbstractAdapter.
+module PgSaurus::ConnectionAdapters::AbstractAdapter::IndexMethods
+  def supports_partial_index?
+    false
+  end
+end

data/lib/pg_saurus/connection_adapters/abstract_adapter/schema_methods.rb

@@ -0,0 +1,20 @@
+# Extends ActiveRecord::ConnectionAdapters::AbstractAdapter
+# with methods for multi-schema support.
+module PgSaurus::ConnectionAdapters::AbstractAdapter::SchemaMethods
+
+  # Provide :schema option to +create_table+ method.
+  def create_table_with_schema_option(table_name, options = {}, &block)
+    options     = options.dup
+    schema_name = options.delete(:schema)
+    table_name  = "#{schema_name}.#{table_name}" if schema_name
+    create_table_without_schema_option(table_name, options, &block)
+  end
+
+  # Provide :schema option to +drop_table+ method.
+  def drop_table_with_schema_option(table_name, options = {})
+    options     = options.dup
+    schema_name = options.delete(:schema)
+    table_name  = "#{schema_name}.#{table_name}" if schema_name
+    drop_table_without_schema_option(table_name, options)
+  end
+end

data/lib/pg_saurus/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,20 @@
+# Extends ActiveRecord::ConnectionAdapters::AbstractAdapter class.
+module PgSaurus::ConnectionAdapters::AbstractAdapter
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+
+  autoload :CommentMethods
+  autoload :ForeignerMethods
+  autoload :SchemaMethods
+  autoload :IndexMethods
+
+  include CommentMethods
+  include ForeignerMethods
+  include SchemaMethods
+  include IndexMethods
+
+  included do
+    alias_method_chain :create_table, :schema_option
+    alias_method_chain :drop_table  , :schema_option
+  end
+end

data/lib/pg_saurus/connection_adapters/foreign_key_definition.rb

@@ -0,0 +1,5 @@
+module PgSaurus::ConnectionAdapters
+  # Structure to store information about foreign keys related to from_table.
+  class ForeignKeyDefinition < Struct.new(:from_table, :to_table, :options)
+  end
+end

data/lib/pg_saurus/connection_adapters/index_definition.rb

@@ -0,0 +1,8 @@
+module PgSaurus::ConnectionAdapters
+  # Structure to store index parameters
+  # Overrides ActiveRecord::ConnectionAdapters::IndexDefinition
+  # with the additional :where parameter.
+  class IndexDefinition < Struct.new( :table, :name, :unique, :columns,
+                                      :lengths, :where, :access_method )
+  end
+end

data/lib/pg_saurus/connection_adapters/postgresql_adapter/comment_methods.rb

@@ -0,0 +1,114 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support comments feature.
+module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::CommentMethods
+  def supports_comments?
+    true
+  end
+
+  # Executes SQL to set comment on table
+  # @param [String, Symbol] table_name name of table to set a comment on
+  # @param [String] comment
+  def set_table_comment(table_name, comment)
+    sql = "COMMENT ON TABLE #{quote_table_name(table_name)} IS $$#{comment}$$;"
+    execute sql
+  end
+
+  # Executes SQL to set comment on column.
+  # @param [String, Symbol] table_name
+  # @param [String, Symbol] column_name
+  # @param [String] comment
+  def set_column_comment(table_name, column_name, comment)
+    sql = "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS $$#{comment}$$;"
+    execute sql
+  end
+
+  # Sets comments on columns of passed table.
+  # @param [String, Symbol] table_name
+  # @param [Hash] comments every key is a column name and value is a comment.
+  def set_column_comments(table_name, comments)
+    comments.each_pair do |column_name, comment|
+      set_column_comment table_name, column_name, comment
+    end
+  end
+
+  # Sets the given comment on the given index
+  # @param [String, Symbol] index_name The name of the index
+  # @param [String, Symbol] comment The comment to set on the index
+  def set_index_comment(index_name, comment)
+    sql = "COMMENT ON INDEX #{quote_string(index_name)} IS $$#{comment}$$;"
+    execute sql
+  end
+
+  # Executes SQL to remove comment on passed table.
+  # @param [String, Symbol] table_name
+  def remove_table_comment(table_name)
+    sql = "COMMENT ON TABLE #{quote_table_name(table_name)} IS NULL;"
+    execute sql
+  end
+
+  # Executes SQL to remove comment on column.
+  # @param [String, Symbol] table_name
+  # @param [String, Symbol] column_name
+  def remove_column_comment(table_name, column_name)
+    sql = "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS NULL;"
+    execute sql
+  end
+
+  # Remove comments on passed table columns.
+  def remove_column_comments(table_name, *column_names)
+    column_names.each do |column_name|
+      remove_column_comment table_name, column_name
+    end
+  end
+
+  # Removes any comment from the given index
+  # @param [String, Symbol] index_name The name of the index
+  def remove_index_comment(index_name)
+    sql = "COMMENT ON INDEX #{quote_string(index_name)} IS NULL;"
+    execute sql
+  end
+
+  # Fetches all comments related to passed table.
+  # I returns table comment and column comments as well.
+  # ===Example
+  #   comments("users") # => [[ ""    , "Comment on table"       ],
+  #                           ["id"   , "Comment on id column"   ],
+  #                           ["email", "Comment on email column"]]
+  def comments(table_name)
+    relation_name, schema_name = table_name.split(".", 2).reverse
+    schema_name ||= :public
+
+    com = select_all <<-SQL
+      SELECT a.attname AS column_name, d.description AS comment
+      FROM pg_description d
+        JOIN pg_class c on c.oid = d.objoid
+        LEFT OUTER JOIN pg_attribute a ON c.oid = a.attrelid AND a.attnum = d.objsubid
+        JOIN pg_namespace ON c.relnamespace = pg_namespace.oid
+      WHERE c.relkind = 'r' AND c.relname = '#{relation_name}' AND
+        pg_namespace.nspname = '#{schema_name}'
+    SQL
+    com.map do |row|
+      [ row['column_name'], row['comment'] ]
+    end
+  end
+
+  # Fetches index comments
+  # returns an Array of Arrays, each element representing a single index with comment as
+  #  [ 'schema_name', 'index_name', 'comment' ]
+  def index_comments
+    query =  <<-SQL
+      SELECT c.relname AS index_name, d.description AS comment, pg_namespace.nspname AS schema_name
+      FROM pg_description d
+      JOIN pg_class c ON c.oid = d.objoid
+      JOIN pg_namespace ON c.relnamespace = pg_namespace.oid
+      WHERE c.relkind = 'i'
+      ORDER BY schema_name, index_name
+    SQL
+
+    com = select_all(query)
+
+    com.map do |row|
+      [ row['schema_name'], row['index_name'], row['comment'] ]
+    end
+  end
+end