rroonga 7.1.1-x64-mingw32 → 9.0.2-x64-mingw32

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

@@ -10,6 +10,7 @@ module Groonga
                  "max",
                  "max_border",
                  "filter",
+                 "post_filter",
                ])
 
       def run_body(input)
@@ -18,9 +19,14 @@ module Groonga
         counter = Counter.new(input, enumerator.target_range)
         total = 0
         have_shard = false
-        enumerator.each do |shard, shard_range|
-          have_shard = true
-          total += counter.count(shard, shard_range)
+        begin
+          enumerator.each do |shard, shard_range|
+            have_shard = true
+            counter.count_pre(shard, shard_range)
+          end
+          total += counter.count
+        ensure
+          counter.close
         end
         unless have_shard
           message =
@@ -43,22 +49,40 @@ module Groonga
         key << "#{input[:max]}\0"
         key << "#{input[:max_border]}\0"
         key << "#{input[:filter]}\0"
+        key << "#{input[:post_filter]}\0"
         dynamic_columns = DynamicColumns.parse(input)
         key << dynamic_columns.cache_key
         key
       end
 
+      class ShardCountContext
+        attr_reader :shard
+        attr_reader :cover_type
+        attr_reader :range_index
+        attr_accessor :table
+        def initialize(shard, cover_type, range_index)
+          @shard = shard
+          @cover_type = cover_type
+          @range_idnex = range_index
+          @table = shard.table
+        end
+      end
+
       class Counter
         def initialize(input, target_range)
           @logger = Context.instance.logger
           @filter = input[:filter]
+          @post_filter = input[:post_filter]
           @dynamic_columns = DynamicColumns.parse(input)
           @target_range = target_range
+          @contexts = []
+          @temporary_tables = []
+          @temporary_expressions = []
         end
 
-        def count(shard, shard_range)
+        def count_pre(shard, shard_range)
           cover_type = @target_range.cover_type(shard_range)
-          return 0 if cover_type == :none
+          return if cover_type == :none
 
           shard_key = shard.key
           if shard_key.nil?
@@ -66,41 +90,41 @@ module Groonga
                       "<#{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",
+          table_name = shard.table_name
+          range_index = nil
+          if @filter or @post_filter
+            log_use_range_index(false, table_name, "need filter",
+                                __LINE__, __method__)
+          elsif cover_type == :all
+            log_use_range_index(false, table_name, "covered",
+                                __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
-              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
+              log_use_range_index(false, table_name, "no range index",
+                                  __LINE__, __method__)
             end
+          end
+          @contexts << ShardCountContext.new(shard, cover_type, range_index)
+        end
 
-            if range_index
-              count_n_records_in_range(range_index, cover_type)
-            else
-              filtered_count_n_records(table, shard_key, cover_type)
-            end
+        def count
+          prepare_contexts
+          total = 0
+          @contexts.each do |context|
+            total += count_shard(context)
           end
+          total
+        end
+
+        def close
+          @temporary_tables.each(&:close)
+          @temporary_expressions.each(&:close)
         end
 
         private
@@ -119,34 +143,51 @@ module Groonga
                       message)
         end
 
-        def prepare_table(shard)
-          table = shard.table
-          return yield(table) if @filter.nil?
-
-          @dynamic_columns.each_initial do |dynamic_column|
-            if table == shard.table
-              table = table.select_all
+        def prepare_contexts
+          if @filter or @post_filter
+            if @dynamic_columns.have_initial?
+              apply_targets = []
+              @contexts.each do |context|
+                table = context.table.select_all
+                @temporary_tables << table
+                context.table = table
+                apply_targets << [table]
+              end
+              @dynamic_columns.apply_initial(apply_targets)
             end
-            dynamic_column.apply(table)
           end
-
-          begin
-            yield(table)
-          ensure
-            table.close if table != shard.table
+          @contexts.each do |context|
+            filter_shard(context)
+          end
+          if @post_filter
+            if @dynamic_columns.have_filtered?
+              apply_targets = @contexts.collect do |context|
+                [context.table]
+              end
+              @dynamic_columns.apply_filtered(apply_targets)
+            end
+            @contexts.each do |context|
+              post_filter_shard(context)
+            end
           end
         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
+        def filter_shard(context)
+          return if context.range_index
+
+          if context.cover_type == :all and @filter.nil?
+            if @post_filter and @dynamic_columns.have_filtered?
+              filtered_table = context.table.select_all
+              @temporary_tables << filtered_table
+              context.table = filtered_table
+            end
+          else
+            expression = Expression.create(context.table)
+            @temporary_expressions << expression
+            expression_builder = RangeExpressionBuilder.new(context.shard.key,
+                                                            @target_range)
+            expression_builder.filter = @filter
+            case context.cover_type
             when :all
               expression_builder.build_all(expression)
             when :partial_min
@@ -156,16 +197,33 @@ module Groonga
             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
+            filtered_table = context.table.select(expression)
+            @temporary_tables << filtered_table
+            context.table = filtered_table
           end
         end
 
-        def count_n_records_in_range(range_index, cover_type)
-          case cover_type
+        def count_shard(context)
+          if context.range_index
+            count_n_records_in_range(context)
+          else
+            context.table.size
+          end
+        end
+
+        def post_filter_shard(context)
+          expression = nil
+          post_filtered_table = nil
+          expression = Expression.create(context.table)
+          @temporary_expressions << expression
+          expression.parse(@post_filter)
+          filtered_table = context.table.select(expression)
+          @temporary_tables << filtered_table
+          context.table = filtered_table
+        end
+
+        def count_n_records_in_range(context)
+          case context.cover_type
           when :partial_min
             min = @target_range.min
             min_border = @target_range.min_border
@@ -197,7 +255,7 @@ module Groonga
             flags |= TableCursorFlags::LT
           end
 
-          TableCursor.open(range_index.table,
+          TableCursor.open(context.range_index.table,
                            :min => min,
                            :max => max,
                            :flags => flags) do |table_cursor|

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

@@ -16,6 +16,7 @@ module Groonga
                  "output_columns",
                  "use_range_index",
                  "post_filter",
+                 "sort_keys",
                ])
 
       def run_body(input)
@@ -73,26 +74,30 @@ module Groonga
         key << "#{input[:output_columns]}\0"
         key << "#{input[:use_range_index]}\0"
         key << "#{input[:post_filter]}\0"
+        key << "#{input[:sort_keys]}\0"
         dynamic_columns = DynamicColumns.parse(input)
         key << dynamic_columns.cache_key
         key
       end
 
       class ExecuteContext
+        include KeysParsable
+
         attr_reader :use_range_index
         attr_reader :enumerator
         attr_reader :order
         attr_reader :filter
         attr_reader :offset
         attr_reader :limit
+        attr_reader :post_filter
+        attr_reader :sort_keys
         attr_reader :dynamic_columns
         attr_accessor :current_offset
         attr_accessor :current_limit
         attr_reader :result_sets
-        attr_reader :unsorted_result_sets
         attr_reader :temporary_tables
         attr_reader :threshold
-        attr_reader :post_filter
+        attr_reader :time_classify_types
         def initialize(input)
           @input = input
           @use_range_index = parse_use_range_index(@input[:use_range_index])
@@ -101,34 +106,34 @@ module Groonga
           @filter = @input[:filter]
           @offset = (@input[:offset] || 0).to_i
           @limit = (@input[:limit] || 10).to_i
+          @post_filter = @input[:post_filter]
+          @sort_keys = parse_keys(@input[:sort_keys])
+
           @dynamic_columns = DynamicColumns.parse(@input)
 
           @current_offset = @offset
           @current_limit = @limit
 
           @result_sets = []
-          @unsorted_result_sets = []
-
           @temporary_tables = []
 
           @threshold = compute_threshold
 
-          @post_filter = @input[:post_filter]
+          @time_classify_types = detect_time_classify_types
         end
 
         def close
-          @unsorted_result_sets.each do |result_set|
-            result_set.close if result_set.temporary?
-          end
-          @result_sets.each do |result_set|
-            result_set.close if result_set.temporary?
-          end
-
           @temporary_tables.each do |table|
             table.close
           end
         end
 
+        def need_look_ahead?
+          return false unless @dynamic_columns.have_window_function?
+          return false unless @time_classify_types.empty?
+          true
+        end
+
         private
         def parse_use_range_index(use_range_index)
           case use_range_index
@@ -163,6 +168,33 @@ module Groonga
           default_threshold = 0.2
           (threshold_env || default_threshold).to_f
         end
+
+        def detect_time_classify_types
+          window_group_keys = []
+          @dynamic_columns.each_filtered do |dynamic_column|
+            window_group_keys.concat(dynamic_column.window_group_keys)
+          end
+          return [] if window_group_keys.empty?
+
+          types = []
+          @dynamic_columns.each do |dynamic_column|
+            next unless window_group_keys.include?(dynamic_column.label)
+            case dynamic_column.value.strip
+            when /\Atime_classify_(.+?)\s*\(\s*([a-zA-Z\d_]+)\s*[,)]/
+              type = $1
+              column = $2
+              next if column != @enumerator.shard_key_name
+
+              case type
+              when "minute", "second"
+                types << type
+              when "day", "hour"
+                types << type
+              end
+            end
+          end
+          types
+        end
       end
 
       class Executor
@@ -172,20 +204,13 @@ module Groonga
 
         def execute
           first_shard = nil
-          enumerator = @context.enumerator
-          target_range = enumerator.target_range
-          if @context.order == :descending
-            each_method = :reverse_each
-          else
-            each_method = :each
-          end
-          enumerator.send(each_method) do |shard, shard_range|
-            first_shard ||= shard
-            shard_executor = ShardExecutor.new(@context, shard, shard_range)
+          each_shard_executor do |shard_executor|
+            first_shard ||= shard_executor.shard
             shard_executor.execute
-            break if @context.current_limit == 0
+            break if @context.current_limit.zero?
           end
           if first_shard.nil?
+            enumerator = @context.enumerator
             message =
               "[logical_range_filter] no shard exists: " +
               "logical_table: <#{enumerator.logical_table}>: " +
@@ -195,82 +220,411 @@ 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)
+            @context.temporary_tables << result_set
+            targets = [[result_set]]
+            @context.dynamic_columns.apply_initial(targets)
+            @context.dynamic_columns.apply_filtered(targets)
+            @context.result_sets << result_set
+          end
+        end
+
+        private
+        def each_shard_executor(&block)
+          enumerator = @context.enumerator
+          target_range = enumerator.target_range
+          if @context.order == :descending
+            each_method = :reverse_each
+          else
+            each_method = :each
+          end
+          if @context.need_look_ahead?
+            executors = []
+            previous_executor = nil
+            enumerator.send(each_method) do |shard, shard_range|
+              current_executor = ShardExecutor.new(@context, shard, shard_range)
+              if previous_executor
+                previous_executor.next_executor = current_executor
+                current_executor.previous_executor = previous_executor
+                executors << previous_executor
+              end
+              previous_executor = current_executor
             end
-            @context.dynamic_columns.each_filtered do |dynamic_column|
-              dynamic_column.apply(result_set)
+            executors << previous_executor if previous_executor
+            executors.each(&block)
+          else
+            enumerator.send(each_method) do |shard, shard_range|
+              yield(ShardExecutor.new(@context, shard, shard_range))
             end
-            @context.result_sets << result_set
           end
         end
       end
 
+      class Window
+        include Comparable
+
+        attr_reader :unit
+        attr_reader :step
+        def initialize(context, shard, shard_range, unit, step)
+          @context = context
+          @shard = shard
+          @shard_range = shard_range
+          @unit = unit
+          @step = step
+
+          @between = Groonga::Context.instance["between"]
+
+          @target_range = @context.enumerator.target_range
+
+          case @unit
+          when :day
+            @step_second = (60 * 60 * 24) * @step
+          when :hour
+            @step_second = (60 * 60) * @step
+          else
+            raise InvalidArgument "Unexpected unit: #{@unit.inspect}"
+          end
+        end
+
+        def <=>(other)
+          case @unit
+          when other.unit
+            @step <=> other.unit
+          when :day # @unit == :day && other.unit == :hour
+            1
+          else # @unit == :hour && other.unit == :day
+            -1
+          end
+        end
+
+        def each(table)
+          min = create_min_edge
+          max = create_max_edge(min)
+          shard_key = table.find_column(@context.enumerator.shard_key_name)
+          begin
+            current_min = min
+            while current_min < max do
+              next_min = compute_next_min_edge(current_min)
+              if next_min > max
+                current_max = max
+              else
+                current_max = WindowEdge.new(next_min.year,
+                                             next_min.month,
+                                             next_min.day,
+                                             next_min.hour,
+                                             next_min.minute,
+                                             next_min.second,
+                                             next_min.microsecond,
+                                             :exclude)
+              end
+              windowed_table = select_by_range(table,
+                                               shard_key,
+                                               current_min,
+                                               current_max)
+              if windowed_table.empty?
+                windowed_table.close
+              else
+                message = "[logical_range_filter][window] "
+                message << "<#{@shard.table_name}>: "
+                message << inspect_range(current_min, current_max)
+                Context.instance.logger.log(Logger::Level::DEBUG,
+                                            __FILE__,
+                                            __LINE__,
+                                            __method__.to_s,
+                                            message)
+                yield(windowed_table)
+              end
+              current_min = next_min
+            end
+          ensure
+            shard_key.close
+          end
+        end
+
+        private
+        def create_min_edge
+          min = @target_range.min
+          if min
+            year = min.year
+            month = min.month
+            day = min.day
+            hour = min.hour
+            minute = min.min
+            second = min.sec
+            microsecond = min.usec
+            border = @target_range.min_border
+          else
+            year = @shard_range.year
+            month = @shard_range.month
+            day = 1
+            hour = 0
+            minute = 0
+            second = 0
+            microsecond = 0
+            border = :include
+          end
+          WindowEdge.new(year, month, day, hour, minute, second, microsecond,
+                         border)
+        end
+
+        def create_max_edge(min)
+          max = @target_range.max
+          if max
+            year = max.year
+            month = max.month
+            day = max.day
+            hour = max.hour
+            minute = max.min
+            second = max.sec
+            microsecond = max.usec
+            border = @target_range.max_border
+          else
+            next_shard_edge = @shard_range.least_over_time
+            year = next_shard_edge.year
+            month = next_shard_edge.month
+            day = next_shard_edge.day
+            hour = 0
+            minute = 0
+            second = 0
+            microsecond = 0
+            border = :exclude
+          end
+          WindowEdge.new(year, month, day, hour, minute, second, microsecond,
+                         border)
+        end
+
+        def compute_next_min_edge(current_min)
+          next_edge = Time.at(current_min.to_time.to_i + @step_second)
+          year = next_edge.year
+          month = next_edge.month
+          day = next_edge.day
+          if @unit == :day
+            hour = 0
+          else
+            hour = next_edge.hour
+          end
+          minute = 0
+          second = 0
+          microsecond = 0
+          border = :include
+          WindowEdge.new(year, month, day, hour, minute, second, microsecond,
+                         border)
+        end
+
+        def select_by_range(table, shard_key, min, max)
+          expression = Expression.create(table)
+          begin
+            expression.append_object(@between, Operator::PUSH, 1)
+            expression.append_object(shard_key, Operator::PUSH, 1)
+            expression.append_operator(Operator::GET_VALUE, 1)
+            expression.append_constant(min.to_s, Operator::PUSH, 1)
+            expression.append_constant(min.border, Operator::PUSH, 1)
+            expression.append_constant(max.to_s, Operator::PUSH, 1)
+            expression.append_constant(max.border, Operator::PUSH, 1)
+            expression.append_operator(Operator::CALL, 5)
+            table.select(expression)
+          ensure
+            expression.close
+          end
+        end
+
+        def inspect_range(min, max)
+          range = ""
+          if min.border == :include
+            range << "["
+          else
+            range << "("
+          end
+          range << min.to_s
+          range << ","
+          range << max.to_s
+          if max.border == :include
+            range << "]"
+          else
+            range << ")"
+          end
+          range
+        end
+      end
+
+      class WindowEdge
+        include Comparable
+
+        attr_reader :year
+        attr_reader :month
+        attr_reader :day
+        attr_reader :hour
+        attr_reader :minute
+        attr_reader :second
+        attr_reader :microsecond
+        attr_reader :border
+        def initialize(year, month, day, hour, minute, second, microsecond,
+                       border)
+          @year = year
+          @month = month
+          @day = day
+          @hour = hour
+          @minute = minute
+          @second = second
+          @microsecond = microsecond
+          @border = border
+        end
+
+        def to_s
+          format = "%04d/%02d/%02d %02d:%02d:%02d"
+          format_values = [@year, @month, @day, @hour, @minute, @second]
+          unless @microsecond.zero?
+            format << ".%06d"
+            format_values << @microsecond
+          end
+          format % format_values
+        end
+
+        def to_time
+          Time.local(@year, @month, @day, @hour, @minute, @second, @microsecond)
+        end
+
+        def values
+          [@year, @month, @day, @hour, @minute, @second, @microsecond]
+        end
+
+        def <=>(other)
+          (values + [@border == :include ? 1 : 0]) <=>
+            (other.values + [other.border == :include ? 1 : 0])
+        end
+      end
+
       class ShardExecutor
+        attr_reader :shard
+        attr_writer :previous_executor
+        attr_writer :next_executor
         def initialize(context, shard, shard_range)
           @context = context
           @shard = shard
           @shard_range = shard_range
 
+          @shard_key = shard.key
           @target_table = @shard.table
 
           @filter = @context.filter
           @post_filter = @context.post_filter
           @result_sets = @context.result_sets
-          @unsorted_result_sets = @context.unsorted_result_sets
+          @filtered_result_sets = []
+          @temporary_tables = @context.temporary_tables
 
           @target_range = @context.enumerator.target_range
 
           @cover_type = @target_range.cover_type(@shard_range)
+
+          @previous_executor = nil
+          @next_executor = nil
+
+          @initital_table = nil
+
+          @range_index = nil
+          @window = nil
+
+          @prepared = false
+          @filtered = false
         end
 
         def execute
-          return if @cover_type == :none
-          return if @target_table.empty?
+          ensure_filtered
+
+          return if @filtered_result_sets.empty?
+
+          if @window
+            @filtered_result_sets.each do |result_set|
+              @window.each(result_set) do |windowed_result_set|
+                @temporary_tables << windowed_result_set
+                if @context.dynamic_columns.have_filtered?
+                  apply_targets = [[windowed_result_set]]
+                  @context.dynamic_columns.apply_filtered(apply_targets)
+                end
+                sort_result_set(windowed_result_set)
+                return if @context.current_limit.zero?
+              end
+            end
+          else
+            apply_targets = []
+            if @previous_executor
+              @previous_executor.add_filtered_stage_context(apply_targets)
+            end
+            @filtered_result_sets.each do |result_set|
+              apply_targets << [result_set]
+            end
+            if @next_executor
+              @next_executor.add_filtered_stage_context(apply_targets)
+            end
+            options = {}
+            if @context.need_look_ahead?
+              options[:normal] = false
+            end
+            @context.dynamic_columns.apply_filtered(apply_targets, options)
+            @filtered_result_sets.each do |result_set|
+              sort_result_set(result_set)
+            end
+          end
+        end
 
-          shard_key = @shard.key
-          if shard_key.nil?
+        def add_initial_stage_context(apply_targets)
+          ensure_prepared
+          return unless @initial_table
+          apply_targets << [@initial_table, {context: true}]
+        end
+
+        def add_filtered_stage_context(apply_targets)
+          ensure_filtered
+          @filtered_result_sets.each do |table|
+            apply_targets << [table, {context: true}]
+          end
+        end
+
+        private
+        def have_record?
+          return false if @cover_type == :none
+          return false if @target_table.empty?
+          true
+        end
+
+        def ensure_prepared
+          return if @prepared
+          @prepared = true
+
+          return unless have_record?
+
+          if @shard_key.nil?
             message = "[logical_range_filter] shard_key doesn't exist: " +
                       "<#{@shard.key_name}>"
             raise InvalidArgument, message
           end
 
-          expression_builder = RangeExpressionBuilder.new(shard_key,
-                                                          @target_range)
-          expression_builder.filter = @filter
-
-          index_info = shard_key.find_index(Operator::LESS)
-          if index_info
-            range_index = index_info.index
-            unless use_range_index?(range_index, expression_builder)
-              range_index = nil
-            end
-          else
-            range_index = nil
+          @expression_builder = RangeExpressionBuilder.new(@shard_key,
+                                                           @target_range)
+          @expression_builder.filter = @filter
+          index_info = @shard_key.find_index(Operator::LESS)
+          if index_info and use_range_index?
+            @range_index = index_info.index
           end
 
-          @context.dynamic_columns.each_initial do |dynamic_column|
-            if @target_table == @shard.table
-              if @cover_type == :all
-                @target_table = @target_table.select_all
-              else
-                expression_builder.filter = nil
-                @target_table = create_expression(@target_table) do |expression|
-                  expression_builder.build(expression, @shard_range)
-                  @target_table.select(expression)
-                end
-                @cover_type = :all
-                expression_builder.filter = @filter
+          if @context.dynamic_columns.have_initial?
+            if @cover_type == :all
+              @target_table = @target_table.select_all
+            else
+              @expression_builder.filter = nil
+              @target_table = create_expression(@target_table) do |expression|
+                @expression_builder.build(expression, @shard_range)
+                @target_table.select(expression)
               end
-              @context.temporary_tables << @target_table
+              @expression_builder.filter = @filter
+              @cover_type = :all
             end
-            dynamic_column.apply(@target_table)
+            @temporary_tables << @target_table
+            @initial_table = @target_table
           end
 
-          execute_filter(range_index, expression_builder)
+          @window = detect_window
         end
 
-        private
         def decide_use_range_index(use, reason, line, method)
           message = "[logical_range_filter]"
           if use
@@ -289,7 +643,7 @@ module Groonga
           use
         end
 
-        def use_range_index?(range_index, expression_builder)
+        def use_range_index?
           use_range_index_parameter_message =
             "force by use_range_index parameter"
           case @context.use_range_index
@@ -326,6 +680,11 @@ module Groonga
             return decide_use_range_index(false, reason, __LINE__, __method__)
           end
 
+          unless @context.sort_keys.empty?
+            reason = "sort_keys is used"
+            return decide_use_range_index(false, reason, __LINE__, __method__)
+          end
+
           current_limit = @context.current_limit
           if current_limit < 0
             reason = "limit is negative: <#{current_limit}>"
@@ -360,7 +719,7 @@ module Groonga
           when :all
             if @filter
               create_expression(table) do |expression|
-                expression_builder.build_all(expression)
+                @expression_builder.build_all(expression)
                 unless range_index_available_expression?(expression,
                                                          __LINE__, __method__)
                   return false
@@ -372,7 +731,7 @@ module Groonga
             end
           when :partial_min
             create_expression(table) do |expression|
-              expression_builder.build_partial_min(expression)
+              @expression_builder.build_partial_min(expression)
               unless range_index_available_expression?(expression,
                                                        __LINE__, __method__)
                 return false
@@ -381,7 +740,7 @@ module Groonga
             end
           when :partial_max
             create_expression(table) do |expression|
-              expression_builder.build_partial_max(expression)
+              @expression_builder.build_partial_max(expression)
               unless range_index_available_expression?(expression,
                                                        __LINE__, __method__)
                 return false
@@ -390,7 +749,7 @@ module Groonga
             end
           when :partial_min_and_max
             create_expression(table) do |expression|
-              expression_builder.build_partial_min_and_max(expression)
+              @expression_builder.build_partial_min_and_max(expression)
               unless range_index_available_expression?(expression,
                                                        __LINE__, __method__)
                 return false
@@ -463,65 +822,102 @@ module Groonga
           nil
         end
 
-        def execute_filter(range_index, expression_builder)
+        def ensure_filtered
+          return if @filtered
+
+          @filtered = true
+
+          ensure_prepared
+          return unless have_record?
+
+          if @context.dynamic_columns.have_initial?
+            apply_targets = []
+            if @previous_executor
+              @previous_executor.add_initial_stage_context(apply_targets)
+            end
+            apply_targets << [@target_table]
+            if @next_executor
+              @next_executor.add_initial_stage_context(apply_targets)
+            end
+            @context.dynamic_columns.apply_initial(apply_targets)
+          end
+
+          execute_filter(@range_index)
+
+          return unless @context.need_look_ahead?
+
+          apply_targets = []
+          @filtered_result_sets = @filtered_result_sets.collect do |result_set|
+            if result_set == @shard.table
+              result_set = result_set.select_all
+              @temporary_tables << result_set
+            end
+            apply_targets << [result_set]
+            result_set
+          end
+          @context.dynamic_columns.apply_filtered(apply_targets,
+                                                  window_function: false)
+        end
+
+        def execute_filter(range_index)
           case @cover_type
           when :all
-            filter_shard_all(range_index, expression_builder)
+            filter_shard_all(range_index)
           when :partial_min
             if range_index
-              filter_by_range(range_index, expression_builder,
+              filter_by_range(range_index,
                               @target_range.min, @target_range.min_border,
                               nil, nil)
             else
               filter_table do |expression|
-                expression_builder.build_partial_min(expression)
+                @expression_builder.build_partial_min(expression)
               end
             end
           when :partial_max
             if range_index
-              filter_by_range(range_index, expression_builder,
+              filter_by_range(range_index,
                               nil, nil,
                               @target_range.max, @target_range.max_border)
             else
               filter_table do |expression|
-                expression_builder.build_partial_max(expression)
+                @expression_builder.build_partial_max(expression)
               end
             end
           when :partial_min_and_max
             if range_index
-              filter_by_range(range_index, expression_builder,
+              filter_by_range(range_index,
                               @target_range.min, @target_range.min_border,
                               @target_range.max, @target_range.max_border)
             else
               filter_table do |expression|
-                expression_builder.build_partial_min_and_max(expression)
+                @expression_builder.build_partial_min_and_max(expression)
               end
             end
           end
         end
 
-        def filter_shard_all(range_index, expression_builder)
+        def filter_shard_all(range_index)
           table = @target_table
           if @filter.nil?
             if @post_filter.nil? and table.size <= @context.current_offset
               @context.current_offset -= table.size
               return
             end
-            if range_index
-              filter_by_range(range_index, expression_builder,
+            if @range_index
+              filter_by_range(range_index,
                               nil, nil,
                               nil, nil)
             else
-              sort_result_set(table)
+              add_filtered_result_set(table)
             end
           else
-            if range_index
-              filter_by_range(range_index, expression_builder,
+            if @range_index
+              filter_by_range(range_index,
                               nil, nil,
                               nil, nil)
             else
               filter_table do |expression|
-                expression_builder.build_all(expression)
+                @expression_builder.build_all(expression)
               end
             end
           end
@@ -536,8 +932,7 @@ module Groonga
           end
         end
 
-        def filter_by_range(range_index, expression_builder,
-                            min, min_border, max, max_border)
+        def filter_by_range(range_index, min, min_border, max, max_border)
           lexicon = range_index.domain
           data_table = range_index.range
           flags = build_range_search_flags(min_border, max_border)
@@ -584,18 +979,18 @@ module Groonga
                 decide_use_range_index(false,
                                        fallback_message,
                                        __LINE__, __method__)
-                execute_filter(nil, expression_builder)
+                execute_filter(nil)
                 return
               end
             end
-          rescue
+          rescue => error
             result_set.close
-            raise
+            raise error
           end
 
           if n_matched_records <= @context.current_offset
             @context.current_offset -= n_matched_records
-            result_set.close
+            @temporary_tables << result_set
             return
           end
 
@@ -605,6 +1000,7 @@ module Groonga
           if @context.current_limit > 0
             @context.current_limit -= result_set.size
           end
+          @temporary_tables << result_set
           @result_sets << result_set
         end
 
@@ -649,7 +1045,8 @@ module Groonga
           create_expression(table) do |expression|
             yield(expression)
             result_set = table.select(expression)
-            sort_result_set(result_set)
+            @temporary_tables << result_set
+            add_filtered_result_set(result_set)
           end
         end
 
@@ -660,40 +1057,41 @@ module Groonga
           end
         end
 
-        def sort_result_set(result_set)
-          @context.temporary_tables.delete(result_set)
-
-          if result_set.empty?
-            result_set.close if result_set.temporary?
-            return
-          end
-
-          @context.dynamic_columns.each_filtered do |dynamic_column|
-            if result_set == @shard.table
-              result_set = result_set.select_all
-            end
-            dynamic_column.apply(result_set)
-          end
+        def add_filtered_result_set(result_set)
+          return if result_set.empty?
+          @filtered_result_sets << result_set
+        end
 
+        def sort_result_set(result_set)
           unless @post_filter.nil?
-            filtered_table = result_set
-            result_set = apply_post_filter(filtered_table)
-            @context.temporary_tables << filtered_table
+            result_set = apply_post_filter(result_set)
+            @temporary_tables << result_set
           end
 
           if result_set.size <= @context.current_offset
             @context.current_offset -= result_set.size
-            result_set.close if result_set.temporary?
             return
           end
 
-          @unsorted_result_sets << result_set if result_set.temporary?
-          sort_keys = [
-            {
-              :key => @context.enumerator.shard_key_name,
-              :order => @context.order,
-            },
-          ]
+          if @context.sort_keys.empty?
+            sort_keys = [
+              {
+                :key => @context.enumerator.shard_key_name,
+                :order => @context.order,
+              },
+            ]
+          else
+            sort_keys = @context.sort_keys.collect do |sort_key|
+              if sort_key.start_with?("-")
+                key = sort_key[1..-1]
+                order = :descending
+              else
+                key = sort_key
+                order = :ascending
+              end
+              {:key => key, :order => order}
+            end
+          end
           if @context.current_limit > 0
             limit = @context.current_limit
           else
@@ -702,6 +1100,7 @@ module Groonga
           sorted_result_set = result_set.sort(sort_keys,
                                               :offset => @context.current_offset,
                                               :limit => limit)
+          @temporary_tables << sorted_result_set
           @result_sets << sorted_result_set
           if @context.current_offset > 0
             @context.current_offset = 0
@@ -710,6 +1109,22 @@ module Groonga
             @context.current_limit -= sorted_result_set.size
           end
         end
+
+        def detect_window
+          # TODO: return nil if result_set is small enough
+          windows = []
+          @context.time_classify_types.each do |type|
+            case type
+            when "minute", "second"
+              windows << Window.new(@context, @shard, @shard_range, :hour, 1)
+            when "day", "hour"
+              unless @shard_range.is_a?(LogicalEnumerator::DayShardRange)
+                windows << Window.new(@context, @shard, @shard_range, :day, 1)
+              end
+            end
+          end
+          windows.max
+        end
       end
     end
   end