rroonga 5.1.1-x86-mingw32 → 6.0.0-x86-mingw32

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

@@ -2,6 +2,7 @@
 /* vim: set sts=4 sw=4 ts=8 noet: */
 /*
   Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2016  Masafumi Yokoyama <yokoyama@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
@@ -709,44 +710,72 @@ rb_grn_column_with_weight_p(VALUE self)
 }
 
 /*
- * Return indexes on `column` which can execute `operator`.
- * @since 1.0.9
- * @return [Array<index_column>] Indexes on `column` which can execute `operator`.
- * @overload indexes(operator=Groonga::Operator::MATCH)
- *   @param [Groonga::Operator::XXX] operator
+ * Return indexes on `column`. If operator is specified, indexes that
+ * can executes the operator are only returned. Otherwise, all indexes
+ * are returned.
+ *
+ * Index means that index column and section.
+ *
+ * @overload find_indexes(options={})
+ *   @param options [::Hash] The name and value pairs.
+ *      Omitted names are initialized as the default value.
+ *   @option options :operator (nil) The operator that should be
+ *      executable by indexes. `nil` means that all operators.
+ *   @return [Array<Groonga::Index>] Target indexes on `column`.
+ *
+ * @since 6.0.0
  */
 static VALUE
-rb_grn_column_get_indexes (int argc, VALUE *argv, VALUE self)
+rb_grn_column_find_indexes (int argc, VALUE *argv, VALUE self)
 {
+    VALUE rb_options;
+    VALUE rb_operator;
     grn_ctx *context;
     grn_obj *column;
     grn_index_datum *index_data = NULL;
     int i, n_indexes;
-    grn_operator operator = GRN_OP_MATCH;
-    VALUE rb_operator, rb_indexes;
+    VALUE rb_indexes;
 
-    rb_scan_args(argc, argv, "01", &rb_operator);
+    rb_scan_args(argc, argv, "01", &rb_options);
+    rb_grn_scan_options(rb_options,
+                        "operator", &rb_operator,
+                        NULL);
 
     rb_grn_column_deconstruct(SELF(self), &column, &context,
-                             NULL, NULL,
-                             NULL, NULL, NULL);
+                              NULL, NULL,
+                              NULL, NULL, NULL);
 
-    if (!NIL_P(rb_operator)) {
+    if (NIL_P(rb_operator)) {
+        n_indexes = grn_column_get_all_index_data(context, column, NULL, 0);
+        if (n_indexes == 0)
+            return rb_ary_new();
+
+        index_data = xmalloc(sizeof(grn_index_datum) * n_indexes);
+        n_indexes = grn_column_get_all_index_data(context, column,
+                                                  index_data, n_indexes);
+    } else {
+        grn_operator operator;
         operator = RVAL2GRNOPERATOR(rb_operator);
+        n_indexes = grn_column_find_index_data(context, column, operator,
+                                               NULL, 0);
+        if (n_indexes == 0)
+            return rb_ary_new();
+
+        index_data = xmalloc(sizeof(grn_index_datum) * n_indexes);
+        n_indexes = grn_column_find_index_data(context, column, operator,
+                                               index_data, n_indexes);
     }
 
-    rb_indexes = rb_ary_new();
-    n_indexes = grn_column_find_index_data(context, column, operator, NULL, 0);
-    if (n_indexes == 0)
-        return rb_indexes;
-
-    index_data = xmalloc(sizeof(grn_index_datum) * n_indexes);
-    n_indexes = grn_column_find_index_data(context, column, operator,
-                                           index_data, n_indexes);
+    rb_indexes = rb_ary_new_capa(n_indexes);
     for (i = 0; i < n_indexes; i++) {
-        VALUE rb_index;
-        rb_index = GRNOBJECT2RVAL(Qnil, context, index_data[i].index, GRN_FALSE);
-        rb_ary_push(rb_indexes, rb_index);
+        VALUE rb_index_column;
+        VALUE rb_section;
+        rb_index_column = GRNOBJECT2RVAL(Qnil,
+                                         context,
+                                         index_data[i].index,
+                                         GRN_FALSE);
+        rb_section = UINT2NUM(index_data[i].section);
+        rb_ary_push(rb_indexes, rb_grn_index_new(rb_index_column, rb_section));
         grn_obj_unlink(context, index_data[i].index);
     }
     xfree(index_data);
@@ -812,7 +841,8 @@ rb_grn_init_column (VALUE mGrn)
     rb_define_method(rb_cGrnColumn, "with_weight?",
                      rb_grn_column_with_weight_p, 0);
 
-    rb_define_method(rb_cGrnColumn, "indexes", rb_grn_column_get_indexes, -1);
+    rb_define_method(rb_cGrnColumn, "find_indexes",
+                     rb_grn_column_find_indexes, -1);
 
     rb_define_method(rb_cGrnColumn, "rename", rb_grn_column_rename, 1);
 

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

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
   Copyright (C) 2015-2016  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2016  Masafumi Yokoyama <yokoyama@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
@@ -73,11 +74,9 @@ rb_grn_config_get (VALUE self, VALUE rb_key)
 
     {
         grn_rc rc;
-        /* TODO: Replace it with grn_config_get() after Groonga 5.1.2
-         * is released.*/
-        rc = grn_conf_get(context,
-                          key, key_size,
-                          &value, &value_size);
+        rc = grn_config_get(context,
+                            key, key_size,
+                            &value, &value_size);
         rb_grn_context_check(context, self);
         rb_grn_rc_check(rc, self);
     }
@@ -123,11 +122,9 @@ rb_grn_config_set (VALUE self, VALUE rb_key, VALUE rb_value)
 
     {
         grn_rc rc;
-        /* TODO: Replace it with grn_config_set() after Groonga 5.1.2
-         * is released.*/
-        rc = grn_conf_set(context,
-                          key, key_size,
-                          value, value_size);
+        rc = grn_config_set(context,
+                            key, key_size,
+                            value, value_size);
         rb_grn_context_check(context, self);
         rb_grn_rc_check(rc, self);
     }
@@ -135,16 +132,140 @@ rb_grn_config_set (VALUE self, VALUE rb_key, VALUE rb_value)
     return rb_value_original;
 }
 
+/*
+ * Deletes a configuration for key.
+ *
+ * @overload delete(key)
+ *   @param [String] key The key.
+ *
+ * @since 6.0.0
+ */
+static VALUE
+rb_grn_config_delete (VALUE self, VALUE rb_key)
+{
+    VALUE rb_context;
+    grn_ctx *context;
+    const char *key;
+    int key_size;
+
+    rb_context = rb_iv_get(self, "@context");
+    context = rb_grn_context_ensure(&rb_context);
+
+    rb_key = rb_grn_convert_to_string(rb_key);
+    key = RSTRING_PTR(rb_key);
+    key_size = RSTRING_LEN(rb_key);
+
+    {
+        grn_rc rc;
+        rc = grn_config_delete(context,
+                               key, key_size);
+        rb_grn_context_check(context, self);
+        rb_grn_rc_check(rc, self);
+    }
+
+    return Qnil;
+}
+
+typedef struct {
+    grn_ctx *context;
+    grn_obj *cursor;
+} RbGrnConfigEachData;
+
+static VALUE
+rb_grn_config_each_body (VALUE user_data)
+{
+    RbGrnConfigEachData *data = (RbGrnConfigEachData *)user_data;
+    grn_ctx *context;
+    grn_obj *cursor;
+
+    context = data->context;
+    cursor = data->cursor;
+    while (grn_config_cursor_next(context, cursor)) {
+        const char *key;
+        uint32_t key_size;
+        VALUE rb_key;
+        const char *value;
+        uint32_t value_size;
+        VALUE rb_value;
+
+        key_size = grn_config_cursor_get_key(context, cursor, &key);
+        rb_key = rb_grn_context_rb_string_new(context, key, key_size);
+        value_size = grn_config_cursor_get_value(context, cursor, &value);
+        rb_value = rb_grn_context_rb_string_new(context, value, value_size);
+
+        rb_yield_values(2, rb_key, rb_value);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_config_each_ensure (VALUE user_data)
+{
+    RbGrnConfigEachData *data = (RbGrnConfigEachData *)user_data;
+
+    grn_obj_close(data->context, data->cursor);
+
+    return Qnil;
+}
+
+/*
+ * Passes all key/value of the config to block in order.
+ *
+ * @example Shows all keys and all values of the config
+ *   context.config["rroonga.key1"] = "value1"
+ *   context.config["rroonga.key2"] = "value2"
+ *   keys = []
+ *   values = []
+ *   context.config.each do |key, value|
+ *     keys << key
+ *     values << value
+ *   end
+ *   p keys   # => ["rroonga.key1", "rroonga.key2"]
+ *   p values # => ["value1", "value2"]
+ *
+ * @overload each
+ *   @yield [key, value]
+ *   @yieldparam [String] key The configuration key
+ *   @yieldparam [String] value The value which is associated with `key`
+ *
+ * @since 6.0.0
+ */
+static VALUE
+rb_grn_config_each (VALUE self)
+{
+    VALUE rb_context;
+    RbGrnConfigEachData data;
+
+    RETURN_ENUMERATOR(self, 0, NULL);
+
+    rb_context = rb_iv_get(self, "@context");
+    data.context = rb_grn_context_ensure(&rb_context);
+
+    data.cursor = grn_config_cursor_open(data.context);
+    rb_ensure(rb_grn_config_each_body, (VALUE)&data,
+              rb_grn_config_each_ensure, (VALUE)&data);
+
+    return Qnil;
+}
+
 void
 rb_grn_init_config (VALUE mGrn)
 {
     VALUE cGrnConfig;
 
     cGrnConfig = rb_define_class_under(mGrn, "Config", rb_cObject);
+    /* For backward compatibility. */
     rb_define_const(mGrn, "Conf", cGrnConfig);
 
+    rb_include_module(cGrnConfig, rb_mEnumerable);
+
     rb_define_method(cGrnConfig, "initialize", rb_grn_config_initialize, 1);
 
     rb_define_method(cGrnConfig, "[]", rb_grn_config_get, 1);
     rb_define_method(cGrnConfig, "[]=", rb_grn_config_set, 2);
+
+    rb_define_method(cGrnConfig, "delete", rb_grn_config_delete, 1);
+
+    rb_define_method(cGrnConfig, "each", rb_grn_config_each, 0);
 }

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

@@ -302,18 +302,13 @@ rb_grn_context_rb_string_new (grn_ctx *context, const char *string, long length)
 {
     if (length < 0)
         length = strlen(string);
-#ifdef HAVE_RUBY_ENCODING_H
     return rb_enc_str_new(string, length,
                           rb_grn_encoding_to_ruby_encoding(context->encoding));
-#else
-    return rb_str_new(string, length);
-#endif
 }
 
 VALUE
 rb_grn_context_rb_string_encode (grn_ctx *context, VALUE rb_string)
 {
-#ifdef HAVE_RUBY_ENCODING_H
     int index, to_index;
     rb_encoding *encoding, *to_encoding;
     grn_encoding context_encoding;
@@ -339,7 +334,6 @@ rb_grn_context_rb_string_encode (grn_ctx *context, VALUE rb_string)
 
     rb_string = rb_str_encode(rb_string, rb_enc_from_encoding(to_encoding),
                               0, Qnil);
-#endif
     return rb_string;
 }
 
@@ -601,14 +595,10 @@ rb_grn_context_set_encoding (VALUE self, VALUE rb_encoding)
 static VALUE
 rb_grn_context_get_ruby_encoding (VALUE self)
 {
-#ifdef HAVE_RUBY_ENCODING_H
     grn_encoding encoding;
 
     encoding = GRN_CTX_GET_ENCODING(SELF(self));
     return rb_grn_encoding_to_ruby_encoding_object(encoding);
-#else
-    return Qnil;
-#endif
 }
 
 /*

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

@@ -148,7 +148,6 @@ rb_grn_encoding_to_ruby_object (grn_encoding encoding)
     return rb_encoding;
 }
 
-#ifdef HAVE_RUBY_ENCODING_H
 rb_encoding *
 rb_grn_encoding_to_ruby_encoding (grn_encoding encoding)
 {
@@ -190,7 +189,6 @@ rb_grn_encoding_to_ruby_encoding_object (grn_encoding encoding)
     rb_encoding *rb_encoding = rb_grn_encoding_to_ruby_encoding(encoding);
     return rb_enc_from_encoding(rb_encoding);
 }
-#endif
 
 /*
  * デフォルトのエンコーディングを返す。

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

@@ -203,6 +203,43 @@ rb_grn_expression_define_variable (int argc, VALUE *argv, VALUE self)
     return rb_variable;
 }
 
+/* TODO: Enable when Groonga 6.0.1 is released. */
+/*
+typedef struct
+{
+    grn_ctx *context;
+    grn_hash *hash;
+    VALUE rb_hash;
+} RbGrnHashFromRubyHashData;
+
+static int
+rb_grn_hash_from_ruby_hash_body (VALUE rb_key,
+                                 VALUE rb_value,
+                                 VALUE user_data)
+{
+    RbGrnHashFromRubyHashData *data = (RbGrnHashFromRubyHashData *)user_data;
+    grn_obj *value;
+    int added;
+
+    rb_key = rb_grn_convert_to_string(rb_key);
+
+    grn_hash_add(data->context,
+                 data->hash,
+                 RSTRING_PTR(rb_key),
+                 RSTRING_LEN(rb_key),
+                 (void **)&value,
+                 &added);
+    rb_grn_context_check(data->context, data->rb_hash);
+
+    if (added) {
+        GRN_VOID_INIT(value);
+    }
+    RVAL2GRNBULK(rb_value, data->context, value);
+
+    return ST_CONTINUE;
+}
+*/
+
 /*
  * _object_ を追加し、 _n_arguments_ 個の引数を取る _operation_ を追加する。
  *
@@ -232,9 +269,32 @@ rb_grn_expression_append_object (int argc, VALUE *argv, VALUE self)
                                   NULL, NULL,
                                   NULL, NULL, NULL);
 
-    object = RVAL2GRNOBJECT(rb_object, &context);
-    grn_expr_append_obj(context, expression, object,
-                        operation, n_arguments);
+    /* TODO: Enable when Groonga 6.0.1 is released. */
+    /*
+    if (RB_TYPE_P(rb_object, RUBY_T_HASH)) {
+        RbGrnHashFromRubyHashData data;
+        data.context = context;
+        data.hash = grn_hash_create(context, NULL,
+                                    GRN_TABLE_MAX_KEY_SIZE,
+                                    sizeof(grn_obj),
+                                    GRN_OBJ_KEY_VAR_SIZE |
+                                    GRN_OBJ_TEMPORARY |
+                                    GRN_HASH_TINY);
+        grn_expr_take_obj(context, expression, (grn_obj *)(data.hash));
+        data.rb_hash = rb_object;
+        rb_hash_foreach(rb_object,
+                        rb_grn_hash_from_ruby_hash_body,
+                        (VALUE)&data);
+        grn_expr_append_obj(context, expression, (grn_obj *)(data.hash),
+                            operation, n_arguments);
+    } else {
+    */
+        object = RVAL2GRNOBJECT(rb_object, &context);
+        grn_expr_append_obj(context, expression, object,
+                            operation, n_arguments);
+    /*
+    }
+    */
     rb_grn_context_check(context, self);
     rb_ary_push(rb_iv_get(self, "@objects"), rb_object);
 

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

@@ -0,0 +1,34 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2016  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_cGrnIndex;
+
+VALUE
+rb_grn_index_new (VALUE rb_index_column, VALUE rb_section)
+{
+    return rb_funcall(rb_cGrnIndex, rb_intern("new"), 2,
+                      rb_index_column, rb_section);
+}
+
+void
+rb_grn_init_index (VALUE mGrn)
+{
+    rb_cGrnIndex = rb_const_get(mGrn, rb_intern("Index"));
+}