rroonga 5.0.0-x64-mingw32 → 5.0.1-x64-mingw32

data/ext/groonga/rb-grn-expression.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2014  Masafumi Yokoyama <myokoym@gmail.com>
 
   This library is free software; you can redistribute it and/or
@@ -107,6 +107,45 @@ rb_grn_expression_initialize (int argc, VALUE *argv, VALUE self)
     return Qnil;
 }
 
+static VALUE
+rb_grn_expression_inspect (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression;
+    grn_obj inspected;
+    VALUE rb_inspected;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    rb_inspected = rb_str_new_cstr("");
+    rb_grn_object_inspect_header(self, rb_inspected);
+
+    GRN_TEXT_INIT(&inspected, 0);
+    grn_inspect(context, &inspected, expression);
+    grn_bulk_truncate(context, &inspected, GRN_TEXT_LEN(&inspected) - 2);
+    {
+        size_t prefix_length;
+        const char *content;
+        size_t content_length;
+
+        prefix_length = strlen("#<expr");
+        content = GRN_TEXT_VALUE(&inspected) + prefix_length;
+        content_length = GRN_TEXT_LEN(&inspected) - prefix_length;
+        rb_str_concat(rb_inspected,
+                      rb_grn_context_rb_string_new(context,
+                                                   content,
+                                                   content_length));
+    }
+
+    GRN_OBJ_FIN(context, &inspected);
+
+    rb_grn_object_inspect_footer(self, rb_inspected);
+
+    return rb_inspected;
+}
+
 /*
  * _expression_ で使用可能な変数を作成する。
  *
@@ -436,7 +475,10 @@ rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
     if (rc != GRN_SUCCESS) {
         VALUE related_object;
 
-        related_object = rb_ary_new3(2, self, rb_ary_new4(argc, argv));
+        related_object =
+            rb_ary_new_from_args(2,
+                                 self,
+                                 rb_ary_new_from_values(argc, argv));
         exception = rb_grn_context_to_exception(context, related_object);
     }
     if (default_column_is_created)
@@ -561,43 +603,6 @@ rb_grn_expression_array_reference (VALUE self, VALUE rb_name_or_offset)
     return GRNVARIABLE2RVAL(context, variable);
 }
 
-/* REMOVE ME */
-grn_rc grn_expr_inspect(grn_ctx *ctx, grn_obj *buf, grn_obj *expr);
-
-/*
- * _expression_ の中身を人に見やすい文字列で返す。
- *
- * @overload inspect
- *   @return [String]
- */
-static VALUE
-rb_grn_expression_inspect (VALUE self)
-{
-    grn_ctx *context = NULL;
-    grn_obj inspected;
-    grn_obj *expression;
-    VALUE rb_inspected;
-
-    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
-                                  NULL, NULL,
-                                  NULL, NULL, NULL);
-
-    GRN_TEXT_INIT(&inspected, 0);
-    GRN_TEXT_PUTS(context, &inspected, "#<Groonga::Expression ");
-#ifdef WIN32
-    GRN_TEXT_PUTS(context, &inspected, "(not supported on Windows)");
-#else
-    grn_expr_inspect(context, &inspected, expression);
-#endif
-    GRN_TEXT_PUTS(context, &inspected, ">");
-    rb_inspected = rb_grn_context_rb_string_new(context,
-                                                GRN_TEXT_VALUE(&inspected),
-                                                GRN_TEXT_LEN(&inspected));
-    GRN_OBJ_FIN(context, &inspected);
-
-    return rb_inspected;
-}
-
 /*
  * _expression_ から {Groonga::Snippet} を生成する。 _tags_ には
  * キーワードの前後に挿入するタグの配列を以下のような形式で指定
@@ -692,7 +697,7 @@ rb_grn_expression_snippet (int argc, VALUE *argv, VALUE self)
     }
 
     if (TYPE(RARRAY_PTR(rb_tags)[0]) == T_STRING) {
-        rb_tags = rb_ary_new3(1, rb_tags);
+        rb_tags = rb_ary_new_from_args(1, rb_tags);
     }
 
     rb_tag_values = RARRAY_PTR(rb_tags);
@@ -738,7 +743,8 @@ rb_grn_expression_snippet (int argc, VALUE *argv, VALUE self)
                             (const char **)open_tags, open_tag_lengths,
                             (const char **)close_tags, close_tag_lengths,
                             mapping);
-    related_object = rb_ary_new3(2, self, rb_ary_new4(argc, argv));
+    related_object =
+        rb_ary_new_from_args(2, self, rb_ary_new_from_values(argc, argv));
     rb_grn_context_check(context, related_object);
 
     return GRNOBJECT2RVAL(Qnil, context, snippet, GRN_TRUE);
@@ -785,6 +791,39 @@ rb_grn_expression_get_keywords (VALUE self)
     return rb_keywords;
 }
 
+/*
+ * Estimates the number of matched records when `expression` is
+ * executed.
+ *
+ * Note that the estimated size isn't correct value. It's just
+ * estimated size.
+ *
+ * @example
+ *   expression.parse("Ruby OR Groonga")
+ *   expression.estimate_size # => 10
+ *
+ * @overload estimate_size
+ *   @return [Integer] the estimated number of matched records when
+ *     `expression` is executed.
+ *
+ * @since 5.0.1
+ */
+static VALUE
+rb_grn_expression_estimate_size (VALUE self)
+{
+    grn_ctx *context = NULL;
+    grn_obj *expression;
+    unsigned int size;
+
+    rb_grn_expression_deconstruct(SELF(self), &expression, &context,
+                                  NULL, NULL,
+                                  NULL, NULL, NULL);
+
+    size = grn_expr_estimate_size(context, expression);
+
+    return UINT2NUM(size);
+}
+
 void
 rb_grn_init_expression (VALUE mGrn)
 {
@@ -793,6 +832,9 @@ rb_grn_init_expression (VALUE mGrn)
     rb_define_method(rb_cGrnExpression, "initialize",
                      rb_grn_expression_initialize, -1);
 
+    rb_define_method(rb_cGrnExpression, "inspect",
+                     rb_grn_expression_inspect, 0);
+
     rb_define_method(rb_cGrnExpression, "define_variable",
                      rb_grn_expression_define_variable, -1);
     rb_define_method(rb_cGrnExpression, "append_object",
@@ -821,6 +863,6 @@ rb_grn_init_expression (VALUE mGrn)
     rb_define_method(rb_cGrnExpression, "keywords",
                      rb_grn_expression_get_keywords, 0);
 
-    rb_define_method(rb_cGrnExpression, "inspect",
-                     rb_grn_expression_inspect, 0);
+    rb_define_method(rb_cGrnExpression, "estimate_size",
+                     rb_grn_expression_estimate_size, 0);
 }

data/ext/groonga/rb-grn-greater-equal-operator.c

@@ -0,0 +1,88 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  Kouhei Sutou <kou@clear-code.com>
+
+  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
+*/
+
+#include "rb-grn.h"
+
+VALUE rb_cGrnGreaterEqualOperator;
+
+/*
+ * Executes a greater-or-equal operation.
+ *
+ * @example Executes greater-or-equal operations with the default context
+ *   Groonga::Operator::GREATER_EQUAL.exec(1, 1) # => true
+ *   Groonga::Operator::GREATER_EQUAL.exec(2, 1) # => true
+ *   Groonga::Operator::GREATER_EQUAL.exec(1, 2) # => false
+ *
+ * @example Executes greater-or-equal operations with the specified context
+ *   context = Groonga::Context.new
+ *   Groonga::Operator::GREATER_EQUAL.exec(1, 1,
+ *                                         :context => context) # => true
+ *   Groonga::Operator::GREATER_EQUAL.exec(2, 1,
+ *                                         :context => context) # => true
+ *   Groonga::Operator::GREATER_EQUAL.exec(1, 2,
+ *                                         :context => context) # => false
+ *
+ * @overload exec(x, y, options={})
+ *   @param x [::Object] The left hand side value.
+ *   @param y [::Object] The right hand side value.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Context] (Groonga::Context.default)
+ *      The context to executes the operation.
+ *   @return [Boolean] `true` if `x` is greater than or equal to`y`,
+ *      `false` otherwise.
+ */
+static VALUE
+rb_grn_greater_equal_operator_exec (int argc, VALUE *argv, VALUE self)
+{
+    grn_bool greater_equal;
+    VALUE rb_x;
+    VALUE rb_y;
+    VALUE rb_options;
+    VALUE rb_context;
+    grn_ctx *context;
+    grn_obj x;
+    grn_obj y;
+
+    rb_scan_args(argc, argv, "21", &rb_x, &rb_y, &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    GRN_VOID_INIT(&x);
+    GRN_VOID_INIT(&y);
+    RVAL2GRNBULK(rb_x, context, &x);
+    RVAL2GRNBULK(rb_y, context, &y);
+    greater_equal = grn_operator_exec_greater_equal(context, &x, &y);
+    GRN_OBJ_FIN(context, &x);
+    GRN_OBJ_FIN(context, &y);
+
+    return CBOOL2RVAL(greater_equal);
+}
+
+void
+rb_grn_init_greater_equal_operator (VALUE mGrn)
+{
+    rb_cGrnGreaterEqualOperator = rb_define_class_under(mGrn,
+                                                        "GreaterEqualOperator",
+                                                        rb_cGrnOperator);
+
+    rb_define_method(rb_cGrnGreaterEqualOperator, "exec",
+                     rb_grn_greater_equal_operator_exec, -1);
+}

data/ext/groonga/rb-grn-greater-operator.c

@@ -0,0 +1,85 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  Kouhei Sutou <kou@clear-code.com>
+
+  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
+*/
+
+#include "rb-grn.h"
+
+VALUE rb_cGrnGreaterOperator;
+
+/*
+ * Executes a greater operation.
+ *
+ * @example Executes greater operations with the default context
+ *   Groonga::Operator::GREATER.exec(2, 1) # => true
+ *   Groonga::Operator::GREATER.exec(1, 2) # => false
+ *
+ * @example Executes greater operations with the specified context
+ *   context = Groonga::Context.new
+ *   Groonga::Operator::GREATER.exec(2, 1,
+ *                                   :context => context) # => true
+ *   Groonga::Operator::GREATER.exec(1, 2,
+ *                                   :context => context) # => false
+ *
+ * @overload exec(x, y, options={})
+ *   @param x [::Object] The left hand side value.
+ *   @param y [::Object] The right hand side value.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Context] (Groonga::Context.default)
+ *      The context to executes the operation.
+ *   @return [Boolean] `true` if `x` is greater than `y`, `false`
+ *      otherwise.
+ */
+static VALUE
+rb_grn_greater_operator_exec (int argc, VALUE *argv, VALUE self)
+{
+    grn_bool greater;
+    VALUE rb_x;
+    VALUE rb_y;
+    VALUE rb_options;
+    VALUE rb_context;
+    grn_ctx *context;
+    grn_obj x;
+    grn_obj y;
+
+    rb_scan_args(argc, argv, "21", &rb_x, &rb_y, &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    GRN_VOID_INIT(&x);
+    GRN_VOID_INIT(&y);
+    RVAL2GRNBULK(rb_x, context, &x);
+    RVAL2GRNBULK(rb_y, context, &y);
+    greater = grn_operator_exec_greater(context, &x, &y);
+    GRN_OBJ_FIN(context, &x);
+    GRN_OBJ_FIN(context, &y);
+
+    return CBOOL2RVAL(greater);
+}
+
+void
+rb_grn_init_greater_operator (VALUE mGrn)
+{
+    rb_cGrnGreaterOperator = rb_define_class_under(mGrn,
+                                                   "GreaterOperator",
+                                                   rb_cGrnOperator);
+
+    rb_define_method(rb_cGrnGreaterOperator, "exec",
+                     rb_grn_greater_operator_exec, -1);
+}

data/ext/groonga/rb-grn-hash.c

@@ -216,7 +216,7 @@ rb_grn_hash_s_create (int argc, VALUE *argv, VALUE klass)
     table = grn_table_create(context, name, name_size, path,
                              flags, key_type, value_type);
     if (!table)
-        rb_grn_context_check(context, rb_ary_new4(argc, argv));
+        rb_grn_context_check(context, rb_ary_new_from_values(argc, argv));
     rb_table = GRNOBJECT2RVAL(klass, context, table, GRN_TRUE);
 
     if (!NIL_P(rb_default_tokenizer))

data/ext/groonga/rb-grn-index-column.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -181,7 +181,7 @@ rb_grn_index_column_inspect (VALUE self)
 {
     VALUE inspected;
 
-    inspected = rb_str_new2("");
+    inspected = rb_str_new_cstr("");
     rb_grn_object_inspect_header(self, inspected);
     rb_grn_object_inspect_content(self, inspected);
     rb_grn_index_column_inspect_content(self, inspected);
@@ -588,7 +588,7 @@ resolve_source_id (grn_ctx *context, grn_obj *column, grn_id range_id,
 {
     grn_id source_id;
 
-    if (CBOOL2RVAL(rb_obj_is_kind_of(rb_source, rb_cInteger))) {
+    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_source, rb_cInteger))) {
         source_id = NUM2UINT(rb_source);
     } else {
         grn_obj *source;
@@ -709,7 +709,7 @@ static VALUE
 rb_grn_index_column_set_source (VALUE self, VALUE rb_source)
 {
     if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_source, rb_cArray)))
-        rb_source = rb_ary_new3(1, rb_source);
+        rb_source = rb_ary_new_from_args(1, rb_source);
 
     return rb_grn_index_column_set_sources(self, rb_source);
 }
@@ -796,6 +796,7 @@ rb_grn_index_column_search (int argc, VALUE *argv, VALUE self)
 
     operator = RVAL2GRNOPERATOR(rb_operator);
 
+    memset(&options, 0, sizeof(grn_search_optarg));
     if (NIL_P(rb_mode)) {
         options.mode = GRN_OP_EXACT;
     } else {
@@ -956,7 +957,8 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
 }
 
 /*
- * Estimates the number of documents found by the given token ID.
+ * Estimates the number of documents found by the given token ID,
+ * query or lexicon cursor.
  *
  * @example Token ID style
  *    # Define schema
@@ -1020,21 +1022,109 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
  *    p @index.estimate_size(@terms["fast"])    # => 7
  *    p @index.estimate_size(@terms["Groonga"]) # => 1
  *
+ * @example Query style
+ *    # Define schema
+ *    Groonga::Schema.define do |schema|
+ *      schema.create_table("Articles") do |table|
+ *        table.text("content")
+ *      end
+ *
+ *      schema.create_table("Terms",
+ *                          :type => :hash,
+ *                          :key_type => "ShortText",
+ *                          :default_tokenizer => "TokenBigramSplitSymbolAlpha",
+ *                          :normalizer => "NormalizerAuto") do |table|
+ *        table.index("Articles.content",
+ *                    :name => "articles_content",
+ *                    :with_position => true,
+ *                    :with_section => true)
+ *      end
+ *    end
+ *    articles = Groonga["Articles"]
+ *    index = Groonga["Terms.articles_content"]
+ *
+ *    # Add data
+ *    articles.add(:content => "Groonga is fast")
+ *    articles.add(:content => "Rroonga is fast")
+ *    articles.add(:content => "Mroonga is fast")
+ *
+ *    # Estimate the number of documents found by query
+ *    p @index.estimate_size("roonga") # => 6
+ *
+ * @example Lexicon cursor style
+ *    # Define schema
+ *    Groonga::Schema.define do |schema|
+ *      schema.create_table("Memos",
+ *                          :type => :hash,
+ *                          :key_type => "ShortText") do |table|
+ *        table.short_text("tags", :type => :vector)
+ *      end
+ *
+ *      schema.create_table("Tags",
+ *                          :type => :patricia_trie,
+ *                          :key_type => "ShortText") do |table|
+ *        table.index("Memos.tags",
+ *                    :name => "memos_tags")
+ *      end
+ *    end
+ *    memos = Groonga["Memos"]
+ *    tags = Groonga["Tags"]
+ *    index = Groonga["Tags.memos_tags"]
+ *
+ *    # Add data
+ *    memos.add(:tags => ["Groonga"])
+ *    memos.add(:tags => ["Rroonga", "Ruby"])
+ *    memos.add(:tags => ["grndump", "Rroonga"])
+ *
+ *    # Estimate the number of documents found by lexicon cursor
+ *    # Iterates tags that start with "R".
+ *    tags.open_prefix_cursor("R") do |cursor|
+ *      # The cursor iterates "Rroonga" and "Ruby".
+ *      p index.estimate_size(cursor) # => 6
+ *    end
+ *
  * @overload estimate_size(token_id)
- *   @param [Integer, Record] token_id The token ID to be estimated.
+ *   @param token_id [Integer, Record] The token ID to be estimated.
  *   @return [Integer] The estimated number of documents found by the
  *     given token ID.
  *
+ * @overload estimate_size(query, options={})
+ *   @param query [String] The query to be estimated.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Operator, String, Symbol] :mode
+ *     (Groonga::Operator::EXACT)
+ *
+ *     The operation mode for search. It must be one of the followings:
+ *
+ *       * `Groonga::Operator::EXACT`, `"exact"`, `:exact`
+ *       * `Groonga::Operator::NEAR`, `"near"`, `:near`
+ *       * `Groonga::Operator::NEAR2`, `"near2"`, `:near2`
+ *       * `Groonga::Operator::SIMILAR`, `"similar"`, `:similar`
+ *       * `Groonga::Operator::REGEXP`, `"regexp"`, `:regexp`
+ *
+ *   @return [Integer] The estimated number of documents found by the
+ *     given query.
+ *
+ *   @since 5.0.1
+ *
+ * @overload estimate_size(lexicon_cursor)
+ *   @param lexicon_cursor [Groonga::TableCursor] The cursor for lexicon.
+ *   @return [Integer] The estimated number of documents found by term IDS
+ *     in the given lexicon cursor.
+ *
+ *   @since 5.0.1
+ *
  * @since 4.0.7
  */
 static VALUE
-rb_grn_index_column_estimate_size (VALUE self, VALUE rb_token_id)
+rb_grn_index_column_estimate_size (int argc, VALUE *argv, VALUE self)
 {
     grn_ctx *context;
     grn_obj *column;
     grn_obj *domain_object;
-    grn_id token_id;
     unsigned int size;
+    VALUE rb_target;
+    VALUE rb_options;
 
     rb_grn_index_column_deconstruct(SELF(self), &column, &context,
                                     NULL, &domain_object,
@@ -1042,8 +1132,57 @@ rb_grn_index_column_estimate_size (VALUE self, VALUE rb_token_id)
                                     NULL, NULL,
                                     NULL, NULL);
 
-    token_id = RVAL2GRNID(rb_token_id, context, domain_object, self);
-    size = grn_ii_estimate_size(context, (grn_ii *)column, token_id);
+    rb_scan_args(argc, argv, "11", &rb_target, &rb_options);
+
+    if (TYPE(rb_target) == T_STRING) {
+        const char *query;
+        unsigned int query_length;
+        grn_search_optarg options;
+        VALUE rb_mode;
+
+        query = StringValueCStr(rb_target);
+        query_length = RSTRING_LEN(rb_target);
+
+        rb_grn_scan_options(rb_options,
+                            "mode", &rb_mode,
+                            NULL);
+
+        memset(&options, 0, sizeof(grn_search_optarg));
+        if (NIL_P(rb_mode)) {
+            options.mode = GRN_OP_EXACT;
+        } else {
+            options.mode = RVAL2GRNOPERATOR(rb_mode);
+        }
+        switch (options.mode) {
+        case GRN_OP_EXACT:
+        case GRN_OP_NEAR:
+        case GRN_OP_NEAR2:
+        case GRN_OP_SIMILAR:
+        case GRN_OP_REGEXP:
+            /* valid */
+            break;
+        default:
+            rb_raise(rb_eArgError,
+                     ":mode must be one of "
+                     "nil, :exact, :near, :near2, :similar or :regexp: <%s>",
+                     rb_grn_inspect(rb_mode));
+            break;
+        }
+
+        size = grn_ii_estimate_size_for_query(context, (grn_ii *)column,
+                                              query, query_length, &options);
+    } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_target, rb_cGrnTableCursor))) {
+        grn_table_cursor *lexicon_cursor;
+
+        lexicon_cursor = RVAL2GRNTABLECURSOR(rb_target, &context);
+        size = grn_ii_estimate_size_for_lexicon_cursor(context,
+                                                       (grn_ii *)column,
+                                                       lexicon_cursor);
+    } else {
+        grn_id token_id;
+        token_id = RVAL2GRNID(rb_target, context, domain_object, self);
+        size = grn_ii_estimate_size(context, (grn_ii *)column, token_id);
+    }
 
     return UINT2NUM(size);
 }
@@ -1085,5 +1224,5 @@ rb_grn_init_index_column (VALUE mGrn)
                      rb_grn_index_column_open_cursor, -1);
 
     rb_define_method(rb_cGrnIndexColumn, "estimate_size",
-                     rb_grn_index_column_estimate_size, 1);
+                     rb_grn_index_column_estimate_size, -1);
 }

data/ext/groonga/rb-grn-less-equal-operator.c

@@ -0,0 +1,88 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2015  Kouhei Sutou <kou@clear-code.com>
+
+  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
+*/
+
+#include "rb-grn.h"
+
+VALUE rb_cGrnLessEqualOperator;
+
+/*
+ * Executes a less-or-equal operation.
+ *
+ * @example Executes less-or-equal operations with the default context
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 1) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 2) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(2, 1) # => false
+ *
+ * @example Executes less-or-equal operations with the specified context
+ *   context = Groonga::Context.new
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 1,
+ *                                      :context => context) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(1, 2,
+ *                                      :context => context) # => true
+ *   Groonga::Operator::LESS_EQUAL.exec(2, 1,
+ *                                      :context => context) # => false
+ *
+ * @overload exec(x, y, options={})
+ *   @param x [::Object] The left hand side value.
+ *   @param y [::Object] The right hand side value.
+ *   @param options [::Hash] The options.
+ *   @option options [Groonga::Context] (Groonga::Context.default)
+ *      The context to executes the operation.
+ *   @return [Boolean] `true` if `x` is less than or equal to`y`,
+ *      `false` otherwise.
+ */
+static VALUE
+rb_grn_less_equal_operator_exec (int argc, VALUE *argv, VALUE self)
+{
+    grn_bool less_equal;
+    VALUE rb_x;
+    VALUE rb_y;
+    VALUE rb_options;
+    VALUE rb_context;
+    grn_ctx *context;
+    grn_obj x;
+    grn_obj y;
+
+    rb_scan_args(argc, argv, "21", &rb_x, &rb_y, &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "context", &rb_context,
+                        NULL);
+    context = rb_grn_context_ensure(&rb_context);
+
+    GRN_VOID_INIT(&x);
+    GRN_VOID_INIT(&y);
+    RVAL2GRNBULK(rb_x, context, &x);
+    RVAL2GRNBULK(rb_y, context, &y);
+    less_equal = grn_operator_exec_less_equal(context, &x, &y);
+    GRN_OBJ_FIN(context, &x);
+    GRN_OBJ_FIN(context, &y);
+
+    return CBOOL2RVAL(less_equal);
+}
+
+void
+rb_grn_init_less_equal_operator (VALUE mGrn)
+{
+    rb_cGrnLessEqualOperator = rb_define_class_under(mGrn,
+                                                     "LessEqualOperator",
+                                                     rb_cGrnOperator);
+
+    rb_define_method(rb_cGrnLessEqualOperator, "exec",
+                     rb_grn_less_equal_operator_exec, -1);
+}