convergence 1.0.6 → 1.1.0

data/lib/convergence/dumper/sqlite_schema_dumper.rb

@@ -0,0 +1,132 @@
+require 'convergence/dumper'
+require 'convergence/table'
+
+class Convergence::Dumper::SqliteSchemaDumper
+  DEFAULT_VALUE_PATTERN = /\A'(?<value>(?:[^']|'')*)'\z/.freeze
+  # SQLite has no CONSTRAINT-name introspection pragma; the name is only
+  # preserved in the original CREATE TABLE text.
+  FOREIGN_KEY_NAME_PATTERN = /CONSTRAINT\s+"?(?<name>\w+)"?\s+FOREIGN KEY\s*\(\s*"?(?<column>\w+)"?\s*\)/i.freeze
+
+  def initialize(connector)
+    @connector = connector
+    @tables = {}
+  end
+
+  def dump
+    table_names.each do |table_name|
+      table = Convergence::Table.new(table_name)
+      parse_columns(table, column_definitions(table_name))
+      parse_indexes(table, index_definitions(table_name))
+      parse_foreign_keys(table, table_name)
+      @tables[table_name] = table
+    end
+    @tables
+  end
+
+  private
+
+  def db
+    @connector.schema_client
+  end
+
+  def table_names
+    db.execute("SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'").map { |r| r['name'] }
+  end
+
+  def table_sql(table_name)
+    row = db.execute('SELECT sql FROM sqlite_master WHERE type = ? AND name = ?', ['table', table_name]).first
+    row ? row['sql'].to_s : ''
+  end
+
+  def column_definitions(table_name)
+    db.execute(%(PRAGMA table_info("#{table_name}")))
+  end
+
+  def index_definitions(table_name)
+    # origin 'c' is an explicitly created index (CREATE [UNIQUE] INDEX). 'pk' and
+    # 'u' are auto-generated by a PRIMARY KEY/UNIQUE column constraint, already
+    # represented on the column itself, so they are excluded here.
+    db.execute(%(PRAGMA index_list("#{table_name}"))).select { |r| r['origin'] == 'c' }
+  end
+
+  def index_column_definitions(index_name)
+    db.execute(%(PRAGMA index_info("#{index_name}")))
+  end
+
+  def foreign_key_definitions(table_name)
+    db.execute(%(PRAGMA foreign_key_list("#{table_name}")))
+  end
+
+  def parse_columns(table, columns)
+    pk_columns = columns.select { |c| c['pk'].to_i > 0 }
+    single_integer_pk_cid = pk_columns.size == 1 ? pk_columns.first['cid'] : nil
+    columns.each do |column|
+      data_type, column_name, options = parse_column(column, single_integer_pk_cid)
+      table.send(data_type, column_name, options)
+    end
+  end
+
+  def parse_column(column, single_integer_pk_cid)
+    raw_type = column['type'].to_s
+    type_name = raw_type[/\A(\w+)/, 1].to_s
+    column_name = column['name']
+    is_auto_increment_pk = !single_integer_pk_cid.nil? && column['cid'] == single_integer_pk_cid && type_name.upcase == 'INTEGER'
+    data_type = if is_auto_increment_pk
+                  :int
+                elsif type_name.empty?
+                  :text
+                else
+                  type_name.downcase.to_sym
+                end
+    options = { null: column['notnull'].to_i.zero? }
+    if is_auto_increment_pk
+      # SQLite's `notnull` pragma column doesn't reflect the implicit NOT NULL
+      # of an INTEGER PRIMARY KEY (rowid alias), so it must be forced here.
+      options.merge!(primary_key: true, extra: 'auto_increment', null: false)
+    else
+      options.merge!(primary_key: true) if column['pk'].to_i > 0
+      options.merge!(default: column_default_expression(data_type, column['dflt_value'])) unless column['dflt_value'].nil?
+    end
+    case data_type
+    when :decimal
+      precision, scale = raw_type.scan(/\d+/)
+      options.merge!(precision: precision, scale: scale) if precision
+    else
+      limit = raw_type[/\((\d+)\)/, 1]
+      options.merge!(limit: limit) unless limit.nil?
+    end
+    [data_type, column_name, options]
+  end
+
+  def column_default_expression(data_type, value)
+    return -> { 'CURRENT_TIMESTAMP' } if data_type == :datetime && value.to_s.upcase == 'CURRENT_TIMESTAMP'
+    match = DEFAULT_VALUE_PATTERN.match(value)
+    return match[:value].gsub("''", "'") if match
+    value
+  end
+
+  def parse_indexes(table, indexes)
+    indexes.each do |index|
+      columns = index_column_definitions(index['name']).sort_by { |c| c['seqno'].to_i }.map { |c| c['name'] }
+      options = { name: index['name'], unique: index['unique'].to_i == 1 }
+      table.index(columns, options)
+    end
+  end
+
+  def parse_foreign_keys(table, table_name)
+    foreign_key_names = table_sql(table_name).scan(FOREIGN_KEY_NAME_PATTERN).to_h { |name, column| [column, name] }
+    foreign_key_definitions(table_name).group_by { |r| r['id'] }.each do |_id, rows|
+      sorted_rows = rows.sort_by { |r| r['seq'].to_i }
+      columns = sorted_rows.map { |r| r['from'] }
+      to_table = sorted_rows.first['table']
+      to_columns = sorted_rows.map { |r| r['to'] }
+      key_name = foreign_key_names[columns.first] || "fk_#{table.table_name}_#{columns.join('_')}"
+      options = {
+        reference: to_table,
+        reference_column: to_columns,
+        name: key_name
+      }
+      table.foreign_key(columns, options)
+    end
+  end
+end

data/lib/convergence/dumper.rb

@@ -1,4 +1,39 @@
 class Convergence::Dumper
+  # Convergence's DSL type names follow MySQL terminology; map them to the
+  # closest ActiveRecord migration column type.
+  RAILS_TYPE_MAPPING = {
+    tinyint: :integer,
+    smallint: :integer,
+    mediumint: :integer,
+    int: :integer,
+    bigint: :bigint,
+    float: :float,
+    double: :float,
+    decimal: :decimal,
+    char: :string,
+    varchar: :string,
+    tinyblob: :binary,
+    blob: :binary,
+    mediumblob: :binary,
+    longblob: :binary,
+    tinytext: :text,
+    text: :text,
+    mediumtext: :text,
+    longtext: :text,
+    date: :date,
+    time: :time,
+    datetime: :datetime,
+    timestamp: :datetime,
+    year: :integer,
+    json: :json,
+    # ActiveRecord has no native enum/set column type; fall back to string.
+    enum: :string,
+    set: :string
+  }.freeze
+  # Options that only make sense for convergence's own SQL generators, with no
+  # equivalent in an ActiveRecord migration's create_table DSL.
+  RAILS_UNSUPPORTED_COLUMN_OPTIONS = %i[character_set collate extra after values].freeze
+
   def dump_dsl(tables)
     tables.map do |_, table|
       dump_table_dsl(table)
@@ -24,8 +59,84 @@ class Convergence::Dumper
     dsl
   end
 
+  def dump_rails_migration(tables, class_name, rails_version: '7.0')
+    dsl = "class #{class_name} < ActiveRecord::Migration[#{rails_version}]\n"
+    dsl += "  def change\n"
+    dsl += tables.map { |_, table| dump_table_rails_migration(table) }.join("\n\n")
+    dsl += "\n  end\n"
+    dsl += 'end'
+    dsl
+  end
+
+  def dump_table_rails_migration(table)
+    table_argument = [table.table_name.to_sym.inspect]
+    dsl = "    create_table #{table_argument.join(', ')} do |t|\n"
+    body_lines = rails_column_lines(table.columns)
+    body_lines += table.indexes.map { |_, index| dump_rails_index(index) }
+    body_lines += table.foreign_keys.map { |_, key| dump_rails_foreign_key(key) }
+    dsl += body_lines.map { |line| "      #{line}" }.join("\n")
+    dsl += "\n    end"
+    dsl
+  end
+
   private
 
+  # ActiveRecord's create_table implicitly adds an auto-incrementing `id`
+  # primary key, so an explicit column matching that shape is redundant.
+  def default_primary_key_column?(column_name, column)
+    column_name == 'id' &&
+      [:int, :bigint].include?(column.type) &&
+      column.options[:primary_key] &&
+      column.options[:extra].to_s.upcase.include?('AUTO_INCREMENT')
+  end
+
+  def rails_timestamp_column?(column)
+    column.type == :datetime && Convergence::Dumper::RAILS_UNSUPPORTED_COLUMN_OPTIONS.none? { |k| column.options.key?(k) }
+  end
+
+  def rails_column_lines(columns)
+    columns = columns.reject { |name, column| default_primary_key_column?(name, column) }
+    if %w[created_at updated_at].all? { |name| columns.key?(name) && rails_timestamp_column?(columns[name]) } &&
+       columns['created_at'].options[:null] == columns['updated_at'].options[:null]
+      remaining = columns.reject { |name, _| %w[created_at updated_at].include?(name) }
+      lines = remaining.map { |_, column| dump_rails_column(column) }
+      lines << (columns['created_at'].options[:null] ? 't.timestamps' : 't.timestamps null: false')
+      lines
+    else
+      columns.map { |_, column| dump_rails_column(column) }
+    end
+  end
+
+  def dump_rails_column(column)
+    argument = [column.column_name.to_sym.inspect]
+    options = column.options.reject { |k, _v| RAILS_UNSUPPORTED_COLUMN_OPTIONS.include?(k) }
+    if column.type == :tinyint && column.options[:limit].to_s == '1'
+      column_type = :boolean
+      options = options.reject { |k, _v| k == :limit }
+      options = options.merge(default: false) if options[:default].to_s == '0'
+      options = options.merge(default: true) if options[:default].to_s == '1'
+    else
+      column_type = RAILS_TYPE_MAPPING[column.type] || column.type
+    end
+    argument << options.map { |k, v| key_value_text(k, v) }
+    "t.#{column_type} #{argument.flatten.join(', ')}"
+  end
+
+  def dump_rails_index(index)
+    argument = [single_or_multiple_symbol(index.index_columns)]
+    options = index.options.select { |k, _v| %i[name unique].include?(k) }
+    argument << options.map { |k, v| key_value_text(k, v) }
+    "t.index #{argument.flatten.join(', ')}"
+  end
+
+  def dump_rails_foreign_key(foreign_key)
+    argument = [foreign_key.to_table.to_sym.inspect]
+    argument << "column: #{single_or_multiple_symbol(foreign_key.from_columns)}"
+    argument << "primary_key: #{single_or_multiple_symbol(foreign_key.to_columns)}" unless foreign_key.to_columns == ['id']
+    argument << key_value_text('name', foreign_key.key_name)
+    "t.foreign_key #{argument.join(', ')}"
+  end
+
   def dump_column(column)
     argument = [column.column_name.to_sym.inspect]
     case [column.type, column.options[:limit]]
@@ -72,6 +183,8 @@ class Convergence::Dumper
   def key_value_text(k, v)
     value = if v.to_s == 'true' || v.to_s == 'false' || v.to_s =~ /^\d+$/
               v
+            elsif v.is_a?(Proc)
+              %(-> { #{v.call.inspect} })
             else
               %(#{v.inspect})
             end

data/lib/convergence/sql_generator/mysql_generator.rb

@@ -13,11 +13,11 @@ class SQLGenerator::MysqlGenerator < SQLGenerator
 
   attr_reader :original_table
 
-  def generate(to_table, delta, original_table)
+  def generate(to_table, delta, original_table, safe_migration: false)
     @original_table = original_table
     sqls = []
     sqls << change_table_sql(to_table, delta)
-    sqls << drop_table_sqls(delta)
+    sqls << (safe_migration ? [] : drop_table_sqls(delta))
     sqls << create_table_sqls(delta)
     sqls.reject!(&:empty?)
     sqls.join("\n")
@@ -166,6 +166,9 @@ DROP TABLE `#{table_name}`;
   def create_column_sql(column, output_primary_key: false, output_auto_increment: true)
     sql = "`#{column.column_name}`"
     sql += " #{column.type}"
+    if [:enum, :set].include?(column.type)
+      sql += "(#{quote_enum_or_set_values(column.options[:values])})"
+    end
     sql += "(#{column.options[:limit]})" unless column.options[:limit].nil?
     if column.options[:precision] && column.options[:scale]
       sql += "(#{column.options[:precision]}, #{column.options[:scale]})"
@@ -188,7 +191,7 @@ DROP TABLE `#{table_name}`;
       sql += ' PRIMARY KEY'
     end
     if column.options[:default]
-      sql += " DEFAULT '#{column.options[:default]}'"
+      sql += " DEFAULT #{quote_default_expression(column.options[:default])}"
     end
     if column.options[:comment]
       sql += " COMMENT '#{column.options[:comment]}'"
@@ -244,4 +247,16 @@ DROP TABLE `#{table_name}`;
       end
     end.join(' ')
   end
+
+  def quote_enum_or_set_values(values)
+    Array(values).map { |v| "'#{v.to_s.gsub("'", "''")}'" }.join(',')
+  end
+
+  def quote_default_expression(value)
+    if value.is_a?(Proc)
+      value.call
+    else
+      %('#{value}')
+    end
+  end
 end

data/lib/convergence/sql_generator/postgres_generator.rb

@@ -0,0 +1,256 @@
+require 'convergence/sql_generator'
+
+class SQLGenerator::PostgresGenerator < SQLGenerator
+  # Convergence's DSL type names follow MySQL terminology (kept for cross-adapter DSL
+  # compatibility). Map them to their closest native PostgreSQL type.
+  TYPE_MAPPING = {
+    tinyint: 'smallint',
+    smallint: 'smallint',
+    mediumint: 'integer',
+    int: 'integer',
+    bigint: 'bigint',
+    float: 'real',
+    double: 'double precision',
+    decimal: 'decimal',
+    char: 'char',
+    varchar: 'varchar',
+    tinyblob: 'bytea',
+    blob: 'bytea',
+    mediumblob: 'bytea',
+    longblob: 'bytea',
+    tinytext: 'text',
+    text: 'text',
+    mediumtext: 'text',
+    longtext: 'text',
+    date: 'date',
+    time: 'time',
+    datetime: 'timestamp',
+    timestamp: 'timestamp',
+    year: 'integer',
+    json: 'jsonb'
+  }.freeze
+  TYPES_WITH_LIMIT = [:char, :varchar].freeze
+  UNSUPPORTED_TYPES = [:enum, :set].freeze
+
+  attr_reader :original_table
+
+  def generate(to_table, delta, original_table, safe_migration: false)
+    @original_table = original_table
+    sqls = []
+    sqls << change_table_sql(to_table, delta)
+    sqls << (safe_migration ? [] : drop_table_sqls(delta))
+    sqls << create_table_sqls(delta)
+    sqls.reject!(&:empty?)
+    sqls.join("\n")
+  end
+
+  private
+
+  # FIXME: multiple pk change not supported yet
+  def change_table_sql(to_table, delta)
+    change_table = delta[:change_table]
+    results = []
+    change_table.each do |table_name, table_delta|
+      unless table_delta[:remove_foreign_key].empty?
+        results << alter_remove_foreign_keys_sql(table_name, table_delta[:remove_foreign_key].keys)
+      end
+      table_delta[:remove_index].each do |index_name, _index|
+        results << alter_remove_index_sql(index_name)
+      end
+      unless table_delta[:remove_column].empty?
+        results << alter_remove_columns_sql(table_name, table_delta[:remove_column].values)
+      end
+      unless table_delta[:add_column].empty?
+        results << alter_add_columns_sql(table_name, table_delta[:add_column].values)
+      end
+      table_delta[:change_column].each do |column_name, column|
+        results << alter_change_column_sql(table_name, column_name, column, to_table)
+      end
+      table_delta[:add_index].each do |_index_name, index|
+        results << alter_add_index_sql(table_name, index)
+      end
+      unless table_delta[:add_foreign_key].empty?
+        results << alter_add_foreign_keys_sql(table_name, table_delta[:add_foreign_key].values)
+      end
+      unless table_delta[:change_table_option].empty?
+        results << alter_change_table_sql(table_name, table_delta[:change_table_option])
+      end
+    end
+    results << '' unless results.empty?
+    results
+  end
+
+  def alter_add_columns_sql(table_name, columns)
+    add_column_sqls = columns.map { |column| %(ALTER TABLE "#{table_name}" ADD COLUMN #{create_column_sql(column, output_primary_key: true)};) }
+    comment_sqls = columns.map { |column| comment_on_column_sql(table_name, column) }.compact
+    (add_column_sqls + comment_sqls).join("\n")
+  end
+
+  def alter_remove_columns_sql(table_name, columns)
+    columns.map { |column| %(ALTER TABLE "#{table_name}" DROP COLUMN "#{column.column_name}";) }.join("\n")
+  end
+
+  def alter_change_column_sql(table_name, column_name, change_column_option, to_table)
+    column = to_table[table_name].columns[column_name]
+    column.options.merge!(after: change_column_option[:after]) unless change_column_option[:after].nil?
+    sqls = []
+    sqls << %(ALTER TABLE "#{table_name}" ALTER COLUMN "#{column_name}" TYPE #{postgres_column_type(column)} USING "#{column_name}"::#{postgres_column_type(column)};)
+    if column.options[:null]
+      sqls << %(ALTER TABLE "#{table_name}" ALTER COLUMN "#{column_name}" DROP NOT NULL;)
+    else
+      sqls << %(ALTER TABLE "#{table_name}" ALTER COLUMN "#{column_name}" SET NOT NULL;)
+    end
+    if column.options[:default]
+      sqls << %(ALTER TABLE "#{table_name}" ALTER COLUMN "#{column_name}" SET DEFAULT #{quote_default_expression(column.options[:default])};)
+    else
+      sqls << %(ALTER TABLE "#{table_name}" ALTER COLUMN "#{column_name}" DROP DEFAULT;)
+    end
+    comment_sql = comment_on_column_sql(table_name, column)
+    sqls << comment_sql unless comment_sql.nil?
+    sqls.join("\n")
+  end
+
+  def alter_change_table_sql(table_name, change_table_option)
+    return '' unless change_table_option.key?(:comment)
+    %(COMMENT ON TABLE "#{table_name}" IS '#{escape_quote(change_table_option[:comment])}';)
+  end
+
+  def alter_remove_index_sql(index_name)
+    %(DROP INDEX "#{index_name}";)
+  end
+
+  def alter_add_index_sql(table_name, index)
+    sql = 'CREATE'
+    sql += ' UNIQUE' if index.options[:unique]
+    sql += %( INDEX "#{index.index_name}" ON "#{table_name}" (#{quoted_index_columns(index).join(',')});)
+    sql
+  end
+
+  def alter_remove_foreign_keys_sql(table_name, index_names)
+    index_names.map { |index_name| %(ALTER TABLE "#{table_name}" DROP CONSTRAINT "#{index_name}";) }.join("\n")
+  end
+
+  def alter_add_foreign_keys_sql(table_name, foreign_keys)
+    foreign_keys.map { |foreign_key| %(ALTER TABLE "#{table_name}" ADD #{foreign_key_constraint_sql(foreign_key)};) }.join("\n")
+  end
+
+  def foreign_key_constraint_sql(foreign_key)
+    sql = %(CONSTRAINT "#{foreign_key.key_name}" FOREIGN KEY )
+    sql += "(#{[foreign_key.from_columns].flatten.map { |v| %("#{v}") }.join(',')}) "
+    sql += %(REFERENCES "#{foreign_key.to_table}" )
+    sql += "(#{[foreign_key.to_columns].flatten.map { |v| %("#{v}") }.join(',')})"
+    sql
+  end
+
+  def create_table_sqls(delta)
+    delta[:add_table].map do |table_name, table|
+      column_sql = (create_table_column_sql(table) << create_table_index_sql(table))
+        .flatten
+        .reject(&:empty?)
+        .join(",\n  ")
+      sql = <<-SQL
+CREATE TABLE "#{table_name}" (
+  #{column_sql}
+);
+      SQL
+      sql = sql.strip
+      index_sqls = table.indexes.values.map { |index| alter_add_index_sql(table_name, index) }
+      comment_sqls = create_table_comment_sqls(table_name, table)
+      ([sql] + index_sqls + comment_sqls).join("\n")
+    end
+  end
+
+  def create_table_comment_sqls(table_name, table)
+    sqls = []
+    if table.table_options[:comment] && !table.table_options[:comment].to_s.empty?
+      sqls << %(COMMENT ON TABLE "#{table_name}" IS '#{escape_quote(table.table_options[:comment])}';)
+    end
+    table.columns.values.each do |column|
+      comment_sql = comment_on_column_sql(table_name, column)
+      sqls << comment_sql unless comment_sql.nil?
+    end
+    sqls
+  end
+
+  def comment_on_column_sql(table_name, column)
+    return nil if column.options[:comment].nil? || column.options[:comment].to_s.empty?
+    %(COMMENT ON COLUMN "#{table_name}"."#{column.column_name}" IS '#{escape_quote(column.options[:comment])}';)
+  end
+
+  def drop_table_sqls(delta)
+    delta[:remove_table].map do |table_name, _|
+      %(DROP TABLE "#{table_name}";)
+    end
+  end
+
+  def create_table_column_sql(table)
+    table.columns.values.map do |column|
+      create_column_sql(column)
+    end
+  end
+
+  def create_column_sql(column, output_primary_key: false, output_identity: true)
+    fail NotImplementedError.new("#{column.type} is not supported on PostgreSQL adapter yet") if UNSUPPORTED_TYPES.include?(column.type)
+    sql = %("#{column.column_name}")
+    sql += " #{postgres_column_type(column)}"
+    if column.options[:null]
+      sql += ' DEFAULT NULL' unless column.options[:default]
+    else
+      sql += ' NOT NULL'
+    end
+    if column.options[:primary_key] && output_primary_key
+      sql += ' PRIMARY KEY'
+    end
+    if column.options[:default]
+      sql += " DEFAULT #{quote_default_expression(column.options[:default])}"
+    end
+    if auto_increment?(column) && output_identity
+      sql += ' GENERATED BY DEFAULT AS IDENTITY'
+    end
+    sql
+  end
+
+  def postgres_column_type(column)
+    return 'boolean' if column.type == :tinyint && column.options[:limit].to_s == '1'
+    type = TYPE_MAPPING[column.type] || column.type.to_s
+    if TYPES_WITH_LIMIT.include?(column.type) && column.options[:limit]
+      "#{type}(#{column.options[:limit]})"
+    elsif column.type == :decimal && column.options[:precision] && column.options[:scale]
+      "#{type}(#{column.options[:precision]}, #{column.options[:scale]})"
+    else
+      type
+    end
+  end
+
+  def auto_increment?(column)
+    extra = column.options[:extra]
+    !extra.nil? && extra.to_s.upcase.include?('AUTO_INCREMENT')
+  end
+
+  def create_table_index_sql(table)
+    pkeys = table.columns.select { |_k, v| v.options[:primary_key] }
+    foreign_keys = table.foreign_keys.values
+    results = []
+    unless pkeys.empty?
+      results << %(PRIMARY KEY (#{pkeys.keys.map { |v| %("#{v}") }.join(',')}))
+    end
+    results << foreign_keys.map { |fk| foreign_key_constraint_sql(fk) }
+    results
+  end
+
+  def quoted_index_columns(index)
+    [index.index_columns].flatten.map { |v| %("#{v}") }
+  end
+
+  def escape_quote(value)
+    value.to_s.gsub("'", "''")
+  end
+
+  def quote_default_expression(value)
+    if value.is_a?(Proc)
+      value.call
+    else
+      %('#{escape_quote(value)}')
+    end
+  end
+end