convergence 0.0.1

data/lib/convergence/dsl.rb

@@ -0,0 +1,20 @@
+class Convergence::DSL
+  attr_accessor :tables
+
+  def initialize
+    @tables = {}
+  end
+
+  def create_table(table_name, options = {}, &block)
+    table = Convergence::Table.new(table_name, options)
+    block.call(table)
+    @tables[table_name.to_s] = table
+    table
+  end
+
+  def self.parse(code)
+    parser = new
+    parser.instance_eval(code)
+    parser.tables
+  end
+end

data/lib/convergence/dumper.rb

@@ -0,0 +1,68 @@
+class Convergence::Dumper
+  def dump_dsl(tables)
+    tables.map do |_, table|
+      dump_table_dsl(table)
+    end.join("\n\n")
+  end
+
+  def dump_table_dsl(table)
+    table_argument = ["\"#{table.table_name}\""]
+    table_argument << table.table_options.map { |k, v| key_value_text(k, v) }
+    dsl = "create_table #{table_argument.flatten.join(', ')} do |t|\n"
+    dsl += "  #{table.columns.map { |_, column| dump_column(column) }.join("\n  ")}"
+    dsl += "\n" if !table.indexes.empty? || !table.foreign_keys.empty?
+    dsl += "\n"
+    unless table.indexes.empty?
+      dsl += "  #{table.indexes.map { |_, index| dump_index(index) }.join("\n  ")}"
+      dsl += "\n"
+    end
+    unless table.foreign_keys.empty?
+      dsl += "  #{table.foreign_keys.map { |_, key| dump_foreign_key(key) }.join("\n  ")}"
+      dsl += "\n"
+    end
+    dsl += 'end'
+    dsl
+  end
+
+  private
+
+  def dump_column(column)
+    argument = [%("#{column.column_name}")]
+    argument << column.options.map { |k, v| key_value_text(k, v) }
+    "t.#{column.type} #{argument.flatten.join(', ')}"
+  end
+
+  def dump_index(index)
+    columns = single_or_multiple_text(index.index_columns)
+    argument = [columns]
+    argument << index.options.map { |k, v| key_value_text(k, v) }
+    "t.index #{argument.flatten.join(', ')}"
+  end
+
+  def dump_foreign_key(foreign_key)
+    columns = single_or_multiple_text(foreign_key.from_columns)
+    argument = [columns]
+    argument << [key_value_text('reference', foreign_key.to_table)]
+    argument << ["reference_column: #{single_or_multiple_text(foreign_key.to_columns)}"]
+    argument << foreign_key.options.map { |k, v| key_value_text(k, v) }
+    "t.foreign_key #{argument.flatten.join(', ')}"
+  end
+
+  def single_or_multiple_text(values)
+    values_array = [values].flatten
+    if values_array.size == 1
+      %("#{values_array.first}")
+    else
+      %(#{values})
+    end
+  end
+
+  def key_value_text(k, v)
+    value = if v.to_s == 'true' || v.to_s == 'false' || v =~ /^\d+$/
+              v
+            else
+              %(#{v.inspect})
+            end
+    "#{k}: #{value}"
+  end
+end

data/lib/convergence/dumper/mysql_schema_dumper.rb

@@ -0,0 +1,149 @@
+require 'mysql2'
+class Convergence::Dumper::MysqlSchemaDumper
+  def initialize(connector)
+    @connector = connector
+    @target_database = connector.config.database
+    @tables = {}
+  end
+
+  def dump
+    table_definitions = select_table_definitions(@target_database)
+    column_definitions = select_column_definitions(@target_database).group_by { |r| r['TABLE_NAME'] }
+    index_definitions = select_index_definitions(@target_database).group_by { |r| r['TABLE_NAME'] }
+    table_definitions.map { |r| r['TABLE_NAME'] }.each do |table_name|
+      table = Convergence::Table.new(table_name)
+      parse_table_options(table, table_definitions.find { |r| r['TABLE_NAME'] == table_name })
+      parse_columns(table, column_definitions[table_name])
+      parse_indexes(table, index_definitions[table_name])
+      @tables[table_name] = table
+    end
+    @tables
+  end
+
+  private
+
+  def mysql
+    @connector.schema_client
+  end
+
+  def select_table_definitions(database_name)
+    mysql.query("
+      SELECT
+        *
+      FROM
+        TABLES
+      INNER JOIN
+        COLLATION_CHARACTER_SET_APPLICABILITY CCSA
+      ON
+        TABLES.TABLE_COLLATION = CCSA.COLLATION_NAME
+      WHERE
+        TABLE_SCHEMA = '#{mysql.escape(database_name)}'
+      ORDER BY
+        TABLE_NAME
+    ")
+  end
+
+  def select_column_definitions(database_name)
+    mysql.query("
+      SELECT * FROM COLUMNS
+      WHERE TABLE_SCHEMA = '#{mysql.escape(database_name)}'
+      ORDER BY TABLE_NAME, ORDINAL_POSITION
+    ")
+  end
+
+  def select_index_definitions(database_name)
+    mysql.query("
+      SELECT
+        DISTINCT S.TABLE_NAME, S.COLUMN_NAME, S.NON_UNIQUE, S.INDEX_NAME, S.SEQ_IN_INDEX, S.INDEX_TYPE,
+        IF(TC.CONSTRAINT_TYPE IS NULL, 'INDEX', TC.CONSTRAINT_TYPE) CONSTRAINT_TYPE,
+        KCU.REFERENCED_TABLE_NAME, KCU.REFERENCED_COLUMN_NAME
+      FROM
+        STATISTICS S
+      LEFT OUTER JOIN
+        TABLE_CONSTRAINTS TC
+      ON
+        TC.TABLE_SCHEMA = S.TABLE_SCHEMA
+        AND TC.TABLE_NAME = S.TABLE_NAME
+        AND TC.CONSTRAINT_NAME = S.INDEX_NAME
+      LEFT OUTER JOIN
+        KEY_COLUMN_USAGE KCU
+      ON
+        KCU.CONSTRAINT_SCHEMA = S.TABLE_SCHEMA
+        AND KCU.TABLE_NAME = S.TABLE_NAME
+        AND KCU.CONSTRAINT_NAME = TC.CONSTRAINT_NAME
+      WHERE
+        S.TABLE_SCHEMA = '#{mysql.escape(database_name)}'
+      ORDER BY
+        S.TABLE_NAME, S.INDEX_NAME, S.SEQ_IN_INDEX
+    ")
+  end
+
+  def parse_table_options(table, table_option)
+    option = {}
+    option.merge!(engine: table_option['ENGINE'])
+    row_format = table_option['CREATE_OPTIONS'].scan(/=(.*)/).flatten[0] || table_option['ROW_FORMAT']
+    option.merge!(row_format: row_format)
+    option.merge!(default_charset: table_option['CHARACTER_SET_NAME'])
+    option.merge!(collate: table_option['TABLE_COLLATION'])
+    option.merge!(comment: table_option['TABLE_COMMENT'])
+    table.table_options = option
+  end
+
+  def parse_columns(table, columns)
+    columns.each do |column|
+      data_type, column_name, options = parse_column(column)
+      table.send(data_type, column_name, options)
+    end
+  end
+
+  def parse_column(column)
+    data_type = column['DATA_TYPE']
+    column_name = column['COLUMN_NAME']
+    options = { null: column['IS_NULLABLE'] == 'YES' ? true : false }
+    options.merge!(default: column['COLUMN_DEFAULT']) unless column['COLUMN_DEFAULT'].nil?
+    options.merge!(character_set: column['CHARACTER_SET_NAME']) unless column['CHARACTER_SET_NAME'].nil?
+    options.merge!(collate: column['COLLATION_NAME']) unless column['COLLATION_NAME'].nil?
+    column_type = column['COLUMN_TYPE']
+    if data_type == 'enum' || data_type == 'set'
+      # TODO: implement
+    elsif data_type == 'decimal'
+      precision, scale = column_type.scan(/\d+/)
+      options.merge!(precision: precision, scale: scale)
+    else
+      limit = column_type.scan(/\d+/)[0]
+      options.merge!(limit: limit) unless limit.nil?
+    end
+    options.merge!(extra: column['EXTRA']) unless column['EXTRA'].empty?
+    options.merge!(comment: column['COLUMN_COMMENT']) unless column['COLUMN_COMMENT'].empty?
+    [data_type, column_name, options]
+  end
+
+  def parse_indexes(table, table_indexes)
+    table_indexes.group_by { |r| r['INDEX_NAME'] }.each do |index_name, indexes|
+      type = indexes.first['CONSTRAINT_TYPE']
+      columns = indexes.map { |v| v['COLUMN_NAME'] }
+      case type
+      when 'PRIMARY KEY'
+        indexes.map { |r| r['COLUMN_NAME'] }.each do |column|
+          options = { primary_key: true }.merge(table.columns[column].options)
+          table.columns[column].options = options
+        end
+      when 'INDEX', 'UNIQUE'
+        options = { name: index_name, type: indexes.first['INDEX_TYPE'] }
+        options.merge!(unique: true) if type == 'UNIQUE'
+        table.index(columns, options)
+      when 'FOREIGN KEY'
+        to_table = indexes.first['REFERENCED_TABLE_NAME']
+        to_columns = indexes.map { |v| v['REFERENCED_COLUMN_NAME'] }
+        options = {
+          reference: to_table,
+          reference_column: to_columns,
+          name: index_name
+        }
+        table.foreign_key(columns, options)
+      else
+        fail NotImplementedError.new('Unknown index type')
+      end
+    end
+  end
+end

data/lib/convergence/foreign_key.rb

@@ -0,0 +1,11 @@
+class Convergence::ForeignKey
+  attr_accessor :key_name, :from_columns, :to_table, :to_columns, :options
+
+  def initialize(key_name, from_columns, to_table, to_columns, options)
+    @key_name = key_name
+    @from_columns = [from_columns].flatten.map(&:to_s)
+    @to_table = to_table
+    @to_columns = [to_columns].flatten.map(&:to_s)
+    @options = { name: @key_name }.merge(options)
+  end
+end

data/lib/convergence/index.rb

@@ -0,0 +1,9 @@
+class Convergence::Index
+  attr_accessor :index_name, :index_columns, :options
+
+  def initialize(index_name, index_columns, options)
+    @index_name = index_name
+    @index_columns = [index_columns].flatten.map(&:to_s)
+    @options = { name: @index_name }.merge(options)
+  end
+end

data/lib/convergence/logger.rb

@@ -0,0 +1,12 @@
+require 'logger'
+class Convergence::Logger < Logger
+  def initialize
+    super($default_output || $stdout)
+    self.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+    self.level = Logger::INFO
+  end
+
+  def output(msg)
+    info(msg)
+  end
+end

data/lib/convergence/module.rb

@@ -0,0 +1 @@
+module Convergence; end

data/lib/convergence/pretty_diff.rb

@@ -0,0 +1,55 @@
+require 'diffy'
+
+class Convergence::PrettyDiff
+  def initialize(from_tables, to_tables)
+    @from_tables = from_tables
+    @to_tables = to_tables
+  end
+
+  def output
+    diff = Convergence::Diff.new.diff(@from_tables, @to_tables)
+    add_tables = diff[:add_table].keys
+    remove_tables = diff[:remove_table].keys
+    change_tables = diff[:change_table].keys
+
+    results = ''
+    add_tables.each do |table_name|
+      results += diff_add_table(table_name)
+      results += "\n\n"
+    end
+    remove_tables.each do |table_name|
+      results += diff_remove_table(table_name)
+      results += "\n\n"
+    end
+    change_tables.each do |table_name|
+      results += diff_change_table(table_name)
+    end
+    results
+  end
+
+  private
+
+  def diff_add_table(table_name)
+    Convergence::Dumper
+      .new
+      .dump_table_dsl(@to_tables[table_name])
+      .split("\n")
+      .map { |v| "+ #{v}" }
+      .join("\n")
+  end
+
+  def diff_remove_table(table_name)
+    Convergence::Dumper
+      .new
+      .dump_table_dsl(@from_tables[table_name])
+      .split("\n")
+      .map { |v| "- #{v}" }
+      .join("\n")
+  end
+
+  def diff_change_table(table_name)
+    from = Convergence::Dumper.new.dump_table_dsl(@from_tables[table_name]) + "\n"
+    to = Convergence::Dumper.new.dump_table_dsl(@to_tables[table_name]) + "\n"
+    Diffy::Diff.new(from, to).to_s
+  end
+end

data/lib/convergence/sql_generator.rb

@@ -0,0 +1,2 @@
+class SQLGenerator
+end

data/lib/convergence/sql_generator/mysql_generator.rb

@@ -0,0 +1,208 @@
+class SQLGenerator::MysqlGenerator < SQLGenerator
+  OPTION_MAPPING = {
+    engine: 'ENGINE',
+    row_format: 'ROW_FORMAT',
+    default_charset: 'DEFAULT CHARACTER SET',
+    collate: 'COLLATE',
+    comment: 'COMMENT'
+  }
+  QUOTE_OPTION = [:comment]
+
+  def generate(to_table, delta)
+    sqls = []
+    sqls << change_table_sql(to_table, delta)
+    sqls << ['']
+    sqls << create_table_sqls(delta)
+    sqls << drop_table_sqls(delta)
+    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|
+      table_delta[:remove_column].each do |_column_name, column|
+        results << alter_remove_column_sql(table_name, column)
+      end
+      table_delta[:add_column].each do |_column_name, column|
+        results << alter_add_column_sql(table_name, column)
+      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[:remove_index].each do |index_name, _index|
+        results << alter_remove_index_sql(table_name, index_name)
+      end
+      table_delta[:add_index].each do |_index_name, index|
+        results << alter_add_index_sql(table_name, index)
+      end
+      table_delta[:remove_foreign_key].each do |index_name, _foreign_key|
+        results << alter_remove_foreign_key_sql(table_name, index_name)
+      end
+      table_delta[:add_foreign_key].each do |_index_name, foreign_key|
+        results << alter_add_foreign_key_sql(table_name, foreign_key)
+      end
+      unless table_delta[:change_table_option].empty?
+        results << alter_change_table_sql(table_name, table_delta[:change_table_option])
+      end
+    end
+    results
+  end
+
+  def alter_add_column_sql(table_name, column)
+    %(ALTER TABLE `#{table_name}` ADD COLUMN #{create_column_sql(column, output_primary_key: true)};)
+  end
+
+  def alter_remove_column_sql(table_name, column)
+    %(ALTER TABLE `#{table_name}` DROP COLUMN `#{column.column_name}`;)
+  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?
+    %(ALTER TABLE `#{table_name}` MODIFY COLUMN #{create_column_sql(column, output_primary_key: true)};)
+  end
+
+  def alter_change_table_sql(table_name, change_table_option)
+    sql = "ALTER TABLE `#{table_name}`"
+    change_table_option.each do |key, value|
+      if QUOTE_OPTION.include?(key)
+        sql += " #{OPTION_MAPPING[key]}='#{value}'"
+      else
+        sql += " #{OPTION_MAPPING[key]}=#{value}"
+      end
+    end
+    sql += ';'
+    sql
+  end
+
+  def alter_remove_index_sql(table_name, index_name)
+    %(DROP INDEX `#{index_name}` ON `#{table_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}`(#{index.index_columns.join(',')});"
+    sql
+  end
+
+  def alter_remove_foreign_key_sql(table_name, index_name)
+    sql = %(ALTER TABLE `#{table_name}` DROP FOREIGN KEY `#{index_name}`;\n)
+    sql += alter_remove_index_sql(table_name, index_name)
+    sql
+  end
+
+  def alter_add_foreign_key_sql(table_name, foreign_key)
+    sql = %(ALTER TABLE `#{table_name}` ADD CONSTRAINT `#{foreign_key.key_name}` FOREIGN KEY )
+    sql += "(#{[foreign_key.from_columns].join(',')}) REFERENCES `#{foreign_key.to_table}`"
+    sql += "(#{[foreign_key.to_columns].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
+CREATE TABLE `#{table_name}` (
+  #{column_sql}
+) #{create_table_option_sql(table)};
+      SQL
+    end
+  end
+
+  def drop_table_sqls(delta)
+    delta[:remove_table].map do |table_name, _|
+      <<-SQL
+DROP TABLE `#{table_name}`;
+      SQL
+    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)
+    sql = "`#{column.column_name}`"
+    sql += " #{column.type}"
+    sql += "(#{column.options[:limit]})" unless column.options[:limit].nil?
+    if column.options[:precision] && column.options[:scale]
+      sql += "(#{column.options[:precision]}, #{column.options[:scale]})"
+    end
+    if column.options[:character_set]
+      sql += " CHARACTER SET #{column.options[:character_set]}"
+    end
+    if column.options[:collate]
+      sql += " COLLATE #{column.options[:collate]}"
+    end
+    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 '#{column.options[:default]}'"
+    end
+    if column.options[:comment]
+      sql += " COMMENT '#{column.options[:comment]}'"
+    end
+    if column.options[:extra]
+      sql += " #{column.options[:extra].upcase}"
+    end
+    if column.options.keys.include?(:after)
+      if column.options[:after].nil?
+        sql += ' FIRST'
+      else
+        sql += " AFTER `#{column.options[:after]}`"
+      end
+    end
+    sql
+  end
+
+  def create_table_index_sql(table)
+    pkeys = table.columns.select { |_k, v| v.options[:primary_key] }
+    unique_keys = table.indexes.values.select { |v| v.options[:unique] }
+    index_keys = table.indexes.values.reject { |v| v.options[:unique] }
+    foreign_keys = table.foreign_keys.values
+    results = []
+    unless pkeys.empty?
+      results << %(PRIMARY KEY (#{pkeys.keys.map { |v| "`#{v}`" }.join(',')}))
+    end
+    results << unique_keys.map do |uk|
+      %(UNIQUE KEY `#{uk.index_name}` (#{uk.index_columns.map { |v| "`#{v}`" }.join(',')}))
+    end
+    results << index_keys.map do |ik|
+      %(KEY `#{ik.index_name}` (#{ik.index_columns.map { |v| "`#{v}`" }.join(',')}))
+    end
+    results << foreign_keys.map do |fk|
+      sql = %(CONSTRAINT `#{fk.key_name}` FOREIGN KEY)
+      sql += %( (#{[fk.from_columns].flatten.map { |v| "`#{v}`" }.join(',')}))
+      sql += %( REFERENCES `#{fk.to_table}` (#{[fk.to_columns].flatten.map { |v| "`#{v}`" }.join(',')}))
+      sql
+    end
+    results
+  end
+
+  def create_table_option_sql(table)
+    table.table_options.map do |k, v|
+      key = OPTION_MAPPING[k] || k.to_s.upcase
+      if QUOTE_OPTION.include?(k)
+        "#{key}=\"#{v}\""
+      else
+        "#{key}=#{v}"
+      end
+    end.join(' ')
+  end
+end