pg_saurus 2.1.1

data/lib/pg_saurus/create_index_concurrently.rb

@@ -0,0 +1,227 @@
+# Adds ability to configure in migration how index will be created.
+# See more details how to create index concurrently in PostgreSQL at
+# (see http://www.postgresql.org/docs/9.2/static/sql-createindex.html#SQL-CREATEINDEX-CONCURRENTLY).
+#
+# There are several things you should be aware when use option to create index
+# concurrently.
+# Index can not be created concurrently inside transaction and such indexes
+# creation will be postponed till migration transaction will be closed.
+# In case of migration failure and transaction was rolled back indexes will not
+# be created concurrently. But if indexes which should be created concurrently
+# run with errors migration's transaction won't be rolled back. Error in that
+# case will be raised and migration process will be stoped.
+#
+# Migrations can not ensure that all indexes that tend to be created
+# concurrently were created even if the query for such index creation run
+# without errors. Such indexes creation are deferred because of its nature.
+# So, it's up to you to ensure that indexes was really created or remove
+# partially created invalid indexes.
+#
+# :concurrent_index option conflicts with :exclude_index option in method
+# `add_foreign_key`. So, if you put them together exception will be raised.
+#
+# @example
+#
+#   class AddIndexToNameForUsers < ActiveRecord::Migration
+#     def change
+#       add_index :users, :name, :concurrently => true
+#     end
+#   end
+#
+#   # or with foreign key
+#
+#   class AddForeignKeyToRoleIdForUsers < ActiveRecord::Migration
+#     def change
+#       add_foreign_key :users, :roles, :concurrent_index => true
+#     end
+#   end
+#
+module PgSaurus::CreateIndexConcurrently
+  # Provides ability to postpone index creation queries in migrations.
+  #
+  # Overrides `add_index` and `add_foreign_key` methods for migration to be
+  # able to prevent indexes creation inside scope of transaction if they have to
+  # be created concurrently.
+  # Allows to run creation of postponed indexes.
+  #
+  # This module included into ActiveRecord::Migration class to extend it with
+  # new features.
+  #
+  # All postponed index creation queries are stored inside migration instance.
+  module Migration
+    # @attribute postponed_queries
+    #   @return [Array] list of arguments to call `add_index` method.
+    # @private
+    attr_accessor :postponed_queries
+    private :postponed_queries, :postponed_queries=
+
+
+    # Add a new index to the table. +column_name+ can be a single Symbol, or
+    # an Array of Symbols.
+    #
+    # @param [Symbol, String]                        table_name
+    # @param [Symbol, String, Array<Symbol, String>] column_name
+    # @param [optional, Hash]                        options
+    # @option options [Boolean] :unique
+    # @option options [Boolean] :concurrently
+    # @option options [String]  :where
+    #
+    # @return [nil]
+    #
+    # @see ActiveRecord::ConnectionAdapters::SchemaStatements.add_index in pg_saurus gem
+    def add_index(table_name, column_name, options = {}, &block)
+      table_name = ::ActiveRecord::Migrator.proper_table_name(table_name)
+      # GOTCHA:
+      #   checks if index should be created concurretnly then put it into
+      #   the queue to wait till queue processing will be called (should be
+      #   happended after closing transaction).
+      #   Otherwise just delegate call to PgSaurus's `add_index`.
+      #   Block is given for future compatibility.
+      #   -- zekefast 2012-09-12
+      unless options[:concurrently]
+        return connection.add_index(table_name, column_name, options, &block)
+      end
+
+      enque(table_name, column_name, options, &block)
+      nil
+    end
+
+    # Add a foreign key.
+    #
+    # == Options:
+    # * :column
+    # * :primary_key
+    # * :dependent
+    # * :exclude_index    [Boolean]
+    # * :concurrent_index [Boolean]
+    #
+    # @param [String, Symbol]          from_table
+    # @param [String, Symbol]          to_table
+    # @param [Hash]                    options
+    # @option options [String, Symbol] :column
+    # @option options [String, Symbol] :primary_key
+    # @option options [Hash]           :dependent
+    # @option options [Boolean]        :exclude_index
+    # @option options [Boolean]        :concurrent_index
+    #
+    # @raise [ArgumentError] in case of conflicted option were set
+    #
+    # @see ::PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ForeignerMethods.add_foreign_key
+    def add_foreign_key(from_table, to_table, options = {}, &block)
+      from_table       = ::ActiveRecord::Migrator.proper_table_name(from_table)
+      concurrent_index = options[:concurrent_index]
+
+      if concurrent_index then
+        if options[:exclude_index]
+          raise ArgumentError, 'Conflicted options(exclude_index, concurrent_index) was found, both are set to true.'
+        end
+
+        options[:column] ||= connection.id_column_name_from_table_name(to_table)
+        options = options.merge(:concurrently => concurrent_index)
+
+        index_options = { :concurrently => true }
+        enque(from_table, options[:column], index_options)
+      end
+
+      # GOTCHA:
+      #   proceed foreign key creation, but giving :concurrent_index => true
+      #   prevent normal index creation in PgSaurus's `add_foreign_key`.
+      #   So, postponed creation could be done after transaction.
+      #   -- zekefast 2012-09-12
+      connection.add_foreign_key(from_table, to_table, options, &block)
+    end
+
+    # Execute all postponed index creation.
+    #
+    # @return [::PgSaurus::CreateIndexConcurrently::Migration]
+    def process_postponed_queries
+      Array(@postponed_queries).each do |arguments, block|
+        connection.add_index(*arguments, &block)
+      end
+
+      clear_queue
+
+      self
+    end
+
+    # Clean postponed queries queue.
+    #
+    # @return [::PgSaurus::CreateIndexConcurrently::Migration] migration
+    def clear_queue
+      @postponed_queries = []
+
+      self
+    end
+    private :clear_queue
+
+    # Add to the queue add_index call parameters to be able execute call later.
+    #
+    # @param [Array] arguments
+    # @param [Proc]  block
+    #
+    # @return [::PgSaurus::CreateIndexConcurrently::Migration]
+    def enque(*arguments, &block)
+      @postponed_queries ||= []
+      @postponed_queries << [arguments, block]
+
+      self
+    end
+    private :enque
+  end
+
+  # Allows `process_postponed_queries` to be called on MigrationProxy instances.
+  # So, (see ::PgSaurus::CreateIndexConcurrently::Migrator) could run index
+  # creation concurrently.
+  #
+  # Default delegation in (see ActiveRecord::MigrationProxy) allows to call
+  # only several methods.
+  module MigrationProxy
+    # :nodoc:
+    def self.included(klass)
+      klass.delegate :process_postponed_queries, :to => :migration
+    end
+  end
+
+  # Run postponed index creation for each migration.
+  #
+  # This module included into (see ::ActiveRecord::Migrator) class to make possible
+  # to execute queries for postponed index creation after closing migration's
+  # transaction.
+  #
+  # @see ::ActiveRecord::Migrator.migrate
+  # @see ::ActiveRecord::Migrator.ddl_transaction
+  module Migrator
+    extend ActiveSupport::Concern
+
+    # :nodoc:
+    def self.included(klass)
+      klass.alias_method_chain :ddl_transaction, :postponed_queries
+    end
+
+    # Override (see ::ActiveRecord::Migrator.ddl_transaction) to call
+    # (see ::PgSaurus::CreateIndexConcurrently::Migration.process_postponed_queries)
+    # immediately after transaction.
+    #
+    # @see ::ActiveRecord::Migrator.ddl_transaction
+    def ddl_transaction_with_postponed_queries(*args, &block)
+      ddl_transaction_without_postponed_queries(*args, &block)
+
+      # GOTCHA:
+      #   This might be a bit tricky, but I've decided that this is the best
+      #   way to retrieve migration instance after closing transaction.
+      #   The problem that (see ::ActiveRecord::Migrator) doesn't provide any
+      #   access to recently launched migration. All logic to iterate through
+      #   set of migrations incapsulated in (see ::ActiveRecord::Migrator.migrate)
+      #   method.
+      #   So, to get access to migration you need to override `migrate` method
+      #   and duplicated all logic inside it, plus add call to
+      #   `process_postponed_queries`.
+      #   I've decided this is less forward compatible then retrieving
+      #   value of `migration` variable in context where block
+      #   given to `ddl_transaction` method was created.
+      #   -- zekefast 2012-09-12
+      migration = block.binding.eval('migration')
+      migration.process_postponed_queries
+    end
+  end
+end

data/lib/pg_saurus/engine.rb

@@ -0,0 +1,57 @@
+module PgSaurus
+  # :nodoc:
+  class Engine < Rails::Engine
+
+    initializer 'pg_saurus' do
+      ActiveSupport.on_load(:active_record) do
+        # load monkey patches
+        ['schema_dumper',
+         'errors',
+         'connection_adapters/postgresql_adapter',
+         'connection_adapters/abstract/schema_statements'].each do |path|
+          require ::PgSaurus::Engine.root + 'lib/core_ext/active_record/' + path
+        end
+
+        ActiveRecord::SchemaDumper.class_eval { include ::PgSaurus::SchemaDumper }
+
+        if defined?(ActiveRecord::Migration::CommandRecorder)
+          ActiveRecord::Migration::CommandRecorder.class_eval do
+            include ::PgSaurus::Migration::CommandRecorder
+          end
+        end
+
+        # Follow three include statements add support for concurrently
+        #   index creation in migrations.
+        ActiveRecord::Migration.class_eval do
+          include ::PgSaurus::CreateIndexConcurrently::Migration
+        end
+        ActiveRecord::Migrator.class_eval do
+          include ::PgSaurus::CreateIndexConcurrently::Migrator
+        end
+        ActiveRecord::MigrationProxy.class_eval do
+          include ::PgSaurus::CreateIndexConcurrently::MigrationProxy
+        end
+
+        ActiveRecord::ConnectionAdapters::Table.module_eval do
+          include ::PgSaurus::ConnectionAdapters::Table
+        end
+
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+          include ::PgSaurus::ConnectionAdapters::AbstractAdapter
+        end
+
+        if defined?(ActiveRecord::ConnectionAdapters::JdbcAdapter)
+          sql_adapter_class = ActiveRecord::ConnectionAdapters::JdbcAdapter
+        else
+          sql_adapter_class = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
+        end
+
+        sql_adapter_class.class_eval do
+          include ::PgSaurus::ConnectionAdapters::PostgreSQLAdapter
+        end
+
+      end
+    end
+
+  end
+end

data/lib/pg_saurus/errors.rb

@@ -0,0 +1,6 @@
+module PgSaurus # :nodoc:
+
+  # Raised when an unexpected index exists
+  class IndexExistsError < StandardError; end
+
+end

data/lib/pg_saurus/migration/command_recorder/comment_methods.rb

@@ -0,0 +1,68 @@
+# Provides methods to extend ActiveRecord::Migration::CommandRecorder to
+# support comments feature.
+module  PgSaurus::Migration::CommandRecorder::CommentMethods
+  # :nodoc:
+  def set_table_comment(*args)
+    record(:set_table_comment, args)
+  end
+
+  # :nodoc:
+  def remove_table_comment(*args)
+    record(:remove_table_comment, args)
+  end
+
+  # :nodoc:
+  def set_column_comment(*args)
+    record(:set_column_comment, args)
+  end
+
+  # :nodoc:
+  def set_column_comments(*args)
+    record(:set_column_comments, args)
+  end
+
+  # :nodoc:
+  def remove_column_comment(*args)
+    record(:remove_column_comment, args)
+  end
+
+  # :nodoc:
+  def remove_column_comments(*args)
+    record(:remove_column_comments, args)
+  end
+
+  # :nodoc:
+  def set_index_comment(*args)
+    record(:set_index_comment, args)
+  end
+
+  # :nodoc:
+  def remove_index_comment(*args)
+    record(:remove_index_comment, args)
+  end
+
+  # :nodoc:
+  def invert_set_table_comment(args)
+    table_name = args.first
+    [:remove_table_comment, [table_name]]
+  end
+
+  # :nodoc:
+  def invert_set_column_comment(args)
+    table_name = args[0]
+    column_name = args[1]
+    [:remove_column_comment, [table_name, column_name]]
+  end
+
+  # :nodoc:
+  def invert_set_column_comments(args)
+    i_args = [args[0]] + args[1].collect{|name, value| name  }
+    [:remove_column_comments, i_args]
+  end
+
+  # :nodoc:
+  def invert_set_index_comment(args)
+    index_name = args.first
+    [:remove_index_comment, [index_name]]
+  end
+end

data/lib/pg_saurus/migration/command_recorder/extension_methods.rb

@@ -0,0 +1,25 @@
+# Provides methods to extend ActiveRecord::Migration::CommandRecorder to
+# support extensions feature.
+module  PgSaurus::Migration::CommandRecorder::ExtensionMethods
+  # :nodoc:
+  def create_extension(*args)
+    record(:create_extension, args)
+  end
+
+  # :nodoc:
+  def drop_extension(*args)
+    record(:drop_extension, args)
+  end
+
+  # :nodoc:
+  def invert_create_extension(args)
+    extension_name = args.first
+    [:drop_extension, [extension_name]]
+  end
+
+  # :nodoc:
+  def invert_drop_extension(args)
+    extension_name = args.first
+    [:create_extension, [extension_name]]
+  end
+end

data/lib/pg_saurus/migration/command_recorder/foreigner_methods.rb

@@ -0,0 +1,31 @@
+# Provides methods to extend ActiveRecord::Migration::CommandRecorder to
+# support foreign keys feature.
+module PgSaurus::Migration::CommandRecorder::ForeignerMethods
+  # :nodoc:
+  def add_foreign_key(*args)
+    record(:add_foreign_key, args)
+  end
+
+  # :nodoc:
+  def remove_foreign_key(*args)
+    record(:remove_foreign_key, args)
+  end
+
+  # :nodoc:
+  def invert_add_foreign_key(args)
+    from_table, to_table, add_options = *args
+    add_options ||= {}
+    add_name_option   = add_options[:name]
+    add_column_option = add_options[:column]
+
+    if add_name_option then
+      options = {:name => add_name_option}
+    elsif add_column_option
+      options = {:column => add_column_option}
+    else
+      options = to_table
+    end
+
+    [:remove_foreign_key, [from_table, options]]
+  end
+end

data/lib/pg_saurus/migration/command_recorder/schema_methods.rb

@@ -0,0 +1,59 @@
+# Provides methods to extend ActiveRecord::Migration::CommandRecorder to
+# support multi schemas feature.
+module  PgSaurus::Migration::CommandRecorder::SchemaMethods
+  # :nodoc:
+  def create_schema(*args)
+    record(:create_schema, args)
+  end
+
+  # :nodoc:
+  def drop_schema(*args)
+    record(:drop_schema, args)
+  end
+
+  # :nodoc:
+  def move_table_to_schema(*args)
+    record(:move_table_to_schema, args)
+  end
+
+  # :nodoc:
+  def create_schema_if_not_exists(*args)
+    record(:create_schema_if_not_exists, args)
+  end
+
+  # :nodoc:
+  def drop_schema_if_exists(*args)
+    record(:drop_schema_if_exists, args)
+  end
+
+  # :nodoc:
+  def invert_create_schema(args)
+    [:drop_schema, [args.first]]
+  end
+
+  # :nodoc:
+  def invert_drop_schema(args)
+    [:create_schema, [args.first]]
+  end
+
+  # :nodoc:
+  def invert_move_table_to_schema(args)
+    table_name     = args.first
+    current_schema = args.second
+
+    new_schema, table = ::PgSaurus::Tools.to_schema_and_table(table_name)
+
+    invert_args = ["#{current_schema}.#{table}", new_schema]
+    [:move_table_to_schema, invert_args]
+  end
+
+  # :nodoc:
+  def invert_create_schema_if_not_exists(*args)
+    [:drop_schema_if_exists, args]
+  end
+
+  # :nodoc:
+  def invert_drop_schema_if_exists(*args)
+    [:create_schema_if_not_exists, args]
+  end
+end

data/lib/pg_saurus/migration/command_recorder/view_methods.rb

@@ -0,0 +1,31 @@
+# Provides methods to extend ActiveRecord::Migration::CommandRecorder to
+# support view feature.
+module  PgSaurus::Migration::CommandRecorder::ViewMethods
+  # Create a PostgreSQL view.
+  #
+  # @param args [Array] view_name and view_definition
+  #
+  # @return [view]
+  def create_view(*args)
+    record(:create_view, args)
+  end
+
+  # Drop a view in the DB.
+  #
+  # @param args [Array] first argument is view_name
+  #
+  # @return [void]
+  def drop_view(*args)
+    record(:drop_view, args)
+  end
+
+  # Invert the creation of a view in the DB.
+  #
+  # @param args [Array] first argument is supposed to be name of view
+  #
+  # @return [void]
+  def invert_create_view(args)
+    [:drop_view, [args.first]]
+  end
+
+end

data/lib/pg_saurus/migration/command_recorder.rb

@@ -0,0 +1,17 @@
+# Provides methods to extend ActiveRecord::Migration::CommandRecorder to
+# support pg_saurus features.
+module PgSaurus::Migration::CommandRecorder
+  extend ActiveSupport::Autoload
+
+  autoload :ExtensionMethods
+  autoload :SchemaMethods
+  autoload :CommentMethods
+  autoload :ForeignerMethods
+  autoload :ViewMethods
+
+  include ExtensionMethods
+  include SchemaMethods
+  include CommentMethods
+  include ForeignerMethods
+  include ViewMethods
+end

data/lib/pg_saurus/migration.rb

@@ -0,0 +1,4 @@
+module PgSaurus::Migration  # :nodoc:
+  extend ActiveSupport::Autoload
+  autoload :CommandRecorder
+end

data/lib/pg_saurus/schema_dumper/comment_methods.rb

@@ -0,0 +1,51 @@
+# Extends ActiveRecord::SchemaDumper class to dump comments on tables and columns.
+module PgSaurus::SchemaDumper::CommentMethods
+  # Hook ActiveRecord::SchemaDumper#table method to dump comments on
+  # table and columns.
+  def tables_with_comments(stream)
+    tables_without_comments(stream)
+
+    # Dump table and column comments
+    @connection.tables.sort.each do |table_name|
+      dump_comments(table_name, stream)
+    end
+
+    # Now dump index comments
+    unless (index_comments = @connection.index_comments).empty?
+      index_comments.each do |schema_name, table_name, raw_comment|
+        index_name = schema_name == 'public' ? "'#{table_name}'" : "'#{schema_name}.#{table_name}'"
+        comment    = format_comment(raw_comment)
+        stream.puts "  set_index_comment #{index_name}, '#{comment}'"
+      end
+      stream.puts
+    end
+  end
+
+  # Find all comments related to passed table and write appropriate
+  # statements to stream.
+  def dump_comments(table_name, stream)
+    unless (comments = @connection.comments(table_name)).empty?
+      comment_statements = comments.map do |row|
+        column_name = row[0]
+        comment     = format_comment(row[1])
+
+        if column_name
+          "  set_column_comment '#{table_name}', '#{column_name}', '#{comment}'"
+        else
+          "  set_table_comment '#{table_name}', '#{comment}'"
+        end
+
+      end
+
+      stream.puts comment_statements.join("\n")
+      stream.puts
+    end
+  end
+  private :dump_comments
+
+  # Escape single quotes from comments.
+  def format_comment(comment)
+    comment.gsub(/'/, "\\\\'")
+  end
+  private :format_comment
+end

data/lib/pg_saurus/schema_dumper/extension_methods.rb

@@ -0,0 +1,29 @@
+# Extends ActiveRecord::SchemaDumper class to dump comments on tables and columns.
+module PgSaurus::SchemaDumper::ExtensionMethods
+  # Hook ActiveRecord::SchemaDumper#header method to dump extensions in all
+  # schemas except for pg_catalog.
+  def header_with_extensions(stream)
+    header_without_extensions(stream)
+    dump_extensions(stream)
+    stream
+  end
+
+# Dump current database extensions recreation commands to the given stream.
+#
+# @param [#puts] stream Stream to write to
+  def dump_extensions(stream)
+    extensions = @connection.pg_extensions
+    commands   = extensions.map do |extension_name, options|
+      result = [%Q|create_extension "#{extension_name}"|]
+      result << %Q|:schema_name => "#{options[:schema_name]}"| unless options[:schema_name] == 'public'
+      result << %Q|:version => "#{options[:version]}"|
+      result.join(', ')
+    end
+
+    commands.each do |command|
+      stream.puts("  #{command}")
+    end
+
+    stream.puts
+  end
+end

data/lib/pg_saurus/schema_dumper/foreigner_methods.rb

@@ -0,0 +1,63 @@
+# Provides methods to extend ActiveRecord::SchemaDumper to dump
+# foreign keys.
+module PgSaurus::SchemaDumper::ForeignerMethods
+  # Hooks ActiveRecord::SchemaDumper#table method to dump foreign keys.
+  def tables_with_foreign_keys(stream)
+    tables_without_foreign_keys(stream)
+
+    table_names = @connection.tables.sort
+
+    table_names.sort.each do |table|
+      next if ['schema_migrations', ignore_tables].flatten.any? do |ignored|
+        case ignored
+        when String; table == ignored
+        when Regexp; table =~ ignored
+        else
+          raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+        end
+      end
+      foreign_keys(table, stream)
+    end
+  end
+
+
+  # Find all foreign keys on passed table and writes appropriate
+  # statements to stream.
+  def foreign_keys(table_name, stream)
+    if (foreign_keys = @connection.foreign_keys(table_name)).any?
+      add_foreign_key_statements = foreign_keys.map do |foreign_key|
+        options         = foreign_key.options
+        table_from_key  = foreign_key.to_table
+        statement_parts = [ ('add_foreign_key ' + foreign_key.from_table.inspect) ]
+        statement_parts << table_from_key.inspect
+        statement_parts << (':name => ' + options[:name].inspect)
+
+        column_from_options      = options[:column]
+        primary_key_from_options = options[:primary_key]
+        dependent_from_options   = options[:dependent]
+
+        if column_from_options != "#{table_from_key.singularize}_id"
+          statement_parts << (":column => #{column_from_options.inspect}")
+        end
+        if primary_key_from_options != 'id'
+          statement_parts << (":primary_key => #{primary_key_from_options.inspect}")
+        end
+        if dependent_from_options.present?
+          statement_parts << (":dependent => #{dependent_from_options.inspect}")
+        end
+
+        # Always exclude the index
+        #  If an index was created in a migration, it will get dumped to the schema
+        #  separately from the foreign key.  This will raise an exception if
+        #  add_foreign_key is run without :exclude_index => true.
+        statement_parts << (':exclude_index => true')
+
+        '  ' + statement_parts.join(', ')
+      end
+
+      stream.puts add_foreign_key_statements.sort.join("\n")
+      stream.puts
+    end
+  end
+  private :foreign_keys
+end