Class: FastSchemaDumper::SchemaDumper

Inherits:

Object

• Object
• FastSchemaDumper::SchemaDumper

Defined in:

lib/fast_schema_dumper/fast_dumper.rb

Class Method Summary

• .dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base) ⇒ Object

Instance Method Summary

• #dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base) ⇒ Object

Class Method Details

.dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base) ⇒ Object

# File 'lib/fast_schema_dumper/fast_dumper.rb', line 7

def dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base)
  new.dump(pool, stream, config)
end

Instance Method Details

#dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base) ⇒ Object

# File 'lib/fast_schema_dumper/fast_dumper.rb', line 12

def dump(pool = ActiveRecord::Base.connection_pool, stream = $stdout, config = ActiveRecord::Base)
  conn = ActiveRecord::Base.connection

  @output = []

  # Get all tables (excluding ar_internal_metadata and schema_migrations)
  tables = conn.exec_query("
    SELECT TABLE_NAME
    FROM INFORMATION_SCHEMA.TABLES
    WHERE TABLE_SCHEMA = DATABASE()
      AND TABLE_TYPE = 'BASE TABLE'
      AND TABLE_NAME NOT IN ('ar_internal_metadata', 'schema_migrations')
    ORDER BY TABLE_NAME
  ").map { |row| row['TABLE_NAME'] }

  # Get all columns
  columns_data = conn.exec_query("
  select
      TABLE_NAME
      , COLUMN_NAME
      , ORDINAL_POSITION
      , COLUMN_DEFAULT
      , IS_NULLABLE
      , DATA_TYPE
      , CHARACTER_MAXIMUM_LENGTH
      , NUMERIC_PRECISION
      , NUMERIC_SCALE
      , COLUMN_TYPE
      , EXTRA
      , GENERATION_EXPRESSION
      , COLUMN_COMMENT
      , DATETIME_PRECISION
      , COLLATION_NAME
  from INFORMATION_SCHEMA.COLUMNS
  where
      TABLE_SCHEMA = database()
  order by TABLE_NAME, ORDINAL_POSITION
")

  # Get all indexes
  indexes_data = conn.exec_query("
  SELECT
    s.TABLE_NAME,
    s.INDEX_NAME,
    s.NON_UNIQUE,
    s.COLUMN_NAME,
    s.SEQ_IN_INDEX,
    s.INDEX_COMMENT,
    s.COLLATION
  FROM INFORMATION_SCHEMA.STATISTICS s
  WHERE s.TABLE_SCHEMA = DATABASE()
  ORDER BY s.TABLE_NAME, s.INDEX_NAME, s.SEQ_IN_INDEX
")

  # Aggregate table information
  # Organize indexes by table
  indexes_by_table = indexes_data.each_with_object({}) do |idx, hash|
    hash[idx['TABLE_NAME']] ||= {}
    hash[idx['TABLE_NAME']][idx['INDEX_NAME']] ||= {
      columns: [],
      unique: idx['NON_UNIQUE'] == 0,
      # length
      orders: {},
      # opclass
      # where
      # using
      # include
      # nulls_not_distinct
      # type
      comment: idx['INDEX_COMMENT']
      # enabled
    }
    hash[idx['TABLE_NAME']][idx['INDEX_NAME']][:columns] << idx['COLUMN_NAME']
    # Track descending order columns (COLLATION = 'D')
    if idx['COLLATION'] == 'D'
      hash[idx['TABLE_NAME']][idx['INDEX_NAME']][:orders][idx['COLUMN_NAME']] = :desc
    end
  end

  # Get table options
  table_options = conn.exec_query("
  SELECT
    TABLE_NAME,
    TABLE_COLLATION,
    TABLE_COMMENT
  FROM INFORMATION_SCHEMA.TABLES
  WHERE TABLE_SCHEMA = DATABASE()
    AND TABLE_TYPE = 'BASE TABLE'
").each_with_object({}) do |row, hash|
    hash[row['TABLE_NAME']] = {
      collation: row['TABLE_COLLATION'],
      comment: row['TABLE_COMMENT']
    }
  end

  # Get foreign keys
  foreign_keys_data = conn.exec_query("
  SELECT
    kcu.TABLE_NAME,
    kcu.CONSTRAINT_NAME,
    kcu.COLUMN_NAME,
    kcu.REFERENCED_TABLE_NAME,
    kcu.REFERENCED_COLUMN_NAME,
    rc.DELETE_RULE,
    rc.UPDATE_RULE
  FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
  JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
    ON kcu.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
    AND kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
  WHERE kcu.TABLE_SCHEMA = DATABASE()
    AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
  ORDER BY kcu.TABLE_NAME, kcu.CONSTRAINT_NAME
")

  # Get CHECK constraints (MySQL 8.0.16+)
  result = conn.exec_query("
  SELECT COUNT(*) as count
  FROM INFORMATION_SCHEMA.TABLES
  WHERE TABLE_SCHEMA = 'information_schema'
    AND TABLE_NAME = 'CHECK_CONSTRAINTS'
")
  check_constraints_data = if result.first['count'] > 0
    conn.exec_query("
    SELECT
      tc.CONSTRAINT_NAME,
      tc.TABLE_NAME,
      cc.CHECK_CLAUSE
    FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
    JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc
      ON tc.CONSTRAINT_SCHEMA = cc.CONSTRAINT_SCHEMA
      AND tc.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
    WHERE tc.TABLE_SCHEMA = DATABASE()
      AND tc.CONSTRAINT_TYPE = 'CHECK'
    ORDER BY tc.TABLE_NAME, tc.CONSTRAINT_NAME
  ")
  else
    []
  end

  check_constraints_by_table = check_constraints_data.each_with_object({}) do |ck, hash|
    hash[ck['TABLE_NAME']] ||= []
    hash[ck['TABLE_NAME']] << {
      constraint_name: ck['CONSTRAINT_NAME'],
      check_clause: ck['CHECK_CLAUSE']
    }
  end

  # Organize columns by table
  columns_by_table = columns_data.each_with_object({}) do |col, hash|
    hash[col['TABLE_NAME']] ||= []
    hash[col['TABLE_NAME']] << col
  end

  # Generate schema for each table
  tables.each do |table_name|
    dump_table(
      table_name,
      columns: columns_by_table[table_name] || [],
      indexes: indexes_by_table[table_name] || {},
      check_constraints: check_constraints_by_table[table_name] || {},
      options: table_options[table_name]
    )
    @output << ""
  end

  # Remove trailing empty line
  @output.pop if @output.last == ""

  @output << ""

  # Foreign keys
  # ordered by table_name and constraint_name

  foreign_keys_by_table = foreign_keys_data.each_with_object({}) do |fk, hash|
    hash[fk['TABLE_NAME']] ||= {}
    hash[fk['TABLE_NAME']][fk['CONSTRAINT_NAME']] ||= {
      column: fk['COLUMN_NAME'],
      referenced_table: fk['REFERENCED_TABLE_NAME'],
      referenced_column: fk['REFERENCED_COLUMN_NAME'],
      constraint_name: fk['CONSTRAINT_NAME']
    }
  end

  all_foreign_keys = []
  foreign_keys_by_table.each do |table_name, foreign_keys|
    foreign_keys.each do |constraint_name, fk_data|
      all_foreign_keys << {
        table_name: table_name,
        constraint_name: constraint_name,
        fk_data: fk_data
      }
    end
  end

  # Sort by table_name first, then by referenced_table name, then by column name
  all_foreign_keys.sort_by { |fk| [fk[:table_name], fk[:fk_data][:referenced_table], fk[:fk_data][:column]] }.each do |fk|
    fk_line = "add_foreign_key \"#{fk[:table_name]}\", \"#{fk[:fk_data][:referenced_table]}\""

    # Determine if we need column: or name: option
    # Rails tries to infer the column name from the table name
    # For simple cases: "users" -> "user_id"
    # But it also handles more complex cases

    inferred_column = "#{singularize(fk[:fk_data][:referenced_table])}_id"

    # Check if column name matches what Rails would infer
    if fk[:fk_data][:column] != inferred_column
      # Column name is custom, need to specify it
      fk_line += ", column: \"#{fk[:fk_data][:column]}\""
    elsif !fk[:fk_data][:constraint_name].start_with?("fk_rails_")
      # Column matches default, check if constraint name is custom
      # Rails generates constraint names starting with "fk_rails_"
      fk_line += ", name: \"#{fk[:fk_data][:constraint_name]}\""
    end

    @output << fk_line
  end

  stream.print @output.join("\n")
end