rroonga 5.0.0-x86-mingw32 → 5.0.1-x86-mingw32

data/vendor/local/bin/onig-config

@@ -27,7 +27,7 @@ if test $# -eq 0; then
   show_usage
 fi
 
-prefix=/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86
+prefix=/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86
 exec_prefix=${prefix}
 is_set_exec_prefix=no
 

data/vendor/local/etc/groonga/groonga.conf

@@ -1,6 +1,6 @@
 # encoding = utf-8
 # log-level = 1
-# address = 0.0.0.0
+# bind-address = 0.0.0.0
 # port = 10041
 # server-id = groonga.example.com
 # max-threads = 2

data/vendor/local/etc/groonga/httpd/groonga-httpd.conf

@@ -15,7 +15,7 @@ http {
   keepalive_timeout 65;
 
   # The default groonga database path.
-  groonga_database /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/var/lib/groonga/db/db;
+  groonga_database /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/var/lib/groonga/db/db;
 
   # Create a groonga database automatically if the groonga database doesn't
   # exist.
@@ -45,7 +45,7 @@ http {
     }
 
     location / {
-      root /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/share/groonga/html/admin;
+      root /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/share/groonga/html/admin;
       index index.html;
     }
 

data/vendor/local/include/groonga/groonga.h

@@ -19,6 +19,7 @@
 #define GROONGA_H
 
 #include "groonga/groonga.h"
+#include "groonga/obj.h"
 #include "groonga/ii.h"
 #include "groonga/expr.h"
 #include "groonga/output.h"

data/vendor/local/include/groonga/groonga/expr.h

@@ -101,6 +101,8 @@ GRN_API grn_rc grn_expr_snip_add_conditions(grn_ctx *ctx,
                                             const char **closetags,
                                             unsigned int *closetag_lens);
 
+GRN_API unsigned int grn_expr_estimate_size(grn_ctx *ctx, grn_obj *expr);
+
 #ifdef __cplusplus
 }
 #endif

data/vendor/local/include/groonga/groonga/groonga.h

@@ -121,6 +121,7 @@ typedef enum {
   GRN_TOKEN_FILTER_ERROR = -73,
   GRN_COMMAND_ERROR = -74,
   GRN_PLUGIN_ERROR = -75,
+  GRN_SCORER_ERROR = -76
 } grn_rc;
 
 GRN_API grn_rc grn_init(void);
@@ -181,7 +182,8 @@ typedef enum {
   GRN_CONTENT_TSV,
   GRN_CONTENT_JSON,
   GRN_CONTENT_XML,
-  GRN_CONTENT_MSGPACK
+  GRN_CONTENT_MSGPACK,
+  GRN_CONTENT_GROONGA_COMMAND_LIST
 } grn_content_type;
 
 typedef struct _grn_obj grn_obj;
@@ -431,6 +433,7 @@ GRN_API grn_rc grn_db_recover(grn_ctx *ctx, grn_obj *db);
 GRN_API grn_rc grn_ctx_use(grn_ctx *ctx, grn_obj *db);
 GRN_API grn_obj *grn_ctx_db(grn_ctx *ctx);
 GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, int name_size);
+GRN_API grn_rc grn_ctx_get_all_tables(grn_ctx *ctx, grn_obj *tables_buffer);
 
 typedef enum {
   GRN_DB_VOID = 0,
@@ -468,7 +471,9 @@ GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int na
                                  grn_obj_flags flags, unsigned int size);
 
 GRN_API grn_rc grn_plugin_register(grn_ctx *ctx, const char *name);
+GRN_API grn_rc grn_plugin_unregister(grn_ctx *ctx, const char *name);
 GRN_API grn_rc grn_plugin_register_by_path(grn_ctx *ctx, const char *path);
+GRN_API grn_rc grn_plugin_unregister_by_path(grn_ctx *ctx, const char *path);
 GRN_API const char *grn_plugin_get_system_plugins_dir(void);
 GRN_API const char *grn_plugin_get_suffix(void);
 
@@ -487,7 +492,8 @@ typedef enum {
   GRN_PROC_FUNCTION,
   GRN_PROC_HOOK,
   GRN_PROC_NORMALIZER,
-  GRN_PROC_TOKEN_FILTER
+  GRN_PROC_TOKEN_FILTER,
+  GRN_PROC_SCORER
 } grn_proc_type;
 
 GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
@@ -707,7 +713,8 @@ typedef enum {
   GRN_OP_TABLE_SORT,
   GRN_OP_TABLE_GROUP,
   GRN_OP_JSON_PUT,
-  GRN_OP_GET_MEMBER
+  GRN_OP_GET_MEMBER,
+  GRN_OP_REGEXP
 } grn_operator;
 
 GRN_API const char *grn_operator_to_string(grn_operator op);
@@ -720,6 +727,12 @@ GRN_API grn_bool grn_operator_exec_less_equal(grn_ctx *ctx,
                                               grn_obj *x, grn_obj *y);
 GRN_API grn_bool grn_operator_exec_greater_equal(grn_ctx *ctx,
                                                  grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_match(grn_ctx *ctx,
+                                         grn_obj *target, grn_obj *sub_text);
+GRN_API grn_bool grn_operator_exec_prefix(grn_ctx *ctx,
+                                          grn_obj *target, grn_obj *prefix);
+GRN_API grn_bool grn_operator_exec_regexp(grn_ctx *ctx,
+                                          grn_obj *target, grn_obj *pattern);
 
 struct _grn_table_group_result {
   grn_obj *table;
@@ -834,8 +847,6 @@ GRN_API grn_obj *grn_obj_get_element_info(grn_ctx *ctx, grn_obj *obj, grn_id id,
 GRN_API grn_rc grn_obj_set_element_info(grn_ctx *ctx, grn_obj *obj, grn_id id,
                                         grn_info_type type, grn_obj *value);
 
-GRN_API grn_bool grn_obj_is_builtin(grn_ctx *ctx, grn_obj *obj);
-
 GRN_API grn_obj *grn_obj_get_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value);
 GRN_API int grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void **values);
 
@@ -910,6 +921,9 @@ struct _grn_search_optarg {
   int vector_size;
   grn_obj *proc;
   int max_size;
+  grn_obj *scorer;
+  grn_obj *scorer_args_expr;
+  unsigned int scorer_args_expr_offset;
 };
 
 GRN_API grn_rc grn_obj_search(grn_ctx *ctx, grn_obj *obj, grn_obj *query,
@@ -975,9 +989,22 @@ GRN_API grn_rc grn_obj_delete_hook(grn_ctx *ctx, grn_obj *obj, grn_hook_entry en
 
 GRN_API grn_obj *grn_obj_open(grn_ctx *ctx, unsigned char type, grn_obj_flags flags, grn_id domain);
 
+/* Deprecated since 5.0.1. Use grn_column_find_indexes() instead. */
 GRN_API int grn_column_index(grn_ctx *ctx, grn_obj *column, grn_operator op,
                              grn_obj **indexbuf, int buf_size, int *section);
 
+/* @since 5.0.1. */
+typedef struct _grn_index_datum {
+  grn_obj *index;
+  unsigned int section;
+} grn_index_datum;
+
+/* @since 5.0.1. */
+GRN_API unsigned int grn_column_find_index_data(grn_ctx *ctx, grn_obj *column,
+                                                grn_operator op,
+                                                grn_index_datum *index_data,
+                                                unsigned int n_index_data);
+
 GRN_API grn_rc grn_obj_delete_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, grn_bool removep);
 GRN_API grn_rc grn_obj_path_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, char *buffer);
 

data/vendor/local/include/groonga/groonga/ii.h

@@ -28,6 +28,13 @@ typedef struct _grn_ii grn_ii;
 typedef struct _grn_ii_buffer grn_ii_buffer;
 
 GRN_API unsigned int grn_ii_estimate_size(grn_ctx *ctx, grn_ii *ii, grn_id tid);
+GRN_API unsigned int grn_ii_estimate_size_for_query(grn_ctx *ctx, grn_ii *ii,
+                                                    const char *query,
+                                                    unsigned int query_len,
+                                                    grn_search_optarg *optarg);
+GRN_API unsigned int grn_ii_estimate_size_for_lexicon_cursor(grn_ctx *ctx,
+                                                             grn_ii *ii,
+                                                             grn_table_cursor *lexicon_cursor);
 
 GRN_API grn_ii_buffer *grn_ii_buffer_open(grn_ctx *ctx, grn_ii *ii,
                                           long long unsigned int update_buffer_size);

data/vendor/local/include/groonga/groonga/obj.h

@@ -0,0 +1,37 @@
+/* -*- c-basic-offset: 2 -*- */
+/*
+  Copyright(C) 2015 Brazil
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef GROONGA_OBJ_H
+#define GROONGA_OBJ_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+GRN_API grn_bool grn_obj_is_builtin(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_bool grn_obj_is_table(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_bool grn_obj_is_proc(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_bool grn_obj_is_function_proc(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_bool grn_obj_is_selector_proc(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_bool grn_obj_is_scorer_proc(grn_ctx *ctx, grn_obj *obj);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GROONGA_OBJ_H */

data/vendor/local/include/groonga/groonga/scorer.h

@@ -0,0 +1,95 @@
+/* -*- c-basic-offset: 2 -*- */
+/*
+  Copyright(C) 2015 Brazil
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+#ifndef GROONGA_SCORER_H
+#define GROONGA_SCORER_H
+
+#include <groonga/plugin.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif  /* __cplusplus */
+
+typedef struct _grn_scorer_matched_record grn_scorer_matched_record;
+
+GRN_API grn_obj *
+  grn_scorer_matched_record_get_table(grn_ctx *ctx,
+                                      grn_scorer_matched_record *record);
+GRN_API grn_obj *
+  grn_scorer_matched_record_get_lexicon(grn_ctx *ctx,
+                                        grn_scorer_matched_record *record);
+GRN_API grn_id
+  grn_scorer_matched_record_get_id(grn_ctx *ctx,
+                                   grn_scorer_matched_record *record);
+GRN_API grn_obj *
+  grn_scorer_matched_record_get_terms(grn_ctx *ctx,
+                                      grn_scorer_matched_record *record);
+GRN_API grn_obj *
+  grn_scorer_matched_record_get_term_weights(grn_ctx *ctx,
+                                             grn_scorer_matched_record *record);
+GRN_API unsigned int
+  grn_scorer_matched_record_get_total_term_weights(grn_ctx *ctx,
+                                                   grn_scorer_matched_record *record);
+GRN_API long long unsigned int
+  grn_scorer_matched_record_get_n_documents(grn_ctx *ctx,
+                                            grn_scorer_matched_record *record);
+GRN_API unsigned int
+  grn_scorer_matched_record_get_n_occurrences(grn_ctx *ctx,
+                                              grn_scorer_matched_record *record);
+GRN_API long long unsigned int
+  grn_scorer_matched_record_get_n_candidates(grn_ctx *ctx,
+                                             grn_scorer_matched_record *record);
+GRN_API unsigned int
+  grn_scorer_matched_record_get_n_tokens(grn_ctx *ctx,
+                                         grn_scorer_matched_record *record);
+GRN_API int
+  grn_scorer_matched_record_get_weight(grn_ctx *ctx,
+                                       grn_scorer_matched_record *record);
+GRN_API grn_obj *
+  grn_scorer_matched_record_get_arg(grn_ctx *ctx,
+                                    grn_scorer_matched_record *record,
+                                    unsigned int i);
+GRN_API unsigned int
+  grn_scorer_matched_record_get_n_args(grn_ctx *ctx,
+                                       grn_scorer_matched_record *record);
+
+
+
+typedef double grn_scorer_score_func(grn_ctx *ctx,
+                                     grn_scorer_matched_record *record);
+
+/*
+  grn_scorer_register() registers a plugin to the database which is
+  associated with `ctx'. `plugin_name_ptr' and `plugin_name_length' specify the
+  plugin name. Alphabetic letters ('A'-'Z' and 'a'-'z'), digits ('0'-'9') and
+  an underscore ('_') are capable characters.
+
+  `score' is called for scoring matched records one by one.
+
+  grn_scorer_register() returns GRN_SUCCESS on success, an error
+  code on failure.
+ */
+GRN_PLUGIN_EXPORT grn_rc grn_scorer_register(grn_ctx *ctx,
+                                             const char *plugin_name_ptr,
+                                             int plugin_name_length,
+                                             grn_scorer_score_func *score);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif  /* __cplusplus */
+
+#endif  /* GROONGA_SCORER_H */

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/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libgroonga.la /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libmsgpack.la /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libonig.la -llz4 -lz -lws2_32'
+dependency_libs=' -L/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libgroonga.la /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libmsgpack.la /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libonig.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='/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/groonga/plugins/query_expanders'
+libdir='/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/groonga/plugins/query_expanders'

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

@@ -17,7 +17,7 @@ old_library='eval.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libgroonga.la /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libonig.la -llz4 -lz -lws2_32 /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libmsgpack.la'
+dependency_libs=' -L/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libgroonga.la /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libonig.la -llz4 -lz -lws2_32 /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libmsgpack.la'
 
 # 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='/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/groonga/plugins/ruby'
+libdir='/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/groonga/plugins/ruby'

data/vendor/local/lib/groonga/plugins/ruby/load.la

@@ -17,7 +17,7 @@ old_library='load.a'
 inherited_linker_flags=''
 
 # Libraries that this one depends upon.
-dependency_libs=' -L/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libgroonga.la /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libonig.la -llz4 -lz -lws2_32 /home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libmsgpack.la'
+dependency_libs=' -L/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libgroonga.la /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libonig.la -llz4 -lz -lws2_32 /home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/libmsgpack.la'
 
 # 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='/home/kenhys/work/groonga/groonga.clean/packages/windows/dist-x86/lib/groonga/plugins/ruby'
+libdir='/home/myokoym/work/groonga/groonga.clean/packages/windows/dist-x86/lib/groonga/plugins/ruby'

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

@@ -17,10 +17,10 @@ module Groonga
         filter = input[:filter]
 
         total = 0
-        enumerator.each do |table, shard_key, shard_range, cover_type|
+        enumerator.each do |table, shard_key, shard_range|
           total += count_n_records(table, filter,
                                    shard_key, shard_range,
-                                   enumerator.target_range, cover_type)
+                                   enumerator.target_range)
         end
         writer.write(total)
       end
@@ -28,7 +28,10 @@ module Groonga
       private
       def count_n_records(table, filter,
                           shard_key, shard_range,
-                          target_range, cover_type)
+                          target_range)
+        cover_type = target_range.cover_type(shard_range)
+        return 0 if cover_type == :none
+
         if cover_type == :all
           if filter.nil?
             return table.size

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

@@ -2,6 +2,8 @@ module Groonga
   module Sharding
     class LogicalEnumerator
       attr_reader :target_range
+      attr_reader :logical_table
+      attr_reader :shard_key_name
       def initialize(command_name, input)
         @command_name = command_name
         @input = input
@@ -11,7 +13,9 @@ module Groonga
       def each
         prefix = "#{@logical_table}_"
         context = Context.instance
-        context.database.each_table(:prefix => prefix) do |table|
+        context.database.each_table(:prefix => prefix,
+                                    :order_by => :key,
+                                    :order => :ascending) do |table|
           shard_range_raw = table.name[prefix.size..-1]
 
           next unless /\A(\d{4})(\d{2})(\d{2})\z/ =~ shard_range_raw
@@ -26,10 +30,7 @@ module Groonga
             raise InvalidArgument, message
           end
 
-          cover_type = @target_range.cover_type(shard_range)
-          next if cover_type == :none
-
-          yield(table, shard_key, shard_range, cover_type)
+          yield(table, shard_key, shard_range)
         end
       end
 

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

@@ -17,32 +17,436 @@ module Groonga
                ])
 
       def run_body(input)
-        enumerator = LogicalEnumerator.new("logical_range_filter", input)
-        filter = input[:filter]
-        offset = input[:offset] || 0
-        limit = input[:limit] || 10
         output_columns = input[:output_columns] || "_key, *"
 
-        result_sets = []
-        enumerator.each do |table, shard_key, shard_range, cover_type|
-          # TODO: result_sets << result_set
-        end
-        if result_sets.empty?
-          n_elements = 0
-        else
+        context = ExecuteContext.new(input)
+        begin
+          executor = Executor.new(context)
+          executor.execute
+
+          result_sets = context.result_sets
           n_elements = 1 # for columns
           result_sets.each do |result_set|
             n_elements += result_set.size
           end
+
+          writer.array("RESULTSET", n_elements) do
+            first_result_set = result_sets.first
+            if first_result_set
+              writer.write_table_columns(first_result_set, output_columns)
+            end
+            result_sets.each do |result_set|
+              writer.write_table_records(result_set, output_columns)
+            end
+          end
+        ensure
+          context.close
+        end
+      end
+
+      class ExecuteContext
+        attr_reader :enumerator
+        attr_reader :order
+        attr_reader :filter
+        attr_reader :offset
+        attr_reader :limit
+        attr_accessor :current_offset
+        attr_accessor :current_limit
+        attr_reader :result_sets
+        attr_reader :unsorted_result_sets
+        attr_reader :threshold
+        def initialize(input)
+          @input = input
+          @enumerator = LogicalEnumerator.new("logical_range_filter", @input)
+          @order = parse_order(@input, :order)
+          @filter = @input[:filter]
+          @offset = (@input[:offset] || 0).to_i
+          @limit = (@input[:limit] || 10).to_i
+
+          @current_offset = 0
+          @current_limit = @limit
+
+          @result_sets = []
+          @unsorted_result_sets = []
+
+          @threshold = compute_threshold
         end
-        writer.array("RESULTSET", n_elements) do
-          first_result_set = result_sets.first
-          if first_result_set
-            writer.write_table_columns(first_result_set, output_columns)
+
+        def close
+          @unsorted_result_sets.each do |result_set|
+            result_set.close if result_set.temporary?
           end
-          result_sets.each do |result_set|
-            writer.write_table_records(result_set, output_columns)
+          @result_sets.each do |result_set|
+            result_set.close if result_set.temporary?
+          end
+        end
+
+        private
+        def parse_order(input, name)
+          order = input[name]
+          return :ascending if order.nil?
+
+          case order
+          when "ascending"
+            :ascending
+          when "descending"
+            :descending
+          else
+            message =
+              "[logical_range_filter] #{name} must be " +
+              "\"ascending\" or \"descending\": <#{order}>"
+            raise InvalidArgument, message
+          end
+        end
+
+        def compute_threshold
+          threshold_env = ENV["GRN_LOGICAL_RANGE_FILTER_THRESHOLD"]
+          default_threshold = 0.000058 # 15000 / 259200000.0
+          (threshold_env || default_threshold).to_f
+        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
+            break if @context.current_limit == 0
+          end
+          if first_table.nil?
+            message =
+              "[logical_range_filter] 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
+          @unsorted_result_sets = @context.unsorted_result_sets
+
+          @target_range = @context.enumerator.target_range
+
+          @cover_type = @target_range.cover_type(@shard_range)
+        end
+
+        def execute
+          return if @cover_type == :none
+
+          index_info = @shard_key.find_index(Operator::LESS)
+          if index_info
+            range_index = index_info.index
+            range_index = nil unless use_range_index?(range_index)
+          else
+            range_index = nil
+          end
+
+          case @cover_type
+          when :all
+            filter_shard_all(range_index)
+          when :partial_min
+            if range_index
+              filter_by_range(range_index,
+                              @target_range.min, @target_range.min_border,
+                              nil, nil)
+            else
+              filter_table do |expression|
+                build_expression_partial_min(expression)
+              end
+            end
+          when :partial_max
+            if range_index
+              filter_by_range(range_index,
+                              nil, nil,
+                              @target_range.max, @target_range.max_border)
+            else
+              filter_table do |expression|
+                build_expression_partial_max(expression)
+              end
+            end
+          when :partial_min_and_max
+            if range_index
+              filter_by_range(range_index,
+                              @target_range.min, @target_range.min_border,
+                              @target_range.max, @target_range.max_border)
+            else
+              filter_table do |expression|
+                build_expression_partial_min_and_max(expression)
+              end
+            end
+          end
+        end
+
+        private
+        def build_expression_all(expression)
+          expression.parse(@filter)
+        end
+
+        def build_expression_partial_min(expression)
+          expression.append_object(@shard_key, Operator::PUSH, 1)
+          expression.append_operator(Operator::GET_VALUE, 1)
+          expression.append_constant(@target_range.min, Operator::PUSH, 1)
+          if @target_range.min_border == :include
+            expression.append_operator(Operator::GREATER_EQUAL, 2)
+          else
+            expression.append_operator(Operator::GREATER, 2)
+          end
+          if @filter
+            expression.parse(@filter)
+            expression.append_operator(Operator::AND, 2)
+          end
+        end
+
+        def build_expression_partial_max(expression)
+          expression.append_object(@shard_key, Operator::PUSH, 1)
+          expression.append_operator(Operator::GET_VALUE, 1)
+          expression.append_constant(@target_range.max, Operator::PUSH, 1)
+          if @target_range.max_border == :include
+            expression.append_operator(Operator::LESS_EQUAL, 2)
+          else
+            expression.append_operator(Operator::LESS, 2)
+          end
+          if @filter
+            expression.parse(@filter)
+            expression.append_operator(Operator::AND, 2)
+          end
+        end
+
+        def build_expression_partial_min_and_max(expression)
+          between = Groonga::Context.instance["between"]
+          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(@target_range.min, Operator::PUSH, 1)
+          expression.append_constant(@target_range.min_border,
+                                     Operator::PUSH, 1)
+          expression.append_constant(@target_range.max, Operator::PUSH, 1)
+          expression.append_constant(@target_range.max_border,
+                                     Operator::PUSH, 1)
+          expression.append_operator(Operator::CALL, 5)
+          if @filter
+            expression.parse(@filter)
+            expression.append_operator(Operator::AND, 2)
+          end
+        end
+
+        def use_range_index?(range_index)
+          return false unless ENV["GRN_LOGICAL_RANGE_FILTER_ENABLED"] == "yes"
+
+          required_n_records = @context.current_offset + @context.current_limit
+          max_n_records = @table.size
+          if max_n_records <= required_n_records
+            return false
+          end
+
+          threshold = @context.threshold
+          if threshold <= 0
+            return false
+          end
+
+          estimated_n_records = 0
+          case @cover_type
+          when :all
+            if @filter
+              create_expression(@table) do |expression|
+                build_expression_all(expression)
+                estimated_n_records = expression.estimate_size
+              end
+            else
+              estimated_n_records = max_n_records
+            end
+          when :partial_min
+            create_expression(@table) do |expression|
+                build_expression_partial_min(expression)
+              estimated_n_records = expression.estimate_size
+            end
+          when :partial_max
+            create_expression(@table) do |expression|
+              build_expression_partial_max(expression)
+              estimated_n_records = expression.estimate_size
+            end
+          when :partial_min_and_max
+            create_expression(@table) do |expression|
+              build_expression_partial_min_and_max(expression)
+              estimated_n_records = expression.estimate_size
+            end
+          end
+
+          if estimated_n_records <= required_n_records
+            return false
+          end
+
+          hit_ratio = estimated_n_records / max_n_records.to_f
+          hit_ratio >= threshold
+        end
+
+        def filter_shard_all(range_index)
+          if @filter.nil?
+            if @table.size <= @context.current_offset
+              @context.current_offset -= @table.size
+              return
+            end
+            if range_index
+              filter_by_range(range_index,
+                              nil, nil,
+                              nil, nil)
+            else
+              sort_result_set(@table)
+            end
+          else
+            if range_index
+              filter_by_range(range_index,
+                              nil, nil,
+                              nil, nil)
+            else
+              filter_table do |expression|
+                build_expression_all(expression)
+              end
+            end
+          end
+        end
+
+        def create_expression(table)
+          expression = Expression.create(table)
+          begin
+            yield(expression)
+          ensure
+            expression.close
+          end
+        end
+
+        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)
+
+          result_set = HashTable.create(:flags => ObjectFlags::WITH_SUBREC,
+                                        :key_type => data_table)
+          n_matched_records = 0
+          begin
+            TableCursor.open(lexicon,
+                             :min => min,
+                             :max => max,
+                             :flags => flags) do |table_cursor|
+              options = {
+                :offset => @context.current_offset,
+                :limit => @context.current_limit,
+              }
+              if @filter
+                create_expression(data_table) do |expression|
+                  expression.parse(@filter)
+                  options[:expression] = expression
+                  IndexCursor.open(table_cursor, range_index) do |index_cursor|
+                    n_matched_records = index_cursor.select(result_set, options)
+                  end
+                end
+              else
+                IndexCursor.open(table_cursor, range_index) do |index_cursor|
+                  n_matched_records = index_cursor.select(result_set, options)
+                end
+              end
+            end
+          rescue
+            result_set.close
+            raise
+          end
+
+          if n_matched_records <= @context.current_offset
+            @context.current_offset -= n_matched_records
+            result_set.close
+            return
+          end
+
+          if @context.current_offset > 0
+            @context.current_offset = 0
+          end
+          @context.current_limit -= result_set.size
+          @result_sets << result_set
+        end
+
+        def build_range_search_flags(min_border, max_border)
+          flags = TableCursorFlags::BY_KEY
+          case @context.order
+          when :ascending
+            flags |= TableCursorFlags::ASCENDING
+          when :descending
+            flags |= TableCursorFlags::DESCENDING
+          end
+          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
+        end
+
+        def filter_table
+          create_expression(@table) do |expression|
+            yield(expression)
+            result_set = @table.select(expression)
+            sort_result_set(result_set)
+          end
+        end
+
+        def sort_result_set(result_set)
+          if result_set.empty?
+            result_set.close if result_set.temporary?
+            return
+          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,
+            },
+          ]
+          sorted_result_set = result_set.sort(sort_keys,
+                                              :offset => @context.current_offset,
+                                              :limit => @context.current_limit)
+          @result_sets << sorted_result_set
+          if @context.current_offset > 0
+            @context.current_offset = 0
           end
+          @context.current_limit -= sorted_result_set.size
         end
       end
     end