rroonga 6.1.3-x64-mingw32 → 7.0.2-x64-mingw32

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/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/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'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/functions'
+libdir='/build/dist-x64/lib/groonga/plugins/functions'

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/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/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'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/functions'
+libdir='/build/dist-x64/lib/groonga/plugins/functions'

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/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/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'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/functions'
+libdir='/build/dist-x64/lib/groonga/plugins/functions'

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/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/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'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/functions'
+libdir='/build/dist-x64/lib/groonga/plugins/functions'

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/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/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'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/normalizers'
+libdir='/build/dist-x64/lib/groonga/plugins/normalizers'

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/vagrant/dist-x64/lib /vagrant/dist-x64/lib/libgroonga.la -lmsgpackc /vagrant/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'
 
 # Names of additional weak libraries provided by this library
 weak_library_names=''
@@ -38,4 +38,4 @@ dlopen=''
 dlpreopen=''
 
 # Directory that this library needs to be installed in:
-libdir='/vagrant/dist-x64/lib/groonga/plugins/query_expanders'
+libdir='/build/dist-x64/lib/groonga/plugins/query_expanders'

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

@@ -66,8 +66,8 @@ module Groonga
         table_name = shard.table_name
 
         expression_builder = RangeExpressionBuilder.new(shard_key,
-                                                        target_range,
-                                                        filter)
+                                                        target_range)
+        expression_builder.filter = filter
         if cover_type == :all
           log_use_range_index(false, table_name, __LINE__, __method__)
           if filter.nil?

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

@@ -146,9 +146,9 @@ module Groonga
 
         def to_suffix
           if @day.nil?
-            "_%02d%02d" % [@year, @month]
+            "_%04d%02d" % [@year, @month]
           else
-            "_%02d%02d%02d" % [@year, @month, @day]
+            "_%04d%02d%02d" % [@year, @month, @day]
           end
         end
       end

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

@@ -211,8 +211,8 @@ module Groonga
           end
 
           expression_builder = RangeExpressionBuilder.new(shard_key,
-                                                          @target_range,
-                                                          @filter)
+                                                          @target_range)
+          expression_builder.filter = @filter
 
           index_info = shard_key.find_index(Operator::LESS)
           if index_info

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

@@ -10,17 +10,24 @@ module Groonga
                  "max",
                  "max_border",
                  "filter",
+                 # Deprecated since 6.1.5. Use sort_keys instead.
                  "sortby",
                  "output_columns",
                  "offset",
                  "limit",
                  "drilldown",
+                 # Deprecated since 6.1.5. Use drilldown_sort_keys instead.
                  "drilldown_sortby",
                  "drilldown_output_columns",
                  "drilldown_offset",
                  "drilldown_limit",
                  "drilldown_calc_types",
                  "drilldown_calc_target",
+                 "sort_keys",
+                 "drilldown_sort_keys",
+                 "match_columns",
+                 "query",
+                 "drilldown_filter",
                ])
 
       def run_body(input)
@@ -55,6 +62,9 @@ module Groonga
 
       private
       def cache_key(input)
+        sort_keys = input[:sort_keys] || input[:sortby]
+        drilldown_sort_keys =
+          input[:drilldown_sort_keys] || input[:drilldown_sortby]
         key = "logical_select\0"
         key << "#{input[:logical_table]}\0"
         key << "#{input[:shard_key]}\0"
@@ -63,17 +73,20 @@ module Groonga
         key << "#{input[:max]}\0"
         key << "#{input[:max_border]}\0"
         key << "#{input[:filter]}\0"
-        key << "#{input[:sortby]}\0"
+        key << "#{sort_keys}\0"
         key << "#{input[:output_columns]}\0"
         key << "#{input[:offset]}\0"
         key << "#{input[:limit]}\0"
         key << "#{input[:drilldown]}\0"
-        key << "#{input[:drilldown_sortby]}\0"
+        key << "#{drilldown_sort_keys}\0"
+        key << "#{input[:match_columns]}\0"
+        key << "#{input[:query]}\0"
         key << "#{input[:drilldown_output_columns]}\0"
         key << "#{input[:drilldown_offset]}\0"
         key << "#{input[:drilldown_limit]}\0"
         key << "#{input[:drilldown_calc_types]}\0"
         key << "#{input[:drilldown_calc_target]}\0"
+        key << "#{input[:drilldown_filter]}\0"
         labeled_drilldowns = LabeledDrilldowns.parse(input).sort_by(&:label)
         labeled_drilldowns.each do |drilldown|
           key << "#{drilldown.label}\0"
@@ -83,10 +96,33 @@ module Groonga
           key << "#{drilldown.limit}\0"
           key << "#{drilldown.calc_types}\0"
           key << "#{drilldown.calc_target_name}\0"
+          key << "#{drilldown.filter}\0"
+          cache_key_dynamic_columns(key, drilldown.dynamic_columns)
         end
+        dynamic_columns = DynamicColumns.parse(input)
+        cache_key_dynamic_columns(key, dynamic_columns)
         key
       end
 
+      def cache_key_dynamic_columns(key, dynamic_columns)
+        [
+          :initial,
+          :filtered,
+          :output
+        ].each do |stage|
+          target_dynamic_columns = dynamic_columns.__send__("each_#{stage}").to_a
+          target_dynamic_columns.sort_by(&:label).each do |dynamic_column|
+            key << "#{dynamic_column.label}\0"
+            key << "#{dynamic_column.stage}\0"
+            key << "#{dynamic_column.type}\0"
+            key << "#{dynamic_column.flags}\0"
+            key << "#{dynamic_column.value}\0"
+            key << "#{dynamic_column.window_sort_keys.join(',')}\0"
+            key << "#{dynamic_column.window_group_keys.join(',')}\0"
+          end
+        end
+      end
+
       def write_records(writer, context)
         result_sets = context.result_sets
 
@@ -191,6 +227,24 @@ module Groonga
         end
       end
 
+      class LabeledArgumentParser
+        def initialize(parameters)
+          @parameters = parameters
+        end
+
+        def parse(prefix_pattern)
+          pattern = /\A#{prefix_pattern}\[(.+?)\]\.(.+)\z/
+          labeled_arguments = {}
+          @parameters.each do |key, value|
+            match_data = pattern.match(key)
+            next if match_data.nil?
+            labeled_argument = (labeled_arguments[match_data[1]] ||= {})
+            labeled_argument[match_data[2]] = value
+          end
+          labeled_arguments
+        end
+      end
+
       module KeysParsable
         private
         def parse_keys(raw_keys)
@@ -237,29 +291,42 @@ module Groonga
         include KeysParsable
 
         attr_reader :enumerator
+        attr_reader :match_columns
+        attr_reader :query
         attr_reader :filter
         attr_reader :offset
         attr_reader :limit
         attr_reader :sort_keys
         attr_reader :output_columns
+        attr_reader :dynamic_columns
         attr_reader :result_sets
         attr_reader :unsorted_result_sets
         attr_reader :plain_drilldown
         attr_reader :labeled_drilldowns
+        attr_reader :temporary_tables
+        attr_reader :expressions
         def initialize(input)
           @input = input
           @enumerator = LogicalEnumerator.new("logical_select", @input)
+          @match_columns = @input[:match_columns]
+          @query = @input[:query]
           @filter = @input[:filter]
           @offset = (@input[:offset] || 0).to_i
           @limit = (@input[:limit] || 10).to_i
-          @sort_keys = parse_keys(@input[:sortby])
+          @sort_keys = parse_keys(@input[:sort_keys] || @input[:sortby])
           @output_columns = @input[:output_columns] || "_id, _key, *"
 
+          @dynamic_columns = DynamicColumns.parse(@input)
+
           @result_sets = []
           @unsorted_result_sets = []
 
           @plain_drilldown = PlainDrilldownExecuteContext.new(@input)
           @labeled_drilldowns = LabeledDrilldowns.parse(@input)
+
+          @temporary_tables = []
+
+          @expressions = []
         end
 
         def close
@@ -272,6 +339,150 @@ module Groonga
 
           @plain_drilldown.close
           @labeled_drilldowns.close
+
+          @dynamic_columns.close
+
+          @temporary_tables.each do |table|
+            table.close
+          end
+
+          @expressions.each do |expression|
+            expression.close
+          end
+        end
+      end
+
+      class DynamicColumns
+        class << self
+          def parse(input)
+            parser = LabeledArgumentParser.new(input)
+            columns = parser.parse(/columns?/)
+
+            initial_contexts = []
+            filtered_contexts = []
+            output_contexts = []
+            columns.each do |label, parameters|
+              contexts = nil
+              case parameters["stage"]
+              when "initial"
+                contexts = initial_contexts
+              when "filtered"
+                contexts = filtered_contexts
+              when "output"
+                contexts = output_contexts
+              else
+                next
+              end
+              contexts << DynamicColumnExecuteContext.new(label, parameters)
+            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 close
+          @initial_contexts.each do |context|
+            context.close
+          end
+          @filtered_contexts.each do |context|
+            context.close
+          end
+          @output_contexts.each do |context|
+            context.close
+          end
+        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, parameters)
+          @label = label
+          @stage = parameters["stage"]
+          @type = parse_type(parameters["type"])
+          @flags = parse_flags(parameters["flags"] || "COLUMN_SCALAR")
+          @value = parameters["value"]
+          @window_sort_keys = parse_keys(parameters["window.sort_keys"])
+          @window_group_keys = parse_keys(parameters["window.group_keys"])
+        end
+
+        def close
+        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
 
@@ -286,21 +497,30 @@ module Groonga
         attr_reader :output_columns
         attr_reader :calc_target_name
         attr_reader :calc_types
+        attr_reader :filter
         attr_reader :result_sets
         attr_reader :unsorted_result_sets
+        attr_reader :temporary_tables
+        attr_reader :expressions
         def initialize(input)
           @input = input
           @keys = parse_keys(@input[:drilldown])
           @offset = (@input[:drilldown_offset] || 0).to_i
           @limit = (@input[:drilldown_limit] || 10).to_i
-          @sort_keys = parse_keys(@input[:drilldown_sortby])
+          @sort_keys = parse_keys(@input[:drilldown_sort_keys] ||
+                                  @input[:drilldown_sortby])
           @output_columns = @input[:drilldown_output_columns]
           @output_columns ||= "_key, _nsubrecs"
           @calc_target_name = @input[:drilldown_calc_target]
           @calc_types = parse_calc_types(@input[:drilldown_calc_types])
+          @filter = @input[:drilldown_filter]
 
           @result_sets = []
           @unsorted_result_sets = []
+
+          @temporary_tables = []
+
+          @expressions = []
         end
 
         def close
@@ -310,6 +530,14 @@ module Groonga
           @unsorted_result_sets.each do |result_set|
             result_set.close
           end
+
+          @temporary_tables.each do |table|
+            table.close
+          end
+
+          @expressions.each do |expression|
+            expression.close
+          end
         end
 
         def have_keys?
@@ -323,27 +551,19 @@ module Groonga
 
       class LabeledDrilldowns
         include Enumerable
+        include TSort
 
         class << self
           def parse(input)
-            drilldowns = {}
-            arguments = input.arguments
-            argument = Record.new(arguments, nil)
-            arguments.each do |argument_id|
-              argument.id = argument_id
-              key = argument.key
-              match_data = /\Adrilldown\[(.+?)\]\.(.+)\z/.match(key)
-              next if match_data.nil?
-              drilldown = (drilldowns[match_data[1]] ||= {})
-              drilldown[match_data[2]] = input[key]
-            end
+            parser = LabeledArgumentParser.new(input)
+            drilldowns = parser.parse(/drilldowns?/)
 
-            contexts = []
+            contexts = {}
             drilldowns.each do |label, parameters|
               next if parameters["keys"].nil?
-              contexts << LabeledDrilldownExecuteContext.new(label, parameters)
+              context = LabeledDrilldownExecuteContext.new(label, parameters)
+              contexts[label] = context
             end
-            return nil if contexts.nil?
 
             new(contexts)
           end
@@ -351,16 +571,32 @@ module Groonga
 
         def initialize(contexts)
           @contexts = contexts
+          @dependencies = {}
+          @contexts.each do |label, context|
+            if context.table
+              depended_context = @contexts[context.table]
+              if depended_context.nil?
+                raise "Unknown drilldown: <#{context.table}>"
+              end
+              @dependencies[label] = [depended_context]
+            else
+              @dependencies[label] = []
+            end
+          end
         end
 
         def close
-          @contexts.each do |context|
+          @contexts.each_value do |context|
             context.close
           end
         end
 
+        def [](label)
+          @contexts[label]
+        end
+
         def have_keys?
-          @contexts.size > 0
+          not @contexts.empty?
         end
 
         def n_result_sets
@@ -368,7 +604,15 @@ module Groonga
         end
 
         def each(&block)
-          @contexts.each(&block)
+          @contexts.each_value(&block)
+        end
+
+        def tsort_each_node(&block)
+          @contexts.each_value(&block)
+        end
+
+        def tsort_each_child(context, &block)
+          @dependencies[context.label].each(&block)
         end
       end
 
@@ -384,26 +628,50 @@ module Groonga
         attr_reader :output_columns
         attr_reader :calc_target_name
         attr_reader :calc_types
+        attr_reader :filter
+        attr_reader :table
+        attr_reader :dynamic_columns
         attr_accessor :result_set
         attr_accessor :unsorted_result_set
+        attr_reader :temporary_tables
+        attr_reader :expressions
         def initialize(label, parameters)
           @label = label
           @keys = parse_keys(parameters["keys"])
           @offset = (parameters["offset"] || 0).to_i
           @limit = (parameters["limit"] || 10).to_i
-          @sort_keys = parse_keys(parameters["sortby"])
+          @sort_keys = parse_keys(parameters["sort_keys"] ||
+                                  parameters["sortby"])
           @output_columns = parameters["output_columns"]
           @output_columns ||= "_key, _nsubrecs"
           @calc_target_name = parameters["calc_target"]
           @calc_types = parse_calc_types(parameters["calc_types"])
+          @filter = parameters["filter"]
+          @table = parameters["table"]
+
+          @dynamic_columns = DynamicColumns.parse(parameters)
 
           @result_set = nil
           @unsorted_result_set = nil
+
+          @temporary_tables = []
+
+          @expressions = []
         end
 
         def close
           @result_set.close if @result_set
           @unsorted_result_set.close if @unsorted_result_set
+
+          @dynamic_columns.close
+
+          @temporary_tables.each do |table|
+            table.close
+          end
+
+          @expressions.each do |expression|
+            expression.close
+          end
         end
 
         def need_command_version2?
@@ -462,6 +730,12 @@ module Groonga
           if @context.result_sets.empty?
             result_set = HashTable.create(:flags => ObjectFlags::WITH_SUBREC,
                                           :key_type => first_shard.table)
+            @context.dynamic_columns.each_initial do |dynamic_column|
+              dynamic_column.apply(result_set)
+            end
+            @context.dynamic_columns.each_filtered do |dynamic_column|
+              dynamic_column.apply(result_set)
+            end
             @context.result_sets << result_set
           end
         end
@@ -482,6 +756,7 @@ module Groonga
                 end
               end
               result_set = group_result.table
+              result_set = apply_drilldown_filter(drilldown, result_set)
               if drilldown.sort_keys.empty?
                 drilldown.result_sets << result_set
               else
@@ -498,7 +773,7 @@ module Groonga
         def execute_labeled_drilldowns
           drilldowns = @context.labeled_drilldowns
 
-          drilldowns.each do |drilldown|
+          drilldowns.tsort_each do |drilldown|
             group_result = TableGroupResult.new
             keys = drilldown.keys
             begin
@@ -509,13 +784,25 @@ module Groonga
               end
               group_result.limit = 1
               group_result.flags = drilldown.calc_types
-              @context.result_sets.each do |result_set|
+              if drilldown.table
+                target_table = drilldowns[drilldown.table].result_set
                 with_calc_target(group_result,
-                                 drilldown.calc_target(result_set)) do
-                  result_set.group(keys, group_result)
+                                 drilldown.calc_target(target_table)) do
+                  target_table.group(keys, group_result)
+                end
+              else
+                @context.result_sets.each do |result_set|
+                  with_calc_target(group_result,
+                                   drilldown.calc_target(result_set)) do
+                    result_set.group(keys, group_result)
+                  end
                 end
               end
               result_set = group_result.table
+              drilldown.dynamic_columns.each_initial do |dynamic_column|
+                dynamic_column.apply(result_set)
+              end
+              result_set = apply_drilldown_filter(drilldown, result_set)
               if drilldown.sort_keys.empty?
                 drilldown.result_set = result_set
               else
@@ -538,6 +825,18 @@ module Groonga
             group_result.calc_target = nil
           end
         end
+
+        def apply_drilldown_filter(drilldown, result_set)
+          filter = drilldown.filter
+          return result_set if filter.nil?
+
+          expression = Expression.create(result_set)
+          drilldown.expressions << expression
+          expression.parse(filter)
+          filtered_result_set = result_set.select(expression)
+          drilldown.temporary_tables << result_set
+          filtered_result_set
+        end
       end
 
       class ShardExecutor
@@ -546,6 +845,10 @@ module Groonga
           @shard = shard
           @shard_range = shard_range
 
+          @target_table = @shard.table
+
+          @match_columns = @context.match_columns
+          @query = @context.query
           @filter = @context.filter
           @sort_keys = @context.sort_keys
           @result_sets = @context.result_sets
@@ -558,7 +861,7 @@ module Groonga
 
         def execute
           return if @cover_type == :none
-          return if @shard.table.empty?
+          return if @target_table.empty?
 
           shard_key = @shard.key
           if shard_key.nil?
@@ -567,31 +870,39 @@ module Groonga
             raise InvalidArgument, message
           end
 
-          expression_builder = RangeExpressionBuilder.new(shard_key,
-                                                          @target_range,
-                                                          @filter)
-          case @cover_type
-          when :all
-            filter_shard_all(expression_builder)
-          when :partial_min
-            filter_table do |expression|
-              expression_builder.build_partial_min(expression)
+          @context.dynamic_columns.each_initial do |dynamic_column|
+            if @target_table == @shard.table
+              @target_table = create_all_match_table(@target_table)
+              @context.temporary_tables << @target_table
             end
-          when :partial_max
-            filter_table do |expression|
-              expression_builder.build_partial_max(expression)
-            end
-          when :partial_min_and_max
-            filter_table do |expression|
-              expression_builder.build_partial_min_and_max(expression)
+            dynamic_column.apply(@target_table)
+          end
+
+          create_expression_builder(shard_key) do |expression_builder|
+            case @cover_type
+            when :all
+              filter_shard_all(expression_builder)
+            when :partial_min
+              filter_table do |expression|
+                expression_builder.build_partial_min(expression)
+              end
+            when :partial_max
+              filter_table do |expression|
+                expression_builder.build_partial_max(expression)
+              end
+            when :partial_min_and_max
+              filter_table do |expression|
+                expression_builder.build_partial_min_and_max(expression)
+              end
             end
           end
         end
 
         private
         def filter_shard_all(expression_builder)
-          if @filter.nil?
-            add_result_set(@shard.table)
+          if @query.nil? and @filter.nil?
+            add_result_set(@target_table, nil)
+            @context.temporary_tables.delete(@target_table)
           else
             filter_table do |expression|
               expression_builder.build_all(expression)
@@ -601,27 +912,45 @@ module Groonga
 
         def create_expression(table)
           expression = Expression.create(table)
+          @context.expressions << expression
+          expression
+        end
+
+        def create_expression_builder(shard_key)
+          expression_builder = RangeExpressionBuilder.new(shard_key,
+                                                          @target_range)
+          expression_builder.match_columns = @match_columns
+          expression_builder.query = @query
+          expression_builder.filter = @filter
           begin
-            yield(expression)
+            yield(expression_builder)
           ensure
-            expression.close
+            expression = expression_builder.match_columns_expression
+            @context.expressions << expression if expression
           end
         end
 
         def filter_table
-          table = @shard.table
-          create_expression(table) do |expression|
-            yield(expression)
-            add_result_set(table.select(expression))
-          end
+          table = @target_table
+          expression = create_expression(table)
+          yield(expression)
+          add_result_set(table.select(expression), expression)
         end
 
-        def add_result_set(result_set)
+        def add_result_set(result_set, condition)
           if result_set.empty?
             result_set.close
             return
           end
 
+          @context.dynamic_columns.each_filtered do |dynamic_column|
+            if result_set == @shard.table
+              @context.temporary_tables << result_set
+              result_set = create_all_match_table(result_set)
+            end
+            dynamic_column.apply(result_set, condition)
+          end
+
           if @sort_keys.empty?
             @result_sets << result_set
           else
@@ -630,6 +959,16 @@ module Groonga
             @result_sets << sorted_result_set
           end
         end
+
+        def create_all_match_table(table)
+          expression = Expression.create(table)
+          begin
+            expression.append_constant(true, Operator::PUSH, 1)
+            table.select(expression)
+          ensure
+            expression.close
+          end
+        end
       end
     end
   end