Class: ActiveRecord::SchemaDumper

# File 'activerecord/lib/active_record/schema_dumper.rb', line 51

cattr_accessor :excl_ignore_pattern, default: /^excl_rails_[0-9a-f]{10}$/

# File 'activerecord/lib/active_record/schema_dumper.rb', line 39

cattr_accessor :fk_ignore_pattern, default: /^fk_rails_[0-9a-f]{10}$/

# File 'activerecord/lib/active_record/schema_dumper.rb', line 16

def self.ignore_tables
  ActiveRecord.deprecator.warn(<<~MSG)
    `ActiveRecord::SchemaDumper.ignore_tables` is deprecated and will be removed.
    Use `config.active_record.schema_ignored_tables` instead.
  MSG

  ActiveRecord.schema_ignored_tables
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 26

def self.ignore_tables=(tables)
  ActiveRecord.deprecator.warn(<<~MSG)
    `ActiveRecord::SchemaDumper.ignore_tables=` is deprecated and will be removed.
    Use `config.active_record.schema_ignored_tables` instead.
  MSG

  ActiveRecord.schema_ignored_tables = tables
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 57

cattr_accessor :unique_ignore_pattern, default: /^uniq_rails_[0-9a-f]{10}$/

# File 'activerecord/lib/active_record/schema_dumper.rb', line 68

def generate_options(config)
  {
    table_name_prefix: config.table_name_prefix,
    table_name_suffix: config.table_name_suffix
  }
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 51

cattr_accessor :excl_ignore_pattern, default: /^excl_rails_[0-9a-f]{10}$/

# File 'activerecord/lib/active_record/schema_dumper.rb', line 39

cattr_accessor :fk_ignore_pattern, default: /^fk_rails_[0-9a-f]{10}$/

# File 'activerecord/lib/active_record/schema_dumper.rb', line 89

attr_accessor :table_name

# File 'activerecord/lib/active_record/schema_dumper.rb', line 57

cattr_accessor :unique_ignore_pattern, default: /^uniq_rails_[0-9a-f]{10}$/

# File 'activerecord/lib/active_record/schema_dumper.rb', line 334

def check_constraints_in_create(table, stream)
  if (check_constraints = @check_constraints[table]).any?
    check_valid, check_invalid = check_constraints.partition { |chk| chk.validate? }

    unless check_valid.empty?
      check_constraint_statements = check_valid.map do |check|
        "    t.check_constraint #{check_parts(check).join(', ')}"
      end

      stream.puts check_constraint_statements.sort.join("\n")
    end

    unless check_invalid.empty?
      remaining = StringIO.new
      table_name = remove_prefix_and_suffix(table).inspect

      add_check_constraint_statements = check_invalid.map do |check|
        "  add_check_constraint #{([table_name] + check_parts(check)).join(', ')}"
      end

      remaining.puts add_check_constraint_statements.sort.join("\n")
      remaining
    end
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 360

def check_parts(check)
  check_parts = [ check.expression.inspect ]
  check_parts << "name: #{check.name.inspect}" if check.export_name_on_schema_dump?
  check_parts << "validate: #{check.validate?.inspect}" unless check.validate?
  check_parts
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 110

def define_arglist
  @dump_schema_migrations || @version.nil? ? "" : "(version: #{formatted_version})"
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 76

def dump(stream)
  header(stream)
  schemas(stream)
  extensions(stream)
  types(stream)
  tables(stream)
  virtual_tables(stream)
  trailer(stream)
  versions(stream) if @dump_schema_migrations
  stream
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 155

def extensions(stream)
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 367

def foreign_keys(table, stream)
  if (foreign_keys = @foreign_keys[table]).any?
    add_foreign_key_statements = foreign_keys.map do |foreign_key|
      parts = [
        relation_name(remove_prefix_and_suffix(foreign_key.from_table)).inspect,
        relation_name(remove_prefix_and_suffix(foreign_key.to_table)).inspect,
      ]

      if foreign_key.column != @connection.foreign_key_column_for(foreign_key.to_table, "id")
        parts << "column: #{foreign_key.column.inspect}"
      end

      if foreign_key.custom_primary_key?
        parts << "primary_key: #{foreign_key.primary_key.inspect}"
      end

      parts << "name: #{foreign_key.name.inspect}" if foreign_key.export_name_on_schema_dump?
      parts << "on_update: #{foreign_key.on_update.inspect}" if foreign_key.on_update
      parts << "on_delete: #{foreign_key.on_delete.inspect}" if foreign_key.on_delete
      parts << "deferrable: #{foreign_key.deferrable.inspect}" if foreign_key.deferrable
      parts << "validate: #{foreign_key.validate?.inspect}" unless foreign_key.validate?
      parts << "enforced: #{foreign_key.enforced?.inspect}" unless foreign_key.enforced?

      "  add_foreign_key #{parts.join(', ')}"
    end

    stream.puts add_foreign_key_statements.sort.join("\n")
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 397

def format_colspec(colspec)
  colspec.map do |key, value|
    "#{key}: #{ value.is_a?(Hash) ? "{ #{format_colspec(value)} }" : value }"
  end.join(", ")
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 407

def format_index_parts(options)
  if options.is_a?(Hash)
    "{ #{format_options(options)} }"
  else
    options.inspect
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 403

def format_options(options)
  options.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 104

def formatted_version
  stringified = @version.to_s
  return stringified unless stringified.length == 14
  stringified.insert(4, "_").insert(7, "_").insert(10, "_")
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 114

def header(stream)
  stream.puts <<~HEADER
    # This file is auto-generated from the current state of the database. Instead
    # of editing this file, please use the migrations feature of Active Record to
    # incrementally modify your database, and then regenerate this schema definition.
    #
    # This file is the source Rails uses to define your schema when running `bin/rails
    # db:schema:load`. When creating a new database, `bin/rails db:schema:load` tends to
    # be faster and is potentially less error prone than running all of your
    # migrations from scratch. Old migrations may fail to apply correctly if those
    # migrations use external dependencies or application code.
    #
    # It's strongly recommended that you check this file into your version control system.

    ActiveRecord::Schema[#{ActiveRecord::Migration.current_version}].define#{define_arglist} do
  HEADER
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 434

def ignored?(table_name)
  @ignore_tables.any? do |ignored|
    ignored === table_name
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 315

def index_parts(index)
  index_parts = [
    index.columns.inspect,
    "name: #{index.name.inspect}",
  ]
  index_parts << "unique: true" if index.unique
  index_parts << "length: #{format_index_parts(index.lengths)}" if index.lengths.present?
  index_parts << "order: #{format_index_parts(index.orders)}" if index.orders.present?
  index_parts << "opclass: #{format_index_parts(index.opclasses)}" if index.opclasses.present?
  index_parts << "where: #{index.where.inspect}" if index.where
  index_parts << "using: #{index.using.inspect}" if !@connection.default_index_type?(index)
  index_parts << "include: #{index.include.inspect}" if index.include
  index_parts << "nulls_not_distinct: #{index.nulls_not_distinct.inspect}" if index.nulls_not_distinct
  index_parts << "type: #{index.type.inspect}" if index.type
  index_parts << "comment: #{index.comment.inspect}" if index.comment
  index_parts << "enabled: #{index.enabled.inspect}" if @connection.supports_disabling_indexes? && index.disabled?
  index_parts
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 282

def indexes(table, stream)
  if (indexes = @connection.indexes(table)).any?
    add_index_statements = indexes.map do |index|
      table_name = remove_prefix_and_suffix(index.table)
      "  add_index #{([relation_name(table_name).inspect] + index_parts(index)).join(', ')}"
    end

    stream.puts add_index_statements.sort.join("\n")
    stream.puts
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 294

def indexes_in_create(table, stream)
  if (indexes = @indexes[table]).any?
    if @connection.supports_exclusion_constraints? && (exclusion_constraints = @exclusion_constraints[table]).any?
      exclusion_constraint_names = exclusion_constraints.collect(&:name)

      indexes = indexes.reject { |index| exclusion_constraint_names.include?(index.name) }
    end

    if @connection.supports_unique_constraints? && (unique_constraints = @unique_constraints[table]).any?
      unique_constraint_names = unique_constraints.collect(&:name)

      indexes = indexes.reject { |index| unique_constraint_names.include?(index.name) }
    end

    index_statements = indexes.map do |index|
      "    t.index #{index_parts(index).join(', ')}"
    end
    stream.puts index_statements.sort.join("\n")
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 170

def read_schema_metadata(tables)
  @columns = @connection.columns(tables)
  @table_options = @connection.table_options(tables)
  @primary_keys = @connection.primary_keys(tables)
  @indexes = @connection.indexes(tables)
  @foreign_keys = @connection.foreign_keys(tables) if @connection.supports_foreign_keys?
  @check_constraints = @connection.check_constraints(tables) if @connection.supports_check_constraints?
  @exclusion_constraints = @connection.exclusion_constraints(tables) if @connection.supports_exclusion_constraints?
  @unique_constraints = @connection.unique_constraints(tables) if @connection.supports_unique_constraints?
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 415

def relation_name(name)
  name
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 419

def remove_prefix_and_suffix(table)
  # This method appears at the top when profiling active_record test cases run.
  # Avoid costly calculation when there are no prefix and suffix.
  return table if @options[:table_name_prefix].blank? && @options[:table_name_suffix].blank?

  prefix = Regexp.escape(@options[:table_name_prefix].to_s)
  suffix = Regexp.escape(@options[:table_name_suffix].to_s)
  table.sub(/\A#{prefix}(.+)#{suffix}\z/, "\\1")
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 163

def schemas(stream)
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 207

def table(table, stream)
  columns = @columns[table]
  begin
    self.table_name = table

    tbl = StringIO.new

    # first dump primary key column
    pk = @primary_keys[table]
    pk = pk.first unless pk.size > 1

    tbl.print "  create_table #{relation_name(remove_prefix_and_suffix(table)).inspect}"

    case pk
    when String
      tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
      pkcol = columns.detect { |c| c.name == pk }
      pkcolspec = column_spec_for_primary_key(pkcol)
      unless pkcolspec.empty?
        if pkcolspec != pkcolspec.slice(:id, :default)
          pkcolspec = { id: { type: pkcolspec.delete(:id), **pkcolspec }.compact }
        end
        tbl.print ", #{format_colspec(pkcolspec)}"
      end
    when Array
      tbl.print ", primary_key: #{pk.inspect}"
    else
      tbl.print ", id: false"
    end

    table_options = @table_options[table]
    if table_options.present?
      tbl.print ", #{format_options(table_options)}"
    end

    tbl.puts ", force: :cascade do |t|"

    # then dump all non-primary key columns
    columns.each do |column|
      raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
      next if column.name == pk

      type, colspec = column_spec(column)
      if type.is_a?(Symbol)
        tbl.print "    t.#{type} #{column.name.inspect}"
      else
        tbl.print "    t.column #{column.name.inspect}, #{type.inspect}"
      end
      tbl.print ", #{format_colspec(colspec)}" if colspec.present?
      tbl.puts
    end

    indexes_in_create(table, tbl)
    remaining = check_constraints_in_create(table, tbl) if @connection.supports_check_constraints?
    exclusion_constraints_in_create(table, tbl) if @connection.supports_exclusion_constraints?
    unique_constraints_in_create(table, tbl) if @connection.supports_unique_constraints?

    tbl.puts "  end"

    if remaining
      tbl.puts
      tbl.print remaining.string
    end

    stream.print tbl.string
  rescue => e
    stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
    stream.puts "#   #{e.message}"
    stream.puts
  ensure
    self.table_name = nil
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 181

def tables(stream)
  sorted_tables = @connection.tables.sort

  not_ignored_tables = sorted_tables.reject { |table_name| ignored?(table_name) }

  read_schema_metadata(not_ignored_tables)

  not_ignored_tables.each_with_index do |table_name, index|
    table(table_name, stream)
    stream.puts if index < not_ignored_tables.count - 1
  end

  # dump foreign keys at the end to make sure all dependent tables exist.
  if @connection.supports_foreign_keys?
    foreign_keys_stream = StringIO.new
    not_ignored_tables.each do |tbl|
      foreign_keys(tbl, foreign_keys_stream)
    end

    foreign_keys_string = foreign_keys_stream.string
    stream.puts if foreign_keys_string.length > 0

    stream.print foreign_keys_string
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 132

def trailer(stream)
  stream.puts "end"
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 159

def types(stream)
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 136

def versions(stream)
  pool = @connection.pool

  versions_in_schema_migrations = pool.migration_context.get_all_versions
  versions_in_db_migrate = pool.migration_context.migrations.map(&:version)
  versions_to_dump = versions_in_schema_migrations & versions_in_db_migrate

  if versions_to_dump.any?
    versions_to_dump.map!(&:to_s)
    versions_to_dump.sort_by!(&ActiveRecord.dump_schema_migrations_sort_by)

    stream.puts
    stream.puts "ActiveRecord::Schema.load_schema_migrations(__FILE__)"
    stream.puts "__END__"
    stream.puts versions_to_dump
  end
end

# File 'activerecord/lib/active_record/schema_dumper.rb', line 167

def virtual_tables(stream)
end