mysql-inspector 0.0.6 → 0.1.0

data/lib/mysql_inspector.rb

@@ -0,0 +1,30 @@
+require "fileutils"
+require 'open3'
+require "time"
+require 'tempfile'
+
+require "mysql_inspector/version"
+
+require "mysql_inspector/table_part"
+require "mysql_inspector/column"
+require "mysql_inspector/constraint"
+require "mysql_inspector/index"
+
+require "mysql_inspector/cli"
+require "mysql_inspector/config"
+require "mysql_inspector/diff"
+require "mysql_inspector/grep"
+require "mysql_inspector/migrations"
+require "mysql_inspector/table"
+
+require "mysql_inspector/access"
+require "mysql_inspector/dump"
+
+require "mysql_inspector/ar/access"
+
+if defined?(Rails)
+  require 'mysql_inspector/railtie'
+end
+
+module MysqlInspector
+end

data/lib/mysql_inspector/access.rb

@@ -0,0 +1,64 @@
+module MysqlInspector
+  class Access
+
+    Error = Class.new(StandardError)
+
+    def initialize(database_name, mysql_user, mysql_password, mysql_path)
+      @database_name = database_name
+      @mysql_user = mysql_user
+      @mysql_password = mysql_password
+      @mysql_path = mysql_path
+    end
+
+    def table_names
+      rows_from pipe_to_mysql("SHOW TABLES")
+    end
+
+    def tables
+      table_names.map { |table|
+        rows = rows_from pipe_to_mysql("SHOW CREATE TABLE #{table}")
+        schema = rows[0].split("\t").last.gsub(/\\n/, "\n")
+        MysqlInspector::Table.new(schema)
+      }
+    end
+
+    def drop_all_tables
+      return if table_names.empty?
+
+      pipe_to_mysql without_foreign_keys("DROP TABLE #{table_names.join(',')}")
+    end
+
+    def load(schema)
+      pipe_to_mysql without_foreign_keys(schema)
+    end
+
+  protected
+
+    def without_foreign_keys(query)
+      ["SET foreign_key_checks = 0", query, "SET foreign_key_checks = 1"].join(";\n")
+    end
+
+    def pipe_to_mysql(query)
+      mysql_command = [@mysql_path, "-u#{@mysql_user}", @mysql_password ? "-p#{@mysql_password}" : nil].compact * " "
+      out, err, status = nil
+      Tempfile.open('schema') do |file|
+        file.print(query)
+        file.flush
+        out, err, status = Open3.capture3("cat #{file.path} | #{mysql_command} #{@database_name}")
+      end
+      unless status.exitstatus == 0
+        case err
+        when /\s1049\s/
+          raise Error, "The database #{@database_name} does not exist"
+        else
+          raise Error, err
+        end
+      end
+      out
+    end
+
+    def rows_from(output)
+      (output.split("\n")[1..-1] || []).map { |row| row.chomp }
+    end
+  end
+end

data/lib/mysql_inspector/ar/access.rb

@@ -0,0 +1,55 @@
+module MysqlInspector
+  module AR
+    class Access
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def table_names
+        tables.map { |t| t.table_name }
+      end
+
+      def tables
+        dump = @connection.structure_dump
+        tables = dump.split(";").map { |schema|
+          table = MysqlInspector::Table.new(schema)
+          table if table.table_name
+        }.compact
+      end
+
+      def drop_all_tables
+        @connection.disable_referential_integrity do
+          names = table_names
+          @connection.execute("DROP TABLE #{names.join(',')}") if names.any?
+        end
+      end
+
+      def load(schema)
+        @connection.disable_referential_integrity do
+          schema.split(";").each { |table|
+            @connection.execute(table)
+          }
+        end
+      end
+
+      def read_migrations(table_name)
+        if table_names.include?(table_name)
+          @connection.select_values("SELECT * FROM #{table_name}")
+        else
+          []
+        end
+      end
+
+      def write_migrations(table_name, col, values)
+        if table_names.include?(table_name)
+          values = values.map { |value| "('#{value}')" }
+          @connection.execute("INSERT INTO #{table_name} (#{col}) VALUES #{values * ','}")
+        end
+      end
+    end
+
+  end
+end
+
+

data/lib/mysql_inspector/cli.rb

@@ -0,0 +1,291 @@
+require 'optparse'
+
+module MysqlInspector
+  class CLI
+
+    NAME = "mysql-inspector"
+
+    CURRENT = "current"
+    TARGET  = "target"
+
+    module Helper
+
+      def exit(msg)
+        @stdout.puts msg
+        throw :quit, 0
+      end
+
+      def abort(msg)
+        @stderr.puts msg
+        throw :quit, 1
+      end
+
+      def usage(msg)
+        abort "Usage: #{NAME} #{msg}"
+      end
+
+      def puts(*args)
+        @stdout.puts(*args)
+      end
+    end
+
+    module Formatting
+      # Print table item details.
+      #
+      # Examples
+      #
+      #     LABEL    item1
+      #              item2
+      #
+      def format_items(label, items, &formatter)
+        pad = " " * 4
+        formatter ||= proc { |item | item.to_sql }
+        items.each.with_index { |item, i|
+          if i == 0
+            puts [label, pad, formatter.call(item)] * ""
+          else
+            puts [" " * label.size, pad, formatter.call(item)] * ""
+          end
+        }
+      end
+    end
+
+    include Helper
+
+    def initialize(config, stdout, stderr)
+      @config = config
+      @stdout = stdout
+      @stderr = stderr
+      @status = 0
+    end
+
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :status
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: #{NAME} [options] command [command args]"
+
+        opts.separator ""
+        opts.separator "Options"
+        opts.separator ""
+
+        opts.on("--out DIR", "Where to store schemas. Defaults to '.'") do |dir|
+          @config.dir = dir
+        end
+
+        opts.on("--rails", "Configure for a Rails project") do
+          @config.rails!
+        end
+
+        opts.on("-h", "--help", "What you're looking at") do
+          exit opts.to_s
+        end
+
+        opts.on("-v", "--version", "Show the version of mysql-inspector") do
+          exit MysqlInspector::VERSION
+        end
+
+        opts.separator ""
+        opts.separator "Commands"
+        opts.separator ""
+
+        opts.separator "  write DATABASE [VERSION]"
+        opts.separator "  load DATABASE [VERSION]"
+        opts.separator "  diff"
+        opts.separator "  diff TO"
+        opts.separator "  diff FROM TO"
+        opts.separator "  grep PATTERN [PATTERN]"
+        opts.separator ""
+      end
+    end
+
+    def get_command(argv)
+      option_parser.parse!(argv)
+
+      command_name = argv.shift or abort option_parser.to_s
+      command_class = command_name.capitalize + "Command"
+
+      begin
+        klass = self.class.const_get(command_class)
+        command = klass.new(@config, @stdout, @stderr)
+        command.parse!(argv)
+        command
+      rescue NameError
+        abort "Unknown command #{command_name.inspect}"
+      end
+    end
+
+    def run!(argv)
+      @status = catch(:quit) {
+        command = get_command(argv)
+        command.run!
+      }
+    end
+
+    class Command
+      include Helper
+
+      def initialize(config, stdout, stderr)
+        @config = config
+        @stdout = stdout
+        @stderr = stderr
+        @status = nil
+      end
+
+      attr_reader :config
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :status
+
+      def ivar(name)
+        instance_variable_get("@#{name}")
+      end
+
+      def get_dump(version)
+        dump = @config.create_dump(version)
+        dump.exists? or abort "Dump #{version.inspect} does not exist"
+        dump
+      end
+
+      def parse!(argv)
+        @status = catch(:quit) {
+          parse(argv)
+        }
+      end
+
+      def run!
+        @status = catch(:quit) {
+          begin
+            run
+            throw :quit, 0
+          rescue MysqlInspector::Access::Error => e
+            abort e.message
+          end
+        }
+      end
+    end
+
+    class WriteCommand < Command
+
+      def parse(argv)
+        @database = argv.shift or usage "write DATABASE [VERSION]"
+        @version = argv.shift || CURRENT
+      end
+
+      def run
+        config.database_name = @database
+        config.write_dump(@version)
+      end
+    end
+
+    class LoadCommand < Command
+
+      def parse(argv)
+        @database = argv.shift or usage "load DATABASE [VERSION]"
+        @version  = argv.shift || CURRENT
+      end
+
+      def run
+        get_dump(@version) # ensure it exists
+        config.database_name = @database
+        config.load_dump(@version)
+      end
+    end
+
+    class GrepCommand < Command
+      include Formatting
+
+      def parse(argv)
+        @version = CURRENT
+        @matchers = *argv.map { |a| Regexp.new(a) }
+      end
+
+      def run
+        dump = get_dump(@version)
+
+        grep = Grep.new(dump, @matchers)
+        grep.execute
+
+        puts "grep #{@matchers.map { |m| m.inspect } * " AND "}"
+
+        puts if grep.any_matches?
+
+        grep.each_table { |table, subset|
+          puts table.table_name
+          format_items("COL", subset.columns)
+          format_items("IDX", subset.indices)
+          format_items("CST", subset.constraints)
+          puts
+        }
+      end
+    end
+
+    class DiffCommand < Command
+      include Formatting
+
+      def parse(argv)
+        case argv.size
+        when 0
+          @version1 = CURRENT
+          @version2 = TARGET
+        when 1
+          @version1 = CURRENT
+          @version2 = argv.shift
+        else
+          @version1 = argv.shift
+          @version2 = argv.shift
+        end
+      end
+
+      def run
+        dump1 = get_dump(@version1)
+        dump2 = get_dump(@version2)
+
+        diff = Diff.new(dump1, dump2)
+        diff.execute
+
+        puts "diff #{@version1} #{@version2}"
+
+        tables = diff.added_tables + diff.missing_tables + diff.different_tables
+
+        if tables.any?
+          puts
+          tables.sort.each do |t|
+            prefix = prefix_for_table(t, diff)
+            puts "#{prefix} #{t.table_name}"
+            if t.is_a?(Diff::TableDiff)
+              format_diff_items("  COL", t.added_columns, t.missing_columns)
+              format_diff_items("  IDX", t.added_indices, t.missing_indices)
+              format_diff_items("  CST", t.added_constraints, t.missing_constraints)
+            end
+          end
+          puts
+        end
+      end
+
+    protected
+
+      def prefix_for_table(table, diff)
+        case
+        when diff.added_tables.include?(table) then "+"
+        when diff.missing_tables.include?(table) then "-"
+        else "="
+        end
+      end
+
+      def prefix_for_item(item, added, removed)
+        added.include?(item) ? "+" : "-"
+      end
+
+      def format_diff_items(label, added, removed)
+        format_items(label, (added + removed).sort) { |item|
+          prefix = prefix_for_item(item, added, removed)
+          "#{prefix} #{item.to_sql}"
+        }
+      end
+    end
+
+  end
+end

data/lib/mysql_inspector/column.rb

@@ -0,0 +1,21 @@
+module MysqlInspector
+  class Column < Struct.new(:name, :sql_type, :nullable, :default, :auto_increment)
+
+    include MysqlInspector::TablePart
+
+    def to_sql
+      parts = []
+      parts << quote(name)
+      parts << sql_type
+      parts << (nullable ? "NULL" : "NOT NULL")
+      parts << "DEFAULT #{default}" if default
+      parts << "AUTO_INCREMENT" if auto_increment
+      parts * " "
+    end
+
+    def =~(matcher)
+      name =~ matcher
+    end
+
+  end
+end