groonga-schema 1.0.0

data/lib/groonga-schema/column.rb

@@ -0,0 +1,211 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module GroongaSchema
+  class Column
+    attr_reader :table_name
+    attr_reader :name
+    attr_accessor :type
+    attr_accessor :flags
+    attr_accessor :value_type
+    attr_accessor :sources
+    attr_writer :reference_value_type
+    attr_accessor :related_columns
+    def initialize(table_name, name)
+      @table_name = table_name
+      @name = name
+      @type = :scalar
+      @flags = []
+      @value_type = "ShortText"
+      @sources = []
+      @reference_value_type = false
+      @related_columns = []
+    end
+
+    def reference_value_type?
+      @reference_value_type
+    end
+
+    def apply_command(command)
+      applier = CommandApplier.new(self, command)
+      applier.apply
+    end
+
+    def apply_column(column)
+      self.type                 = column.type
+      self.flags                = column.flags
+      self.value_type           = column.value_type
+      self.sources              = column.sources
+      self.reference_value_type = column.reference_value_type?
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      @table_name == other.table_name and
+        @name == other.name and
+        @type == other.type and
+        @flags.sort == other.flags.sort and
+        @value_type == other.value_type and
+        @sources == other.sources
+    end
+
+    def to_create_groonga_command
+      column_create_command(@name)
+    end
+
+    def to_remove_groonga_command
+      column_remove_command(@name)
+    end
+
+    def to_copy_groonga_command(to_table_name, to_name)
+      column_copy_command(to_table_name, to_name)
+    end
+
+    def to_migrate_start_groonga_commands
+      commands = []
+      commands << column_create_command(new_name)
+      if type != :index
+        commands << column_copy_command(@table_name, new_name)
+      end
+      commands << column_rename_command(@name, old_name)
+      commands << column_rename_command(new_name, @name)
+      commands
+    end
+
+    def to_migrate_finish_groonga_commands
+      [
+        column_remove_command(old_name),
+      ]
+    end
+
+    private
+    def old_name
+      "#{@name}_old"
+    end
+
+    def new_name
+      "#{@name}_new"
+    end
+
+    def column_create_command(name)
+      flags_value = [type_flag, *flags].join("|")
+      sources_value = @sources.join(",")
+      sources_value = nil if sources_value.empty?
+      arguments = {
+        "table"  => @table_name,
+        "name"   => name,
+        "flags"  => flags_value,
+        "type"   => @value_type,
+        "source" => sources_value,
+      }
+      Groonga::Command::ColumnCreate.new(arguments)
+    end
+
+    def column_remove_command(name)
+      arguments = {
+        "table"  => @table_name,
+        "name"   => name,
+      }
+      Groonga::Command::ColumnRemove.new(arguments)
+    end
+
+    def column_copy_command(to_table_name, to_name)
+      arguments = {
+        "from_table" => @table_name,
+        "from_name"  => @name,
+        "to_table"   => to_table_name,
+        "to_name"    => to_name,
+      }
+      Groonga::Command::ColumnCopy.new(arguments)
+    end
+
+    def column_rename_command(name, new_name)
+      arguments = {
+        "table"    => @table_name,
+        "name"     => name,
+        "new_name" => new_name,
+      }
+      Groonga::Command::ColumnRename.new(arguments)
+    end
+
+    def type_flag
+      case @type
+      when :scalar
+        "COLUMN_SCALAR"
+      when :vector
+        "COLUMN_VECTOR"
+      when :index
+        "COLUMN_INDEX"
+      else
+        "COLUMN_SCALAR"
+      end
+    end
+
+    class CommandApplier
+      def initialize(column, command)
+        @column = column
+        @command = command
+      end
+
+      def apply
+        apply_flags
+        apply_value_type
+        apply_sources
+      end
+
+      private
+      def apply_flags
+        @type = :scalar
+        @flags = []
+        @command.flags.each do |flag|
+          parse_flag(flag)
+        end
+
+        @column.type = @type
+        @column.flags = @flags
+      end
+
+      def parse_flag(flag)
+        case flag
+        when "COLUMN_SCALAR"
+          @type = :scalar
+        when "COLUMN_VECTOR"
+          @type = :vector
+        when "COLUMN_INDEX"
+          @type = :index
+        else
+          @flags << flag
+        end
+      end
+
+      def apply_value_type
+        # TODO: Validate for index column. Index column must have table as
+        # value type.
+        @column.value_type = @command.type
+      end
+
+      def apply_sources
+        case @type
+        when :index
+          @column.sources = @command.sources
+        else
+          @column.sources = []
+        end
+      end
+    end
+  end
+end

data/lib/groonga-schema/command-line/groonga-schema-diff.rb

@@ -0,0 +1,112 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "optparse"
+require "uri"
+require "open-uri"
+
+require "groonga/command/parser"
+
+require "groonga-schema/differ"
+
+module GroongaSchema
+  module CommandLine
+    class GroongaSchemaDiff
+      class << self
+        def run(args=ARGV)
+          new(args).run
+        end
+      end
+
+      def initialize(args)
+        @args = args
+        @format = :command
+      end
+
+      def run
+        parse_arguments
+
+        from_schema = parse_schema(@from)
+        to_schema = parse_schema(@to)
+        differ = GroongaSchema::Differ.new(from_schema, to_schema)
+        diff = differ.diff
+        $stdout.print(diff.to_groonga_command_list(:format => @format))
+
+        if diff.same?
+          0
+        else
+          1
+        end
+      end
+
+      private
+      def parse_arguments
+        parser = OptionParser.new
+        parser.banner += " FROM_SCHEMA TO_SCHEMA"
+
+        available_formats = [:command, :uri]
+        parser.on("--format=FORMAT", available_formats,
+                  "Specify output Groonga command format.",
+                  "Available formats: #{available_formats.join(", ")}",
+                  "(#{@format})") do |format|
+          @format = format
+        end
+
+        rest_args = parser.parse(@args)
+
+        if rest_args.size != 2
+          $stderr.puts("Error: Both FROM_SCHEMA and TO_SCHEMA are required.")
+          $stderr.puts(parser.help)
+          exit(false)
+        end
+        @from, @to = rest_args
+      end
+
+      def parse_schema(resource_path)
+        open_resource(resource_path) do |resource|
+          schema = GroongaSchema::Schema.new
+          parser = Groonga::Command::Parser.new
+          parser.on_command do |command|
+            schema.apply_command(command)
+          end
+          resource.each_line do |line|
+            parser << line
+          end
+          parser.finish
+          schema
+        end
+      end
+
+      def open_resource(resource_path)
+        uri = nil
+        begin
+          uri = URI.parse(resource_path)
+        rescue URI::InvalidURIError
+        end
+
+        if uri and uri.respond_to?(:open)
+          uri.open do |response|
+            yield(response)
+          end
+        else
+          File.open(resource_path) do |file|
+            yield(file)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groonga-schema/diff.rb

@@ -0,0 +1,268 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+module GroongaSchema
+  class Diff
+    attr_reader :removed_plugins
+    attr_reader :added_plugins
+
+    attr_reader :removed_tables
+    attr_reader :added_tables
+    attr_reader :changed_tables
+
+    attr_reader :removed_columns
+    attr_reader :added_columns
+    attr_reader :changed_columns
+    def initialize
+      @removed_plugins = []
+      @added_plugins = []
+
+      @removed_tables = {}
+      @added_tables = {}
+      @changed_tables = {}
+
+      @removed_columns = {}
+      @added_columns = {}
+      @changed_columns = {}
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+
+      @removed_plugins == other.removed_plugins and
+        @added_plugins == other.added_plugins and
+        @removed_tables == other.removed_tables and
+        @added_tables == other.added_tables and
+        @changed_tables == other.changed_tables and
+        @removed_columns == other.removed_columns and
+        @added_columns == other.added_columns and
+        @changed_columns == other.changed_columns
+    end
+
+    def same?
+      @removed_plugins.empty? and
+        @added_plugins.empty? and
+        @removed_tables.empty? and
+        @added_tables.empty? and
+        @changed_tables.empty? and
+        @removed_columns.empty? and
+        @added_columns.empty? and
+        @changed_columns.empty?
+    end
+
+    def to_groonga_command_list(options={})
+      converter = GroongaCommandListConverter.new(self, options)
+      converter.convert
+    end
+
+    class GroongaCommandListConverter
+      def initialize(diff, options={})
+        @diff = diff
+        @options = options
+        @grouped_list = []
+      end
+
+      def convert
+        @grouped_list.clear
+
+        convert_added_plugins
+        convert_added_tables
+        convert_removed_columns
+        convert_removed_tables
+        convert_removed_plugins
+        convert_changed_tables
+
+        meaningful_grouped_list = @grouped_list.reject do |group|
+          group.empty?
+        end
+        formatted_grouped_list = meaningful_grouped_list.collect do |group|
+          command_list = ""
+          group.each do |command|
+            command_list << "#{format_command(command)}\n"
+          end
+          command_list
+        end
+        formatted_grouped_list.join("\n")
+      end
+
+      private
+      def convert_added_plugins
+        sorted_plugins = @diff.added_plugins.sort_by(&:name)
+        @grouped_list << sorted_plugins.collect(&:to_register_groonga_command)
+      end
+
+      def convert_added_tables
+        reference_table_names = []
+        no_reference_table_names = []
+        @diff.added_tables.each do |name, table|
+          if table.reference_key_type?
+            reference_table_names << name
+          else
+            no_reference_table_names << name
+          end
+        end
+        no_reference_table_names |=
+          (@diff.added_columns.keys - reference_table_names)
+
+        sorted_reference_table_names = reference_table_names.sort
+        sorted_no_reference_table_names = no_reference_table_names.sort
+
+        sorted_table_names =
+          sorted_no_reference_table_names +
+          sorted_reference_table_names
+
+        sorted_table_names.each do |name|
+          group = []
+          table = @diff.added_tables[name]
+          group << table.to_create_groonga_command if table
+          group.concat(convert_added_columns(name, false))
+          @grouped_list << group
+        end
+
+        sorted_table_names.each do |name|
+          @grouped_list << convert_added_columns(name, true)
+        end
+      end
+
+      def convert_added_columns(name, target_is_reference_type)
+        columns = @diff.added_columns[name]
+        return [] if columns.nil?
+
+        sorted_columns = columns.sort_by do |column_name,|
+          column_name
+        end
+
+        group = []
+        sorted_columns.each do |column_name, column|
+          if target_is_reference_type
+            next unless column.reference_value_type?
+          else
+            next if column.reference_value_type?
+          end
+          group << column.to_create_groonga_command
+        end
+        group
+      end
+
+      def convert_removed_columns
+        sorted_removed_columns = @diff.removed_columns.sort_by do |table_name,|
+          table_name
+        end
+
+        column_groups = []
+        sorted_removed_columns.each do |table_name, columns|
+          group = []
+          columns.each do |column_name, column|
+            group << column unless column.sources.empty?
+          end
+          next if group.empty?
+          column_groups << group
+        end
+        sorted_removed_columns.each do |table_name, columns|
+          group = []
+          columns.each do |column_name, column|
+            group << column if column.sources.empty?
+          end
+          next if group.empty?
+          column_groups << group
+        end
+
+        column_groups.each do |columns|
+          sorted_columns = columns.sort_by do |column|
+            column.name
+          end
+          group = sorted_columns.collect do |column|
+            column.to_remove_groonga_command
+          end
+          @grouped_list << group
+        end
+      end
+
+      def convert_removed_tables
+        sorted_tables = @diff.removed_tables.sort_by do |name, table|
+          [
+            table.reference_key_type? ? 0 : 1,
+            table.name,
+          ]
+        end
+
+        sorted_tables.each do |name, table|
+          @grouped_list << [table.to_remove_groonga_command]
+        end
+      end
+
+      def convert_removed_plugins
+        sorted_plugins = @diff.removed_plugins.sort_by(&:name)
+        @grouped_list << sorted_plugins.collect(&:to_unregister_groonga_command)
+      end
+
+      def convert_changed_tables
+        sorted_tables = @diff.changed_tables.sort_by do |name, table|
+          [
+            table.reference_key_type? ? 1 : 0,
+            table.name,
+          ]
+        end
+
+        sorted_tables.each do |name, table|
+          @grouped_list << table.to_migrate_start_groonga_commands
+        end
+        convert_changed_columns
+        sorted_tables.each do |name, table|
+          @grouped_list << table.to_migrate_finish_groonga_commands
+        end
+      end
+
+      def convert_changed_columns
+        all_columns = []
+        @diff.changed_columns.each do |table_name, columns|
+          all_columns.concat(columns.values)
+        end
+
+        sorted_columns = all_columns.sort_by do |column|
+          [
+            (column.type == :index) ? 1 : 0,
+            column.table_name,
+            column.name,
+          ]
+        end
+        sorted_columns.each do |column|
+          @grouped_list << column.to_migrate_start_groonga_commands
+        end
+
+        sorted_columns = all_columns.sort_by do |column|
+          [
+            (column.type == :index) ? 0 : 1,
+            column.table_name,
+            column.name,
+          ]
+        end
+        sorted_columns.each do |column|
+          @grouped_list << column.to_migrate_finish_groonga_commands
+        end
+      end
+
+      def format_command(command)
+        case @options[:format]
+        when :uri
+          command.to_uri_format
+        else
+          command.to_command_format
+        end
+      end
+    end
+  end
+end

data/lib/groonga-schema/differ.rb

@@ -0,0 +1,120 @@
+# Copyright (C) 2016  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+require "groonga-schema/diff"
+
+module GroongaSchema
+  class Differ
+    # @param from [Schema] The original schema.
+    # @param to [Schema] The changed schema.
+    def initialize(from, to)
+      @from = from
+      @to = to
+    end
+
+    def diff
+      diff = Diff.new
+      diff_plugins(diff)
+      diff_tables(diff)
+      diff_columns(diff)
+      diff
+    end
+
+    private
+    def diff_plugins(diff)
+      diff.removed_plugins.concat(@from.plugins - @to.plugins)
+      diff.added_plugins.concat(@to.plugins - @from.plugins)
+    end
+
+    def diff_tables(diff)
+      from_tables = @from.tables
+      to_tables = @to.tables
+
+      from_tables.each do |name, from_table|
+        to_table = to_tables[name]
+        if to_table.nil?
+          diff.removed_tables[from_table.name] = from_table
+        elsif from_table != to_table
+          diff_changed_table(diff, to_table)
+        end
+      end
+
+      to_tables.each do |name, to_table|
+        from_table = from_tables[name]
+        if from_table.nil?
+          diff.added_tables[name] = to_table
+        end
+      end
+    end
+
+    def diff_changed_table(diff, to_table)
+      diff.changed_tables[to_table.name] = to_table
+
+      to_table.related_tables.each do |table|
+        diff.changed_tables[table.name] = table
+      end
+
+      to_table.related_columns.each do |column|
+        table_name = column.table_name
+        diff.changed_columns[table_name] ||= {}
+        diff.changed_columns[table_name][column.name] = column
+      end
+    end
+
+    def diff_columns(diff)
+      @from.columns.each do |table_name, from_columns|
+        to_columns = @to.columns[table_name]
+        next if to_columns.nil?
+
+        from_columns.each do |name, from_column|
+          to_column = to_columns[name]
+          if to_column.nil?
+            diff.removed_columns[table_name] ||= {}
+            diff.removed_columns[table_name][name] = from_column
+          elsif from_column != to_column
+            diff_changed_column(diff, to_column)
+          end
+        end
+      end
+
+      @to.columns.each do |table_name, to_columns|
+        from_columns = @from.columns[table_name] || {}
+        to_columns.each do |name, to_column|
+          from_column = from_columns[name]
+          if from_column.nil?
+            diff.added_columns[table_name] ||= {}
+            diff.added_columns[table_name][name] = to_column
+          end
+        end
+      end
+    end
+
+    def diff_changed_column(diff, to_column)
+      table_name = to_column.table_name
+      name = to_column.name
+
+      diff.changed_columns[table_name] ||= {}
+      diff.changed_columns[table_name][name] = to_column
+
+      to_column.related_columns.each do |related_column|
+        related_table_name = related_column.table_name
+        related_name = related_column.name
+        diff.changed_columns[related_table_name] ||= {}
+        diff.changed_columns[related_table_name][related_name] = related_column
+      end
+    end
+  end
+end