groonga-query-log 1.3.0 → 1.3.1

data/lib/groonga-query-log/command/verify-server.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2013-2017  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2013-2018  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
@@ -19,133 +19,149 @@ require "optparse"
 require "groonga-query-log"
 
 module GroongaQueryLog
-    module Command
-      class VerifyServer
-        def initialize
-          @options = ServerVerifier::Options.new
-        end
-
-        def run(command_line, &callback)
-          input_paths = create_parser.parse(command_line)
-          verifier = ServerVerifier.new(@options)
-          if input_paths.empty?
-            verifier.verify($stdin, &callback)
-          else
-            input_paths.each do |input_path|
-              File.open(input_path) do |input|
-                verifier.verify(input, &callback)
+  module Command
+    class VerifyServer
+      def initialize
+        @options = ServerVerifier::Options.new
+      end
+
+      def run(command_line, &callback)
+        input_paths = create_parser.parse(command_line)
+        same = true
+        verifier = ServerVerifier.new(@options)
+        if input_paths.empty?
+          same = verifier.verify($stdin, &callback)
+        else
+          input_paths.each do |input_path|
+            File.open(input_path) do |input|
+              unless verifier.verify(input, &callback)
+                same = false
               end
             end
           end
-          true
         end
+        same
+      end
 
-        private
-        def create_parser
-          parser = OptionParser.new
-          parser.version = VERSION
-          parser.banner += " QUERY_LOG1 QUERY_LOG2 ..."
+      private
+      def create_parser
+        parser = OptionParser.new
+        parser.version = VERSION
+        parser.banner += " QUERY_LOG1 QUERY_LOG2 ..."
 
-          parser.separator("")
-          parser.separator("Options:")
+        parser.separator("")
+        parser.separator("Options:")
 
-          available_protocols = [:gqtp, :http]
-          available_protocols_label = "[#{available_protocols.join(', ')}]"
+        available_protocols = [:gqtp, :http]
+        available_protocols_label = "[#{available_protocols.join(', ')}]"
 
-          parser.on("--groonga1-host=HOST",
-                    "Host name or IP address of Groonga server 1",
-                    "[#{@options.groonga1.host}]") do |host|
-            @options.groonga1.host = host
-          end
+        parser.on("--groonga1-host=HOST",
+                  "Host name or IP address of Groonga server 1",
+                  "[#{@options.groonga1.host}]") do |host|
+          @options.groonga1.host = host
+        end
 
-          parser.on("--groonga1-port=PORT", Integer,
-                    "Port number of Groonga server 1",
-                    "[#{@options.groonga1.port}]") do |port|
-            @options.groonga1.port = port
-          end
+        parser.on("--groonga1-port=PORT", Integer,
+                  "Port number of Groonga server 1",
+                  "[#{@options.groonga1.port}]") do |port|
+          @options.groonga1.port = port
+        end
 
-          parser.on("--groonga1-protocol=PROTOCOL", available_protocols,
-                    "Protocol of Groonga server 1",
-                    available_protocols_label) do |protocol|
-            @options.groonga1.protocol = protocol
-          end
+        parser.on("--groonga1-protocol=PROTOCOL", available_protocols,
+                  "Protocol of Groonga server 1",
+                  available_protocols_label) do |protocol|
+          @options.groonga1.protocol = protocol
+        end
 
-          parser.on("--groonga2-host=HOST",
-                    "Host name or IP address of Groonga server 2",
-                    "[#{@options.groonga2.host}]") do |host|
-            @options.groonga2.host = host
-          end
+        parser.on("--groonga2-host=HOST",
+                  "Host name or IP address of Groonga server 2",
+                  "[#{@options.groonga2.host}]") do |host|
+          @options.groonga2.host = host
+        end
 
-          parser.on("--groonga2-port=PORT", Integer,
-                    "Port number of Groonga server 2",
-                    "[#{@options.groonga2.port}]") do |port|
-            @options.groonga2.port = port
-          end
+        parser.on("--groonga2-port=PORT", Integer,
+                  "Port number of Groonga server 2",
+                  "[#{@options.groonga2.port}]") do |port|
+          @options.groonga2.port = port
+        end
 
-          parser.on("--groonga2-protocol=PROTOCOL", available_protocols,
-                    "Protocol of Groonga server 2",
-                    available_protocols_label) do |protocol|
-            @options.groonga2.protocol = protocol
-          end
+        parser.on("--groonga2-protocol=PROTOCOL", available_protocols,
+                  "Protocol of Groonga server 2",
+                  available_protocols_label) do |protocol|
+          @options.groonga2.protocol = protocol
+        end
 
-          parser.on("--n-clients=N", Integer,
-                    "The max number of concurrency",
-                    "[#{@options.n_clients}]") do |n_clients|
-            @options.n_clients = n_clients
-          end
+        parser.on("--n-clients=N", Integer,
+                  "The max number of concurrency",
+                  "[#{@options.n_clients}]") do |n_clients|
+          @options.n_clients = n_clients
+        end
 
-          parser.on("--request-queue-size=SIZE", Integer,
-                    "The size of request queue",
-                    "[auto]") do |size|
-            @options.request_queue_size = size
-          end
+        parser.on("--request-queue-size=SIZE", Integer,
+                  "The size of request queue",
+                  "[auto]") do |size|
+          @options.request_queue_size = size
+        end
 
-          parser.on("--disable-cache",
-                    "Add 'cache=no' parameter to request",
-                    "[#{@options.disable_cache?}]") do
-            @options.disable_cache = true
-          end
+        parser.on("--disable-cache",
+                  "Add 'cache=no' parameter to request",
+                  "[#{@options.disable_cache?}]") do
+          @options.disable_cache = true
+        end
 
-          parser.on("--target-command-name=NAME",
-                    "Add NAME to target command names",
-                    "You can specify this option zero or more times",
-                    "See also --target-command-names") do |name|
-            @options.target_command_names << name
-          end
+        parser.on("--target-command-name=NAME",
+                  "Add NAME to target command names",
+                  "You can specify this option zero or more times",
+                  "See also --target-command-names") do |name|
+          @options.target_command_names << name
+        end
 
-          target_command_names_label = @options.target_command_names.join(", ")
-          parser.on("--target-command-names=NAME1,NAME2,...", Array,
-                    "Replay only NAME1,NAME2,... commands",
-                    "You can use glob to choose command name",
-                    "[#{target_command_names_label}]") do |names|
-            @options.target_command_names = names
-          end
+        target_command_names_label = @options.target_command_names.join(", ")
+        parser.on("--target-command-names=NAME1,NAME2,...", Array,
+                  "Replay only NAME1,NAME2,... commands",
+                  "You can use glob to choose command name",
+                  "[#{target_command_names_label}]") do |names|
+          @options.target_command_names = names
+        end
 
-          parser.on("--no-care-order",
-                    "Don't care order of select response records") do
-            @options.care_order = false
-          end
+        parser.on("--no-care-order",
+                  "Don't care order of select response records") do
+          @options.care_order = false
+        end
 
-          parser.on("--output=PATH",
-                    "Output results to PATH",
-                    "[stdout]") do |path|
-            @options.output_path = path
-          end
+        parser.on("--output=PATH",
+                  "Output results to PATH",
+                  "[stdout]") do |path|
+          @options.output_path = path
+        end
 
-          parser.on("--[no-]verify-cache",
-                    "Verify cache for each query.",
-                    "[#{@options.verify_cache?}]") do |verify_cache|
-            @options.verify_cache = verify_cache
-          end
+        parser.on("--[no-]verify-cache",
+                  "Verify cache for each query.",
+                  "[#{@options.verify_cache?}]") do |verify_cache|
+          @options.verify_cache = verify_cache
+        end
 
-          parser.separator("Debug options:")
-          parser.separator("")
+        parser.on("--ignore-drilldown-key=KEY",
+                  "Don't compare drilldown result for KEY",
+                  "You can specify multiple drilldown keys by",
+                  "specifying this option multiple times") do |key|
+          @options.ignored_drilldown_keys << key
+        end
 
-          parser.on("--abort-on-exception",
-                    "Abort on exception in threads") do
-            Thread.abort_on_exception = true
-          end
+        parser.on("--[no-]stop-on-failure",
+                  "Stop execution on the first failure",
+                  "(#{@options.stop_on_failure?})") do |boolean|
+          @options.stop_on_failure = boolean
+        end
+
+        parser.separator("Debug options:")
+        parser.separator("")
+
+        parser.on("--abort-on-exception",
+                  "Abort on exception in threads") do
+          Thread.abort_on_exception = true
         end
       end
     end
+  end
 end

data/lib/groonga-query-log/response-comparer.rb

@@ -1,4 +1,4 @@
-# Copyright (C) 2014-2017  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2014-2018  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
@@ -15,199 +15,266 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 
 module GroongaQueryLog
-    class ResponseComparer
-      def initialize(command, response1, response2, options={})
-        @command = command
-        @response1 = response1
-        @response2 = response2
-        @options = options
-        @options[:care_order] = true if @options[:care_order].nil?
-      end
+  class ResponseComparer
+    def initialize(command, response1, response2, options={})
+      @command = command
+      @response1 = response1
+      @response2 = response2
+      @options = options.dup
+      @options[:care_order] = true if @options[:care_order].nil?
+      @options[:ignored_drilldown_keys] ||= []
+    end
 
-      def same?
-        if error_response?(@response1) or error_response?(@response2)
-          if error_response?(@response1) and error_response?(@response2)
-            same_error_response?
-          else
-            false
-          end
+    def same?
+      if error_response?(@response1) or error_response?(@response2)
+        if error_response?(@response1) and error_response?(@response2)
+          same_error_response?
         else
-          case @command.name
-          when "select", "logical_select"
-            same_select_response?
-          when "status"
-            same_cache_hit_rate?
-          else
-            same_response?
-          end
+          false
+        end
+      else
+        case @command.name
+        when "select", "logical_select"
+          same_select_response?
+        when "status"
+          same_cache_hit_rate?
+        else
+          same_response?
         end
       end
+    end
 
-      private
-      def error_response?(response)
-        response.is_a?(Groonga::Client::Response::Error)
-      end
+    private
+    def error_response?(response)
+      response.is_a?(Groonga::Client::Response::Error)
+    end
 
-      def same_error_response?
-        return_code1 = @response1.header[0]
-        return_code2 = @response2.header[0]
-        return_code1 == return_code2
-      end
+    def same_error_response?
+      return_code1 = @response1.header[0]
+      return_code2 = @response2.header[0]
+      return_code1 == return_code2
+    end
 
-      def same_response?
-        @response1.body == @response2.body
-      end
+    def same_response?
+      @response1.body == @response2.body
+    end
 
-      def same_select_response?
-        if care_order?
-          if all_output_columns?
-            same_records_all_output_columns?
-          elsif have_unary_minus_output_column?
-            same_records_unary_minus_output_column?
-          else
-            same_response?
-          end
+    def same_select_response?
+      if care_order?
+        if all_output_columns?
+          return false unless same_records_all_output_columns?
+        elsif have_unary_minus_output_column?
+          return false unless same_records_unary_minus_output_column?
         else
-          same_size_response?
+          return false unless same_records?
         end
+        same_drilldowns?
+      else
+        same_size_response?
       end
+    end
 
-      def same_cache_hit_rate?
-        cache_hit_rate1 = @response1.body["cache_hit_rate"]
-        cache_hit_rate2 = @response2.body["cache_hit_rate"]
-        (cache_hit_rate1 - cache_hit_rate2).abs < (10 ** -13)
-      end
+    def same_cache_hit_rate?
+      cache_hit_rate1 = @response1.body["cache_hit_rate"]
+      cache_hit_rate2 = @response2.body["cache_hit_rate"]
+      (cache_hit_rate1 - cache_hit_rate2).abs < (10 ** -13)
+    end
+
+    def care_order?
+      return false unless @options[:care_order]
+      return false if random_sort?
+
+      true
+    end
+
+    def random_score?
+      return false unless @command.respond_to?(:scorer)
+      /\A_score\s*=\s*rand\(\)\z/ === @command.scorer
+    end
 
-      def care_order?
-        return false unless @options[:care_order]
-        return false if random_sort?
+    def random_sort?
+      random_score? and score_sort?
+    end
 
-        true
+    def score_sort?
+      sort_items = @command.sort_keys
+      normalized_sort_items = sort_items.collect do |item|
+        item.gsub(/\A[+-]/, "")
       end
+      normalized_sort_items.include?("_score")
+    end
+
+    def same_size_response?
+      records_result1 = @response1.body[0] || []
+      records_result2 = @response2.body[0] || []
+      return false if records_result1.size != records_result2.size
 
-      def random_score?
-        return false unless @command.respond_to?(:scorer)
-        /\A_score\s*=\s*rand\(\)\z/ === @command.scorer
+      n_hits1 = records_result1[0]
+      n_hits2 = records_result2[0]
+      return false if n_hits1 != n_hits2
+
+      columns1 = records_result1[1]
+      columns2 = records_result2[1]
+      if all_output_columns?
+        columns1.sort_by(&:first) == columns2.sort_by(&:first)
+      else
+        columns1 == columns2
       end
+    end
 
-      def random_sort?
-        random_score? and score_sort?
+    def have_unary_minus_output_column?
+      output_columns = @command.output_columns
+      return false if output_columns.nil?
+      output_columns.split(/\s*,?\s*/).any? {|column| column.start_with?("-")}
+    end
+
+    def same_records_unary_minus_output_column?
+      records_result1 = @response1.body[0] || []
+      records_result2 = @response2.body[0] || []
+      return false if records_result1.size != records_result2.size
+
+      n_hits1 = records_result1[0]
+      n_hits2 = records_result2[0]
+      return false if n_hits1 != n_hits2
+
+      columns1 = records_result1[1]
+      columns2 = records_result2[1]
+      records1 = records_result1[2..-1]
+      records2 = records_result2[2..-1]
+
+      if columns1.size != columns2.size
+        if columns2.size > columns1.size
+          columns1, columns2 = columns2, columns1
+          records1, records2 = records2, records1
+        end
       end
 
-      def score_sort?
-        sort_items = (@command.sortby || "").split(/\s*,\s*/)
-        normalized_sort_items = sort_items.collect do |item|
-          item.gsub(/\A[+-]/, "")
+      records1.each_with_index do |record1, record_index|
+        record2 = records2[record_index]
+        column_offset2 = 0
+        columns1.each_with_index do |name, column_index1|
+          column_index2 = column_offset2 + column_index1
+          if name != columns2[column_index2]
+            column_offset2 -= 1
+            next
+          end
+          value1 = record1[column_index1]
+          value1 = normalize_value(value1, columns1[column_index1])
+          value2 = record2[column_index2]
+          value2 = normalize_value(value2, columns2[column_index2])
+          return false if value1 != value2
         end
-        normalized_sort_items.include?("_score")
       end
 
-      def same_size_response?
-        records_result1 = @response1.body[0] || []
-        records_result2 = @response2.body[0] || []
-        return false if records_result1.size != records_result2.size
+      true
+    end
+
+    def all_output_columns?
+      output_columns = @command.output_columns
+      output_columns.nil? or
+        /\A\s*\z/ === output_columns or
+        output_columns.split(/\s*,?\s*/).include?("*")
+    end
 
-        n_hits1 = records_result1[0]
-        n_hits2 = records_result2[0]
-        return false if n_hits1 != n_hits2
+    def same_records_all_output_columns?
+      records_result1 = @response1.body[0] || []
+      records_result2 = @response2.body[0] || []
+      return false if records_result1.size != records_result2.size
 
-        columns1 = records_result1[1]
-        columns2 = records_result2[1]
-        if all_output_columns?
-          columns1.sort_by(&:first) == columns2.sort_by(&:first)
-        else
-          columns1 == columns2
+      n_hits1 = records_result1[0]
+      n_hits2 = records_result2[0]
+      return false if n_hits1 != n_hits2
+
+      columns1 = records_result1[1]
+      columns2 = records_result2[1]
+      return false if columns1.sort_by(&:first) != columns2.sort_by(&:first)
+
+      column_to_index1 = make_column_to_index_map(columns1)
+      column_to_index2 = make_column_to_index_map(columns2)
+
+      records1 = records_result1[2..-1]
+      records2 = records_result2[2..-1]
+      records1.each_with_index do |record1, record_index|
+        record2 = records2[record_index]
+        column_to_index1.each do |name, column_index1|
+          value1 = record1[column_index1]
+          value1 = normalize_value(value1, columns1[column_index1])
+          column_index2 = column_to_index2[name]
+          value2 = record2[column_index2]
+          value2 = normalize_value(value2, columns2[column_index2])
+          return false if value1 != value2
         end
       end
 
-      def have_unary_minus_output_column?
-        output_columns = @command.output_columns
-        return false if output_columns.nil?
-        output_columns.split(/\s*,?\s*/).any? {|column| column.start_with?("-")}
-      end
+      true
+    end
 
-      def same_records_unary_minus_output_column?
-        records_result1 = @response1.body[0] || []
-        records_result2 = @response2.body[0] || []
-        return false if records_result1.size != records_result2.size
+    def same_records?
+      record_set1 = @response1.body[0] || []
+      record_set2 = @response2.body[0] || []
+      same_record_set?(record_set1,
+                       record_set2)
+    end
 
-        n_hits1 = records_result1[0]
-        n_hits2 = records_result2[0]
-        return false if n_hits1 != n_hits2
+    def same_record_set?(record_set1, record_set2)
+      return false if record_set1.size != record_set2.size
 
-        columns1 = records_result1[1]
-        columns2 = records_result2[1]
-        records1 = records_result1[2..-1]
-        records2 = records_result2[2..-1]
+      n_hits1 = record_set1[0]
+      n_hits2 = record_set2[0]
+      return false if n_hits1 != n_hits2
 
-        if columns1.size != columns2.size
-          if columns2.size > columns1.size
-            columns1, columns2 = columns2, columns1
-            records1, records2 = records2, records1
-          end
-        end
+      columns1 = record_set1[1]
+      columns2 = record_set2[1]
+      return false if columns1 != columns2
 
-        records1.each_with_index do |record1, record_index|
-          record2 = records2[record_index]
-          column_offset2 = 0
-          columns1.each_with_index do |name, column_index1|
-            column_index2 = column_offset2 + column_index1
-            if name != columns2[column_index2]
-              column_offset2 -= 1
-              next
-            end
-            value1 = record1[column_index1]
-            value2 = record2[column_index2]
-            return false if value1 != value2
-          end
+      records1 = record_set1[2..-1]
+      records2 = record_set2[2..-1]
+      records1.each_with_index do |record1, record_index|
+        record2 = records2[record_index]
+        columns1.each_with_index do |column1, column_index|
+          value1 = record1[column_index]
+          value1 = normalize_value(value1, column1)
+          value2 = record2[column_index]
+          value2 = normalize_value(value2, column1)
+          return false if value1 != value2
         end
-
-        true
       end
 
-      def all_output_columns?
-        output_columns = @command.output_columns
-        output_columns.nil? or
-          /\A\s*\z/ === output_columns or
-          output_columns.split(/\s*,?\s*/).include?("*")
+      true
+    end
+
+    def make_column_to_index_map(columns)
+      map = {}
+      columns.each_with_index do |(name, _), i|
+        map[name] = i
       end
+      map
+    end
 
-      def same_records_all_output_columns?
-        records_result1 = @response1.body[0] || []
-        records_result2 = @response2.body[0] || []
-        return false if records_result1.size != records_result2.size
-
-        n_hits1 = records_result1[0]
-        n_hits2 = records_result2[0]
-        return false if n_hits1 != n_hits2
-
-        columns1 = records_result1[1]
-        columns2 = records_result2[1]
-        return false if columns1.sort_by(&:first) != columns2.sort_by(&:first)
-
-        column_to_index1 = make_column_to_index_map(columns1)
-        column_to_index2 = make_column_to_index_map(columns2)
-
-        records1 = records_result1[2..-1]
-        records2 = records_result2[2..-1]
-        records1.each_with_index do |record1, record_index|
-          record2 = records2[record_index]
-          column_to_index1.each do |name, column_index1|
-            value1 = record1[column_index1]
-            value2 = record2[column_to_index2[name]]
-            return false if value1 != value2
-          end
-        end
+    def same_drilldowns?
+      drilldowns1 = @response1.body[1..-1] || []
+      drilldowns2 = @response2.body[1..-1] || []
+      return false if drilldowns1.size != drilldowns2.size
 
-        true
+      drilldown_keys = @command.drilldowns
+      ignored_drilldown_keys = @options[:ignored_drilldown_keys]
+      drilldowns1.each_with_index do |drilldown1, drilldown_index|
+        drilldown_key = drilldown_keys[drilldown_index]
+        next if ignored_drilldown_keys.include?(drilldown_key)
+        drilldown2 = drilldowns2[drilldown_index]
+        return false unless same_record_set?(drilldown1, drilldown2)
       end
+      true
+    end
 
-      def make_column_to_index_map(columns)
-        map = {}
-        columns.each_with_index do |(name, _), i|
-          map[name] = i
-        end
-        map
+    def normalize_value(value, column)
+      type = column[1]
+      case type
+      when "Float"
+        value.round(10)
+      else
+        value
       end
     end
+  end
 end