rroonga 5.0.3-x64-mingw32 → 5.0.4-x64-mingw32

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

@@ -2,3 +2,5 @@ require "sharding/range_expression_builder"
 require "sharding/logical_enumerator"
 require "sharding/logical_count"
 require "sharding/logical_range_filter"
+require "sharding/logical_select"
+require "sharding/logical_table_remove"

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

@@ -20,15 +20,37 @@ module Groonga
 
       private
       def each_internal(order)
-        prefix = "#{@logical_table}_"
         context = Context.instance
-        context.database.each_table(:prefix => prefix,
-                                    :order_by => :key,
-                                    :order => order) do |table|
-          shard_range_raw = table.name[prefix.size..-1]
+        each_shard_with_around(order) do |prev_shard, current_shard, next_shard|
+          table = current_shard.table
+          shard_range_data = current_shard.range_data
+          shard_range = nil
 
-          next unless /\A(\d{4})(\d{2})(\d{2})\z/ =~ shard_range_raw
-          shard_range = ShardRange.new($1.to_i, $2.to_i, $3.to_i)
+          if shard_range_data.day.nil?
+            if order == :ascending
+              if next_shard
+                next_shard_range_data = next_shard.range_data
+              else
+                next_shard_range_data = nil
+              end
+            else
+              if prev_shard
+                next_shard_range_data = prev_shard.range_data
+              else
+                next_shard_range_data = nil
+              end
+            end
+            max_day = compute_month_shard_max_day(shard_range_data.year,
+                                                  shard_range_data.month,
+                                                  next_shard_range_data)
+            shard_range = MonthShardRange.new(shard_range_data.year,
+                                              shard_range_data.month,
+                                              max_day)
+          else
+            shard_range = DayShardRange.new(shard_range_data.year,
+                                            shard_range_data.month,
+                                            shard_range_data.day)
+          end
 
           physical_shard_key_name = "#{table.name}.#{@shard_key_name}"
           shard_key = context[physical_shard_key_name]
@@ -43,6 +65,36 @@ module Groonga
         end
       end
 
+      def each_shard_with_around(order)
+        context = Context.instance
+        prefix = "#{@logical_table}_"
+
+        shards = [nil]
+        context.database.each_table(:prefix => prefix,
+                                    :order_by => :key,
+                                    :order => order) do |table|
+          shard_range_raw = table.name[prefix.size..-1]
+
+          case shard_range_raw
+          when /\A(\d{4})(\d{2})\z/
+            shard_range_data = ShardRangeData.new($1.to_i, $2.to_i, nil)
+          when /\A(\d{4})(\d{2})(\d{2})\z/
+            shard_range_data = ShardRangeData.new($1.to_i, $2.to_i, $3.to_i)
+          else
+            next
+          end
+
+          shards << Shard.new(table, shard_range_data)
+          next if shards.size < 3
+          yield(*shards)
+          shards.shift
+        end
+
+        if shards.size == 2
+          yield(shards[0], shards[1], nil)
+        end
+      end
+
       private
       def initialize_parameters
         @logical_table = @input[:logical_table]
@@ -58,13 +110,84 @@ module Groonga
         @target_range = TargetRange.new(@command_name, @input)
       end
 
-      class ShardRange
+      def compute_month_shard_max_day(year, month, next_shard_range)
+        return nil if next_shard_range.nil?
+
+        return nil if month != next_shard_range.month
+
+        next_shard_range.day
+      end
+
+      class Shard
+        attr_reader :table, :range_data
+        def initialize(table, range_data)
+          @table = table
+          @range_data = range_data
+        end
+      end
+
+      class ShardRangeData
+        attr_reader :year, :month, :day
+        def initialize(year, month, day)
+          @year = year
+          @month = month
+          @day = day
+        end
+      end
+
+      class DayShardRange
         attr_reader :year, :month, :day
         def initialize(year, month, day)
           @year = year
           @month = month
           @day = day
         end
+
+        def least_over_time
+          Time.local(@year, @month, @day + 1)
+        end
+
+        def min_time
+          Time.local(@year, @month, @day)
+        end
+
+        def include?(time)
+          @year == time.year and
+            @month == time.month and
+            @day == time.day
+        end
+      end
+
+      class MonthShardRange
+        attr_reader :year, :month, :max_day
+        def initialize(year, month, max_day)
+          @year = year
+          @month = month
+          @max_day = max_day
+        end
+
+        def least_over_time
+          if @max_day.nil?
+            Time.local(@year, @month + 1, 1)
+          else
+            Time.local(@year, @month, @max_day + 1)
+          end
+        end
+
+        def min_time
+          Time.local(@year, @month, 1)
+        end
+
+        def include?(time)
+          return false unless @year == time.year
+          return false unless @month == time.month
+
+          if @max_day.nil?
+            true
+          else
+            time.day <= @max_day
+          end
+        end
       end
 
       class TargetRange
@@ -139,16 +262,11 @@ module Groonga
         end
 
         def in_min?(shard_range)
-          base_time = Time.local(shard_range.year,
-                                 shard_range.month,
-                                 shard_range.day + 1)
-          @min < base_time
+          @min < shard_range.least_over_time
         end
 
         def in_min_partial?(shard_range)
-          return false unless @min.year == shard_range.year
-          return false unless @min.month == shard_range.month
-          return false unless @min.day == shard_range.day
+          return false unless shard_range.include?(@min)
 
           return true if @min_border == :exclude
 
@@ -159,9 +277,7 @@ module Groonga
         end
 
         def in_max?(shard_range)
-          max_base_time = Time.local(shard_range.year,
-                                     shard_range.month,
-                                     shard_range.day)
+          max_base_time = shard_range.min_time
           if @max_border == :include
             @max >= max_base_time
           else
@@ -170,9 +286,7 @@ module Groonga
         end
 
         def in_max_partial?(shard_range)
-          @max.year == shard_range.year and
-            @max.month == shard_range.month and
-            @max.day == shard_range.day
+          shard_range.include?(@max)
         end
       end
     end

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

@@ -0,0 +1,174 @@
+module Groonga
+  module Sharding
+    class LogicalSelectCommand < Command
+      register("logical_select",
+               [
+                 "logical_table",
+                 "shard_key",
+                 "min",
+                 "min_border",
+                 "max",
+                 "max_border",
+                 "filter",
+               ])
+
+      def run_body(input)
+        output_columns = input[:output_columns] || "_key, *"
+
+        enumerator = LogicalEnumerator.new("logical_select", input)
+
+        context = ExecuteContext.new(input)
+        begin
+          executor = Executor.new(context)
+          executor.execute
+
+          result_sets = context.result_sets
+          n_hits = 0
+          n_elements = 2 # for N hits and columns
+          result_sets.each do |result_set|
+            n_hits += result_set.size
+            n_elements += result_set.size
+          end
+
+          writer.array("RESULTSET", n_elements) do
+            writer.array("NHITS", 1) do
+              writer.write(n_hits)
+            end
+            first_result_set = result_sets.first
+            if first_result_set
+              writer.write_table_columns(first_result_set, output_columns)
+            end
+            options = {}
+            result_sets.each do |result_set|
+              writer.write_table_records(result_set, output_columns, options)
+            end
+          end
+        ensure
+          context.close
+        end
+      end
+
+      class ExecuteContext
+        attr_reader :enumerator
+        attr_reader :filter
+        attr_reader :offset
+        attr_reader :limit
+        attr_reader :result_sets
+        def initialize(input)
+          @input = input
+          @enumerator = LogicalEnumerator.new("logical_select", @input)
+          @filter = @input[:filter]
+          @offset = 0
+          @limit = 10
+
+          @result_sets = []
+        end
+
+        def close
+          @result_sets.each do |result_set|
+            result_set.close if result_set.temporary?
+          end
+        end
+      end
+
+      class Executor
+        def initialize(context)
+          @context = context
+        end
+
+        def execute
+          first_table = nil
+          enumerator = @context.enumerator
+          enumerator.each do |table, shard_key, shard_range|
+            first_table ||= table
+            next if table.empty?
+
+            shard_executor = ShardExecutor.new(@context,
+                                               table, shard_key, shard_range)
+            shard_executor.execute
+          end
+          if first_table.nil?
+            message =
+              "[logical_select] no shard exists: " +
+              "logical_table: <#{enumerator.logical_table}>: " +
+              "shard_key: <#{enumerator.shard_key_name}>"
+            raise InvalidArgument, message
+          end
+          if @context.result_sets.empty?
+            result_set = HashTable.create(:flags => ObjectFlags::WITH_SUBREC,
+                                          :key_type => first_table)
+            @context.result_sets << result_set
+          end
+        end
+      end
+
+      class ShardExecutor
+        def initialize(context, table, shard_key, shard_range)
+          @context = context
+          @table = table
+          @shard_key = shard_key
+          @shard_range = shard_range
+
+          @filter = @context.filter
+          @result_sets = @context.result_sets
+
+          @target_range = @context.enumerator.target_range
+
+          @cover_type = @target_range.cover_type(@shard_range)
+
+          @expression_builder = RangeExpressionBuilder.new(@shard_key,
+                                                           @target_range,
+                                                           @filter)
+        end
+
+        def execute
+          return if @cover_type == :none
+
+          case @cover_type
+          when :all
+            filter_shard_all
+          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
+
+        private
+        def filter_shard_all
+          if @filter.nil?
+            @result_sets << @table
+          else
+            filter_table do |expression|
+              @expression_builder.build_all(expression)
+            end
+          end
+        end
+
+        def create_expression(table)
+          expression = Expression.create(table)
+          begin
+            yield(expression)
+          ensure
+            expression.close
+          end
+        end
+
+        def filter_table
+          create_expression(@table) do |expression|
+            yield(expression)
+            @result_sets << @table.select(expression)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Groonga
+  module Sharding
+    class LogicalTableRemoveCommand < Command
+      register("logical_table_remove",
+               [
+                 "logical_table",
+                 "shard_key",
+                 "min",
+                 "min_border",
+                 "max",
+                 "max_border",
+               ])
+
+      def run_body(input)
+        enumerator = LogicalEnumerator.new("logical_table_remove", input)
+
+        succeess = true
+        enumerator.each do |table, shard_key, shard_range|
+          remove_table(table,
+                       shard_key,
+                       shard_range,
+                       enumerator.target_range)
+        end
+        writer.write(succeess)
+      end
+
+      private
+      def remove_table(table, shard_key, shard_range, target_range)
+        cover_type = target_range.cover_type(shard_range)
+        return if cover_type == :none
+
+        expression_builder = RangeExpressionBuilder.new(shard_key,
+                                                        target_range,
+                                                        nil)
+
+        case cover_type
+        when :all
+          table.remove
+        when :partial_min
+          remove_records(table) do |expression|
+            expression_builder.build_partial_min(expression)
+          end
+          table.remove if table.empty?
+        when :partial_max
+          remove_records(table) do |expression|
+            expression_builder.build_partial_max(expression)
+          end
+          table.remove if table.empty?
+        when :partial_min_and_max
+          remove_records(table) do |expression|
+            expression_builder.build_partial_min_and_max(expression)
+          end
+          table.remove if table.empty?
+        end
+      end
+
+      def remove_records(table)
+        expression = nil
+
+        begin
+          expression = Expression.create(table)
+          yield(expression)
+          table.delete(:expression => expression)
+        ensure
+          expression.close if expression
+        end
+      end
+    end
+  end
+end