rroonga 7.0.2-x64-mingw32 → 7.1.1-x64-mingw32

data/vendor/local/lib/groonga/plugins/functions/math.la

@@ -0,0 +1,41 @@
+# math.la - a libtool library file
+# Generated by libtool (GNU libtool) 2.4.6 Debian-2.4.6-2
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='math.dll'
+
+# Names of this library.
+library_names='math.dll.a'
+
+# The name of the static archive.
+old_library='math.a'
+
+# Linker flags that cannot go in dependency_libs.
+inherited_linker_flags=''
+
+# Libraries that this one depends upon.
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -ldbghelp'
+
+# Names of additional weak libraries provided by this library
+weak_library_names=''
+
+# Version information for math.
+current=0
+age=0
+revision=0
+
+# Is this an already installed library?
+installed=yes
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=yes
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='/build/dist-x64/lib/groonga/plugins/functions'

data/vendor/local/lib/groonga/plugins/functions/number.la

@@ -17,7 +17,7 @@ old_library='number.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -ldbghelp'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''

data/vendor/local/lib/groonga/plugins/functions/string.la

@@ -17,7 +17,7 @@ old_library='string.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -ldbghelp'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''

data/vendor/local/lib/groonga/plugins/functions/time.la

@@ -17,7 +17,7 @@ old_library='time.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -ldbghelp'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''

data/vendor/local/lib/groonga/plugins/functions/vector.la

@@ -17,7 +17,7 @@ old_library='vector.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -ldbghelp'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''

data/vendor/local/lib/groonga/plugins/normalizers/mysql.la

@@ -17,7 +17,7 @@ old_library='mysql.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -ldbghelp'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''

data/vendor/local/lib/groonga/plugins/query_expanders/tsv.la

@@ -17,7 +17,7 @@ old_library='tsv.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/build/dist-x64/lib /build/dist-x64/lib/libgroonga.la -lmsgpackc /build/dist-x64/lib/libonigmo.la -llz4 -lz -lws2_32 -ldbghelp'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''

data/vendor/local/lib/groonga/plugins/ruby/eval.rb

@@ -16,7 +16,7 @@ module Groonga
         eval_context = EvalContext.new
         begin
           result = eval_context.eval(script)
-        rescue => error
+        rescue Exception => error
           writer.map("result", 1) do
             writer.write("exception")
             writer.map("exception", 1) do

data/vendor/local/lib/groonga/plugins/sharding.rb

@@ -1,6 +1,9 @@
 require "sharding/parameters"
 require "sharding/range_expression_builder"
 require "sharding/logical_enumerator"
+require "sharding/keys_parsable"
+
+require "sharding/dynamic_columns"
 
 require "sharding/logical_parameters"
 

data/vendor/local/lib/groonga/plugins/sharding/dynamic_columns.rb

@@ -0,0 +1,152 @@
+module Groonga
+  module Sharding
+    class DynamicColumns
+      class << self
+        def parse(input)
+          initial_contexts = []
+          filtered_contexts = []
+          output_contexts = []
+          labeled_arguments = LabeledArguments.new(input, /columns?/)
+          labeled_arguments.each do |label, arguments|
+            contexts = nil
+            case arguments["stage"]
+            when "initial"
+              contexts = initial_contexts
+            when "filtered"
+              contexts = filtered_contexts
+            when "output"
+              contexts = output_contexts
+            else
+              next
+            end
+            contexts << DynamicColumnExecuteContext.new(label, arguments)
+          end
+
+          new(initial_contexts,
+              filtered_contexts,
+              output_contexts)
+        end
+      end
+
+      def initialize(initial_contexts,
+                     filtered_contexts,
+                     output_contexts)
+        @initial_contexts = initial_contexts
+        @filtered_contexts = filtered_contexts
+        @output_contexts = output_contexts
+      end
+
+      def each_initial(&block)
+        @initial_contexts.each(&block)
+      end
+
+      def each_filtered(&block)
+        @filtered_contexts.each(&block)
+      end
+
+      def each_output(&block)
+        @output_contexts.each(&block)
+      end
+
+      def each(&block)
+        each_initial(&block)
+        each_filtered(&block)
+        each_output(&block)
+      end
+
+      def empty?
+        @initial_contexts.empty? and
+          @filtered_contexts.empty? and
+          @output_contexts.empty?
+      end
+
+      def cache_key
+        key = ""
+        [
+          @initial_contexts,
+          @filtered_contexts,
+          @output_contexts,
+        ].each do |contexts|
+          contexts.sort_by(&:label).each do |context|
+            key << "#{context.label}\0"
+            key << "#{context.stage}\0"
+            key << "#{context.type.name}\0"
+            key << "#{context.flags}\0"
+            key << "#{context.value}\0"
+            key << "#{context.window_sort_keys.join(',')}\0"
+            key << "#{context.window_group_keys.join(',')}\0"
+          end
+        end
+        key
+      end
+    end
+
+    class DynamicColumnExecuteContext
+      include KeysParsable
+
+      attr_reader :label
+      attr_reader :stage
+      attr_reader :type
+      attr_reader :flags
+      attr_reader :value
+      attr_reader :window_sort_keys
+      attr_reader :window_group_keys
+      def initialize(label, arguments)
+        @label = label
+        @stage = arguments["stage"]
+        @type = parse_type(arguments["type"])
+        @flags = parse_flags(arguments["flags"] || "COLUMN_SCALAR")
+        @value = arguments["value"]
+        @window_sort_keys = parse_keys(arguments["window.sort_keys"])
+        @window_group_keys = parse_keys(arguments["window.group_keys"])
+      end
+
+      def apply(table, condition=nil)
+        column = table.create_column(@label, @flags, @type)
+        return if table.empty?
+
+        expression = Expression.create(table)
+        begin
+          expression.parse(@value)
+          if @window_sort_keys.empty? and @window_group_keys.empty?
+            expression.condition = condition if condition
+            table.apply_expression(column, expression)
+          else
+            table.apply_window_function(column, expression,
+                                        :sort_keys => @window_sort_keys,
+                                        :group_keys => @window_group_keys)
+          end
+        ensure
+          expression.close
+        end
+      end
+
+      private
+      def parse_type(type_raw)
+        return nil if type_raw.nil?
+
+        type = Context.instance[type_raw]
+        if type.nil?
+          message = "#{error_message_tag} unknown type: <#{type_raw}>"
+          raise InvalidArgument, message
+        end
+
+        case type
+        when Type, Table
+          type
+        else
+          message = "#{error_message_tag} invalid type: #{type.grn_inspect}"
+          raise InvalidArgument, message
+        end
+      end
+
+      def parse_flags(flags_raw)
+        Column.parse_flags(error_message_tag, flags_raw)
+      end
+
+      def error_message_tag
+        "[logical_select][columns][#{@stage}][#{@label}]"
+      end
+    end
+  end
+end

data/vendor/local/lib/groonga/plugins/sharding/keys_parsable.rb

@@ -0,0 +1,12 @@
+module Groonga
+  module Sharding
+    module KeysParsable
+      private
+      def parse_keys(raw_keys)
+        return [] if raw_keys.nil?
+
+        raw_keys.strip.split(/ *, */)
+      end
+    end
+  end
+end

data/vendor/local/lib/groonga/plugins/sharding/logical_count.rb

@@ -14,13 +14,22 @@ module Groonga
 
       def run_body(input)
         enumerator = LogicalEnumerator.new("logical_count", input)
-        filter = input[:filter]
 
+        counter = Counter.new(input, enumerator.target_range)
         total = 0
+        have_shard = false
         enumerator.each do |shard, shard_range|
-          total += count_n_records(filter, shard, shard_range,
-                                   enumerator.target_range)
+          have_shard = true
+          total += counter.count(shard, shard_range)
         end
+        unless have_shard
+          message =
+            "[logical_count] no shard exists: " +
+            "logical_table: <#{enumerator.logical_table}>: " +
+            "shard_key: <#{enumerator.shard_key_name}>"
+          raise InvalidArgument, message
+        end
+        query_logger.log(:size, ":", "count(#{total})")
         writer.write(total)
       end
 
@@ -34,133 +43,167 @@ module Groonga
         key << "#{input[:max]}\0"
         key << "#{input[:max_border]}\0"
         key << "#{input[:filter]}\0"
+        dynamic_columns = DynamicColumns.parse(input)
+        key << dynamic_columns.cache_key
         key
       end
 
-      def log_use_range_index(use, table_name, line, method)
-        message = "[logical_count]"
-        if use
-          message << "[range-index]"
-        else
-          message << "[select]"
+      class Counter
+        def initialize(input, target_range)
+          @logger = Context.instance.logger
+          @filter = input[:filter]
+          @dynamic_columns = DynamicColumns.parse(input)
+          @target_range = target_range
         end
-        message << " <#{table_name}>"
-        Context.instance.logger.log(Logger::Level::DEBUG,
-                                    __FILE__,
-                                    line,
-                                    method.to_s,
-                                    message)
-      end
 
-      def count_n_records(filter, shard, shard_range, target_range)
-        cover_type = target_range.cover_type(shard_range)
-        return 0 if cover_type == :none
+        def count(shard, shard_range)
+          cover_type = @target_range.cover_type(shard_range)
+          return 0 if cover_type == :none
 
-        shard_key = shard.key
-        if shard_key.nil?
-          message = "[logical_count] shard_key doesn't exist: " +
-                    "<#{shard.key_name}>"
-          raise InvalidArgument, message
-        end
-        table = shard.table
-        table_name = shard.table_name
-
-        expression_builder = RangeExpressionBuilder.new(shard_key,
-                                                        target_range)
-        expression_builder.filter = filter
-        if cover_type == :all
-          log_use_range_index(false, table_name, __LINE__, __method__)
-          if filter.nil?
-            return table.size
-          else
-            return filtered_count_n_records(table) do |expression|
-              expression_builder.build_all(expression)
+          shard_key = shard.key
+          if shard_key.nil?
+            message = "[logical_count] shard_key doesn't exist: " +
+                      "<#{shard.key_name}>"
+            raise InvalidArgument, message
+          end
+          table_name = shard.table_name
+
+          prepare_table(shard) do |table|
+            if cover_type == :all
+              log_use_range_index(false, table_name, "covered",
+                                  __LINE__, __method__)
+              if @filter
+                return filtered_count_n_records(table, shard_key, cover_type)
+              else
+                return table.size
+              end
+            end
+
+            range_index = nil
+            if @filter
+              log_use_range_index(false, table_name, "need filter",
+                                  __LINE__, __method__)
+            else
+              index_info = shard_key.find_index(Operator::LESS)
+              range_index = index_info.index if index_info
+              if range_index
+                log_use_range_index(true, table_name, "range index is available",
+                                    __LINE__, __method__)
+              else
+                log_use_range_index(false, table_name, "no range index",
+                                    __LINE__, __method__)
+              end
+            end
+
+            if range_index
+              count_n_records_in_range(range_index, cover_type)
+            else
+              filtered_count_n_records(table, shard_key, cover_type)
             end
           end
         end
 
-        range_index = nil
-        if filter.nil?
-          index_info = shard_key.find_index(Operator::LESS)
-          if index_info
-            range_index = index_info.index
+        private
+        def log_use_range_index(use, table_name, reason, line, method)
+          message = "[logical_count]"
+          if use
+            message << "[range-index]"
+          else
+            message << "[select]"
           end
+          message << " <#{table_name}>: #{reason}"
+          @logger.log(Logger::Level::DEBUG,
+                      __FILE__,
+                      line,
+                      method.to_s,
+                      message)
         end
 
-        use_range_index = (!range_index.nil?)
-        log_use_range_index(use_range_index, table_name, __LINE__, __method__)
+        def prepare_table(shard)
+          table = shard.table
+          return yield(table) if @filter.nil?
 
-        case cover_type
-        when :partial_min
-          if range_index
-            count_n_records_in_range(range_index,
-                                     target_range.min, target_range.min_border,
-                                     nil, nil)
-          else
-            filtered_count_n_records(table) do |expression|
-              expression_builder.build_partial_min(expression)
+          @dynamic_columns.each_initial do |dynamic_column|
+            if table == shard.table
+              table = table.select_all
             end
+            dynamic_column.apply(table)
           end
-        when :partial_max
-          if range_index
-            count_n_records_in_range(range_index,
-                                     nil, nil,
-                                     target_range.max, target_range.max_border)
-          else
-            filtered_count_n_records(table) do |expression|
-              expression_builder.build_partial_max(expression)
-            end
+
+          begin
+            yield(table)
+          ensure
+            table.close if table != shard.table
           end
-        when :partial_min_and_max
-          if range_index
-            count_n_records_in_range(range_index,
-                                     target_range.min, target_range.min_border,
-                                     target_range.max, target_range.max_border)
-          else
-            filtered_count_n_records(table) do |expression|
+        end
+
+        def filtered_count_n_records(table, shard_key, cover_type)
+          expression = nil
+          filtered_table = nil
+
+          expression_builder = RangeExpressionBuilder.new(shard_key,
+                                                          @target_range)
+          expression_builder.filter = @filter
+          begin
+            expression = Expression.create(table)
+            case cover_type
+            when :all
+              expression_builder.build_all(expression)
+            when :partial_min
+              expression_builder.build_partial_min(expression)
+            when :partial_max
+              expression_builder.build_partial_max(expression)
+            when :partial_min_and_max
               expression_builder.build_partial_min_and_max(expression)
             end
+            filtered_table = table.select(expression)
+            filtered_table.size
+          ensure
+            filtered_table.close if filtered_table
+            expression.close if expression
           end
         end
-      end
 
-      def filtered_count_n_records(table)
-        expression = nil
-        filtered_table = nil
-
-        begin
-          expression = Expression.create(table)
-          yield(expression)
-          filtered_table = table.select(expression)
-          filtered_table.size
-        ensure
-          filtered_table.close if filtered_table
-          expression.close if expression
-        end
-      end
+        def count_n_records_in_range(range_index, cover_type)
+          case cover_type
+          when :partial_min
+            min = @target_range.min
+            min_border = @target_range.min_border
+            max = nil
+            max_bordre = nil
+          when :partial_max
+            min = nil
+            min_bordre = nil
+            max = @target_range.max
+            max_border = @target_range.max_border
+          when :partial_min_and_max
+            min = @target_range.min
+            min_border = @target_range.min_border
+            max = @target_range.max
+            max_border = @target_range.max_border
+          end
 
-      def count_n_records_in_range(range_index,
-                                   min, min_border, max, max_border)
-        flags = TableCursorFlags::BY_KEY
-        case min_border
-        when :include
-          flags |= TableCursorFlags::GE
-        when :exclude
-          flags |= TableCursorFlags::GT
-        end
-        case max_border
-        when :include
-          flags |= TableCursorFlags::LE
-        when :exclude
-          flags |= TableCursorFlags::LT
-        end
+          flags = TableCursorFlags::BY_KEY
+          case min_border
+          when :include
+            flags |= TableCursorFlags::GE
+          when :exclude
+            flags |= TableCursorFlags::GT
+          end
+          case max_border
+          when :include
+            flags |= TableCursorFlags::LE
+          when :exclude
+            flags |= TableCursorFlags::LT
+          end
 
-        TableCursor.open(range_index.table,
-                         :min => min,
-                         :max => max,
-                         :flags => flags) do |table_cursor|
-          IndexCursor.open(table_cursor, range_index) do |index_cursor|
-            index_cursor.count
+          TableCursor.open(range_index.table,
+                           :min => min,
+                           :max => max,
+                           :flags => flags) do |table_cursor|
+            IndexCursor.open(table_cursor, range_index) do |index_cursor|
+              index_cursor.count
+            end
           end
         end
       end