pg_power 1.0.0

data/lib/core_ext/active_record/schema_dumper.rb

@@ -0,0 +1,40 @@
+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.join(', ')
+        end
+
+        stream.puts add_index_statements.sort.join("\n")
+        stream.puts
+      end
+    end
+  end
+end

data/lib/pg_power.rb

@@ -0,0 +1,16 @@
+require "pg_power/engine"
+
+# Rails engine which allows to use some PostgreSQL features:
+# * Schemas.
+# * Comments on columns and tables.
+# * Foreign keys.
+# * Partial indexes.
+module PgPower
+  extend ActiveSupport::Autoload
+
+  autoload :Adapter
+  autoload :SchemaDumper
+  autoload :Tools
+  autoload :Migration
+  autoload :ConnectionAdapters
+end

data/lib/pg_power/connection_adapters.rb

@@ -0,0 +1,9 @@
+module PgPower::ConnectionAdapters # :nodoc:
+  extend ActiveSupport::Autoload
+
+  autoload :AbstractAdapter
+  autoload :PostgreSQLAdapter, 'pg_power/connection_adapters/postgresql_adapter'
+  autoload :Table
+  autoload :ForeignKeyDefinition
+  autoload :IndexDefinition, 'pg_power/connection_adapters/index_definition'
+end

data/lib/pg_power/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,20 @@
+# Extends {ActiveRecord::ConnectionAdapters::AbstractAdapter} class.
+module PgPower::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_power/connection_adapters/abstract_adapter/comment_methods.rb

@@ -0,0 +1,62 @@
+# Extends {ActiveRecord::ConnectionAdapters::AbstractAdapter} with
+# empty methods for comments feature.
+module PgPower::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
+
+  # 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
+end

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

@@ -0,0 +1,67 @@
+# Extends {ActiveRecord::ConnectionAdapters::AbstractAdapter} with
+# empty methods for foreign keys feature.
+module PgPower::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_power/connection_adapters/abstract_adapter/index_methods.rb

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

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

@@ -0,0 +1,18 @@
+# Extends {ActiveRecord::ConnectionAdapters::AbstractAdapter} 
+# with methods for multi schema support.
+module PgPower::ConnectionAdapters::AbstractAdapter::SchemaMethods
+
+  # Provides :schema option to +create_table+ method.
+  def create_table_with_schema_option(table_name, options = {}, &block)
+    schema_name = options.delete(:schema)
+    table_name  = "#{schema_name}.#{table_name}" if schema_name
+    create_table_without_schema_option(table_name, options, &block)
+  end
+
+  # Provides :schema option to +drop_table+ method.
+  def drop_table_with_schema_option(table_name, options = {})
+    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_power/connection_adapters/foreign_key_definition.rb

@@ -0,0 +1,5 @@
+module PgPower::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_power/connection_adapters/index_definition.rb

@@ -0,0 +1,6 @@
+module PgPower::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)
+  end
+end

data/lib/pg_power/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,16 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support pg_power features.
+module PgPower::ConnectionAdapters::PostgreSQLAdapter
+  extend ActiveSupport::Autoload
+  extend ActiveSupport::Concern
+
+  autoload :SchemaMethods   , 'pg_power/connection_adapters/postgresql_adapter/schema_methods'
+  autoload :CommentMethods  , 'pg_power/connection_adapters/postgresql_adapter/comment_methods'
+  autoload :ForeignerMethods, 'pg_power/connection_adapters/postgresql_adapter/foreigner_methods'
+  autoload :IndexMethods    , 'pg_power/connection_adapters/postgresql_adapter/index_methods'
+
+  include SchemaMethods
+  include CommentMethods
+  include ForeignerMethods
+  include IndexMethods
+end

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

@@ -0,0 +1,79 @@
+# Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+# to support comments feature.
+module PgPower::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
+
+  # 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
+
+  # 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
+end

data/lib/pg_power/connection_adapters/postgresql_adapter/foreigner_methods.rb

@@ -0,0 +1,190 @@
+module PgPower # :nodoc:
+  # Raised when an unexpected index exists
+  class IndexExistsError < StandardError
+  end
+
+  # Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
+  # to support foreign keys feature.
+  module ConnectionAdapters::PostgreSQLAdapter::ForeignerMethods
+    def supports_foreign_keys?
+      true
+    end
+
+    # Fetches information about foreign keys related to passed table.
+    # @param [String, Symbol] table_name name of table (e.g. "users", "music.bands")
+    # @return [Foreigner::ConnectionAdapters::ForeignKeyDefinition]
+    def foreign_keys(table_name)
+      relation, schema = table_name.to_s.split('.', 2).reverse
+      quoted_schema = schema ? "'#{schema}'" : "ANY (current_schemas(false))"
+
+      fk_info = select_all <<-SQL
+        SELECT nsp.nspname || '.' || t2.relname AS to_table,
+               a1.attname    AS column     ,
+               a2.attname    AS primary_key,
+               c.conname     AS name       ,
+               c.confdeltype AS dependency
+        FROM pg_constraint c
+        JOIN pg_class t1 ON c.conrelid = t1.oid
+        JOIN pg_class t2 ON c.confrelid = t2.oid
+        JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+        JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+        JOIN pg_namespace t3 ON c.connamespace = t3.oid
+        JOIN pg_namespace nsp ON nsp.oid = t2.relnamespace
+        WHERE c.contype = 'f'
+        AND t1.relname = '#{relation}'
+        AND t3.nspname = #{quoted_schema}
+        ORDER BY c.conname
+      SQL
+
+      fk_info.map do |row|
+        options = {:column => row['column'], :name => row['name'], :primary_key => row['primary_key']}
+
+        options[:dependent] = case row['dependency']
+          when 'c' then :delete
+          when 'n' then :nullify
+          when 'r' then :restrict
+        end
+
+        PgPower::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row['to_table'], options)
+      end
+    end
+
+    # (optionally disable triggers) and drop table
+    # changes adapted from https://github.com/matthuhiggins/foreigner/blob/e72ab9c454c156056d3f037d55e3359cd972af32/lib/foreigner/connection_adapters/sql2003.rb
+    # NOTE: disabling referential integrity requires superuser access in postgres.  Default AR behavior is to just drop_table.
+    #
+    # == Options:
+    # * :force - force disabling of referential integrity
+    #
+    # Note: I don't know a good way to test this -mike 20120420
+    def drop_table(*args)
+      options = args.clone.extract_options!
+      if options[:force]
+        disable_referential_integrity { super }
+      else
+        super
+      end
+    end
+
+    # Adds foreign key.
+    #
+    # Ensures that an index is created for the foreign key, unless :exclude_index is true.
+    #
+    # Raises a [PgPower::IndexExistsError] when :exclude_index is true, but the index already exists.
+    #
+    # == Options:
+    # * :column
+    # * :primary_key
+    # * :dependent
+    # * :exclude_index [Boolean]
+    #
+    # @param [String, Symbol] from_table
+    # @param [String, Symbol] to_table
+    # @param [Hash] options
+    #
+    def add_foreign_key(from_table, to_table, options = {})
+      options[:column] ||= id_column_name_from_table_name(to_table)
+      options[:exclude_index] ||= false
+
+      if index_exists?(from_table, options[:column]) and !options[:exclude_index]
+        raise PgPower::IndexExistsError, "The index, #{index_name(from_table, options[:column])}, already exists.  Use :exclude_index => true when adding the foreign key."
+      end
+
+      sql = "ALTER TABLE #{quote_table_name(from_table)} #{add_foreign_key_sql(from_table, to_table, options)}"
+      execute(sql)
+
+      add_index(from_table, options[:column]) unless options[:exclude_index]
+    end
+
+    # Returns chunk of SQL to add foreign key based on table names and options.
+    def add_foreign_key_sql(from_table, to_table, options = {})
+      foreign_key_name = foreign_key_name(from_table, options[:column], options)
+      primary_key = options[:primary_key] || "id"
+      dependency = dependency_sql(options[:dependent])
+
+      sql =
+        "ADD CONSTRAINT #{quote_column_name(foreign_key_name)} " +
+        "FOREIGN KEY (#{quote_column_name(options[:column])}) " +
+        "REFERENCES #{quote_table_name(ActiveRecord::Migrator.proper_table_name(to_table))}(#{primary_key})"
+      sql << " #{dependency}" if dependency.present?
+      sql << " #{options[:options]}" if options[:options]
+
+      sql
+    end
+
+    #
+    # TODO Determine if we can refactor the method signature
+    #   remove_foreign_key(from_table, to_table_or_options_hash, options={}) => remove_foreign_key(from_table, to_table, options={})
+    #
+    # Removes foreign key.
+    # @param [String, Symbol] from_table
+    # @param [String, Hash] to_table_or_options_hash
+    #
+    # The flexible method signature allows calls of two principal forms. Examples:
+    #
+    #   remove_foreign_key(from_table, options_hash)
+    #
+    # or:
+    #
+    #   remove_foreign_key(from_table, to_table, options_hash)
+    #
+    def remove_foreign_key(from_table, to_table_or_options_hash, options={})
+      if Hash === to_table_or_options_hash
+        options = to_table_or_options_hash
+        column = options[:column]
+        foreign_key_name = foreign_key_name(from_table, column, options)
+        column ||= id_column_name_from_foreign_key_metadata(from_table, foreign_key_name)
+      else
+        column = id_column_name_from_table_name(to_table_or_options_hash)
+        foreign_key_name = foreign_key_name(from_table, column)
+      end
+
+      execute "ALTER TABLE #{quote_table_name(from_table)} #{remove_foreign_key_sql(foreign_key_name)}"
+
+      options[:exclude_index] ||= false
+      remove_index(from_table, column) unless options[:exclude_index] || !index_exists?(from_table, column)
+    end
+
+    # Returns chunk of SQL to  remove foreign key based on table name and options.
+    def remove_foreign_key_sql(foreign_key_name)
+      "DROP CONSTRAINT #{quote_column_name(foreign_key_name)}"
+    end
+
+    # Builds the foreign key column id from the referenced table
+    def id_column_name_from_table_name(table)
+      "#{table.to_s.split('.').last.singularize}_id"
+    end
+    private :id_column_name_from_table_name
+
+    # Extracts the foreign key column id from the foreign key metadata
+    # @param [String, Symbol] from_table
+    # @param [String]         foreign_key_name
+    def id_column_name_from_foreign_key_metadata(from_table, foreign_key_name)
+      keys = foreign_keys(from_table)
+      this_key = keys.find {|key| key.options[:name] == foreign_key_name}
+      this_key.options[:column]
+    end
+    private :id_column_name_from_foreign_key_metadata
+    
+    # Builds default name for constraint
+    def foreign_key_name(table, column, options = {})
+      if options[:name]
+        options[:name]
+      else
+        prefix = table.gsub(".", "_")
+        "#{prefix}_#{column}_fk"
+      end
+    end
+    private :foreign_key_name
+
+    def dependency_sql(dependency)
+      case dependency
+        when :nullify then "ON DELETE SET NULL"
+        when :delete then "ON DELETE CASCADE"
+        when :restrict then "ON DELETE RESTRICT"
+        else ""
+      end
+    end
+    private :dependency_sql
+  end
+end