pg_saurus 2.6.0 → 3.0.0

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

@@ -1,221 +0,0 @@
-module PgSaurus # :nodoc:
-  # Provides methods to extend {ActiveRecord::ConnectionAdapters::PostgreSQLAdapter}
-  # to support foreign keys feature.
-  module ConnectionAdapters::PostgreSQLAdapter::ForeignerMethods
-    def supports_foreign_keys?
-      true
-    end
-
-    # Fetch information about foreign keys related to the 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
-
-        PgSaurus::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row['to_table'], options)
-      end
-    end
-
-    # Drop table and optionally disable triggers.
-    # 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 just to 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
-
-    # Add foreign key.
-    #
-    # Ensures that an index is created for the foreign key, unless :exclude_index is true.
-    #
-    # == 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 [PgSaurus::IndexExistsError] when :exclude_index is true, but the index already exists
-    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]) && !options[:exclude_index]
-        raise PgSaurus::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)
-
-      # GOTCHA:
-      #   Index can not be created concurrently inside transaction in PostgreSQL.
-      #   So, in case of concurrently created index with foreign key only
-      #   foreign key will be created inside migration transaction and after
-      #   closing transaction queries for index creation will be send to database.
-      #   That's why I prevent here normal index creation in case of
-      #   `concurrent_index` option is given.
-      #   NOTE: Index creation after closing migration transaction could lead
-      #   to weird effects when transaction moves smoothly, but index
-      #   creation with error. In that case transaction will not be rolled back.
-      #   As it was closed before even index was attempted to create.
-      #   -- zekefast 2012-09-12
-      unless options[:exclude_index] || options[:concurrent_index]
-        add_index(from_table, options[:column])
-      end
-    end
-
-    # Return the SQL code fragment to add the foreign key based on the table names and options.
-    def add_foreign_key_sql(from_table, to_table, options = {})
-      column           = options[:column]
-      options_options  = options[:options]
-      foreign_key_name = foreign_key_name(from_table, 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(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={})
-    #
-    # Remove the 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
-      unless options[:exclude_index] || !index_exists?(from_table, column) then
-        remove_index(from_table, column)
-      end
-    end
-
-    # Return the SQL code fragment 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
-
-    # Build 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
-
-    # Extract 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
-
-    # Build default name for constraint.
-    def foreign_key_name(table, column, options = {})
-      name = options[:name]
-
-      if !name.nil? then
-        name
-      else
-        prefix = table.gsub(".", "_")
-        "#{prefix}_#{column}_fk"
-      end
-    end
-    private :foreign_key_name
-
-    # Get the SQL code fragment that represents dependency for a constraint.
-    #
-    # @param dependency [Symbol] :nullify, :delete or :restrict
-    #
-    # @return [String]
-    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

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

@@ -1,51 +0,0 @@
-# Provides methods to extend ActiveRecord::ConnectionAdapters::Table
-# to support foreign keys feature.
-module PgSaurus::ConnectionAdapters::Table::ForeignerMethods
-  # Adds a new foreign key to the table. +to_table+ can be a single Symbol, or
-  # an Array of Symbols. See SchemaStatements#add_foreign_key
-  #
-  # ===== Examples
-  # ====== Creating a simple foreign key
-  # t.foreign_key(:people)
-  # ====== Defining the column
-  # t.foreign_key(:people, :column => :sender_id)
-  # ====== Creating a named foreign key
-  # t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
-  # ====== Defining the column of the +to_table+.
-  # t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
-  def foreign_key(to_table, options = {})
-    @base.add_foreign_key(@table_name, to_table, options)
-  end
-
-  # Remove the given foreign key from the table.
-  #
-  # ===== Examples
-  # ====== Remove the suppliers_company_id_fk in the suppliers table.
-  # change_table :suppliers do |t|
-  # t.remove_foreign_key :companies
-  # end
-  # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
-  # change_table :accounts do |t|
-  # t.remove_foreign_key :column => :branch_id
-  # end
-  # ====== Remove the foreign key named party_foreign_key in the accounts table.
-  # change_table :accounts do |t|
-  # t.remove_index :name => :party_foreign_key
-  # end
-  def remove_foreign_key(options)
-    @base.remove_foreign_key(@table_name, options)
-  end
-
-  # Deprecated
-  def references_with_foreign_keys(*args)
-    options = args.extract_options!
-
-    if options.delete(:foreign_key)
-      p ActiveSupport::Deprecation.send(:deprecation_message, caller,
-        ":foreign_key in t.references is deprecated. " \
-        "Use t.foreign_key instead")
-    end
-
-    references_without_foreign_keys(*(args.dup << options))
-  end
-end

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

@@ -1,31 +0,0 @@
-# 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/schema_dumper/foreigner_methods.rb

@@ -1,63 +0,0 @@
-# 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