rroonga 6.1.3 → 7.0.2

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

@@ -0,0 +1,269 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2017  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"
+
+#define SELF(object) ((RbGrnInvertedIndexCursor *)DATA_PTR(object))
+
+typedef struct _RbGrnInvertedIndexCursor RbGrnInvertedIndexCursor;
+struct _RbGrnInvertedIndexCursor
+{
+    VALUE self;
+    grn_ctx *context;
+    grn_ii_cursor *cursor;
+    grn_id term_id;
+    int flags;
+};
+
+static VALUE rb_cGrnInvertedIndexCursor;
+
+static void
+rb_grn_inverted_index_cursor_free(void *data)
+{
+    RbGrnInvertedIndexCursor *rb_grn_cursor = data;
+
+    if (rb_grn_cursor->context && rb_grn_cursor->cursor) {
+        grn_ii_cursor_close(rb_grn_cursor->context,
+                            rb_grn_cursor->cursor);
+    }
+    xfree(rb_grn_cursor);
+}
+
+static const rb_data_type_t rb_grn_inverted_index_cursor_type = {
+    "Groonga::InvertedIndexCursor",
+    {
+        NULL,
+        rb_grn_inverted_index_cursor_free,
+        NULL,
+    },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE
+rb_grn_inverted_index_cursor_to_ruby_object (grn_ctx *context,
+                                             grn_ii_cursor *cursor,
+                                             grn_id term_id,
+                                             int flags,
+                                             VALUE rb_table,
+                                             VALUE rb_lexicon)
+{
+    VALUE rb_cursor;
+    RbGrnInvertedIndexCursor *rb_grn_cursor;
+
+    rb_cursor = TypedData_Make_Struct(rb_cGrnInvertedIndexCursor,
+                                      RbGrnInvertedIndexCursor,
+                                      &rb_grn_inverted_index_cursor_type,
+                                      rb_grn_cursor);
+
+    rb_grn_cursor->self = rb_cursor;
+    rb_grn_cursor->context = context;
+    rb_grn_cursor->cursor = cursor;
+    rb_grn_cursor->term_id = term_id;
+    rb_grn_cursor->flags = flags;
+    rb_iv_set(rb_cursor, "@table", rb_table);
+    rb_iv_set(rb_cursor, "@lexicon", rb_lexicon);
+
+    if (rb_grn_cursor->cursor &&
+        (rb_grn_cursor->flags & GRN_OBJ_WITH_POSITION)) {
+        grn_ii_cursor_next(context, cursor);
+    }
+
+    return rb_cursor;
+}
+
+static VALUE
+next_value (VALUE rb_posting,
+            RbGrnInvertedIndexCursor *rb_grn_cursor,
+            VALUE rb_table,
+            VALUE rb_lexicon)
+{
+    grn_ctx *context = rb_grn_cursor->context;
+    grn_ii_cursor *cursor = rb_grn_cursor->cursor;
+    grn_posting *posting = NULL;
+
+    if (rb_grn_cursor->flags & GRN_OBJ_WITH_POSITION) {
+        posting = grn_ii_cursor_next_pos(context, cursor);
+        while (!posting && grn_ii_cursor_next(context, cursor)) {
+            posting = grn_ii_cursor_next_pos(context, cursor);
+            break;
+        }
+    } else {
+        posting = grn_ii_cursor_next(context, cursor);
+    }
+    if (!posting) {
+        return Qnil;
+    }
+
+    if (NIL_P(rb_posting)) {
+        return rb_grn_posting_new(posting,
+                                  rb_grn_cursor->term_id,
+                                  rb_table,
+                                  rb_lexicon);
+    } else {
+        rb_grn_posting_update(rb_posting,
+                              posting,
+                              rb_grn_cursor->term_id);
+        return rb_posting;
+    }
+}
+
+static VALUE
+rb_grn_inverted_index_cursor_next (VALUE self)
+{
+    RbGrnInvertedIndexCursor *rb_grn_cursor;
+    VALUE rb_table;
+    VALUE rb_lexicon;
+    VALUE rb_posting;
+
+    TypedData_Get_Struct(self,
+                         RbGrnInvertedIndexCursor,
+                         &rb_grn_inverted_index_cursor_type,
+                         rb_grn_cursor);
+    if (!rb_grn_cursor->context) {
+        rb_raise(rb_eGrnClosed,
+                 "can't access already closed Groonga object: %" PRIsVALUE,
+                 self);
+    }
+
+    if (!rb_grn_cursor->cursor) {
+        return Qnil;
+    }
+
+    rb_table = rb_iv_get(self, "@table");
+    rb_lexicon = rb_iv_get(self, "@lexicon");
+    rb_posting = next_value(Qnil, rb_grn_cursor, rb_table, rb_lexicon);
+
+    return rb_posting;
+
+}
+
+static VALUE
+rb_grn_inverted_index_cursor_each (int argc, VALUE *argv, VALUE self)
+{
+    RbGrnInvertedIndexCursor *rb_grn_cursor;
+    grn_bool reuse_posting_object;
+    VALUE rb_options;
+    VALUE rb_reuse_posting_object;
+    VALUE rb_table;
+    VALUE rb_lexicon;
+    VALUE rb_posting = Qnil;
+
+    RETURN_ENUMERATOR(self, argc, argv);
+
+    rb_scan_args(argc, argv, "01", &rb_options);
+
+    rb_grn_scan_options(rb_options,
+                        "reuse_posting_object", &rb_reuse_posting_object,
+                        NULL);
+
+    TypedData_Get_Struct(self,
+                         RbGrnInvertedIndexCursor,
+                         &rb_grn_inverted_index_cursor_type,
+                         rb_grn_cursor);
+    if (!rb_grn_cursor->context) {
+        rb_raise(rb_eGrnClosed,
+                 "can't access already closed Groonga object: %" PRIsVALUE,
+                 self);
+    }
+
+    if (!rb_grn_cursor->cursor) {
+        return Qnil;
+    }
+
+    rb_table = rb_iv_get(self, "@table");
+    rb_lexicon = rb_iv_get(self, "@lexicon");
+    reuse_posting_object = RVAL2CBOOL(rb_reuse_posting_object);
+
+    if (reuse_posting_object) {
+        rb_posting = rb_grn_posting_new(NULL, GRN_ID_NIL, rb_table, rb_lexicon);
+    }
+    while (GRN_TRUE) {
+        if (!reuse_posting_object) {
+            rb_posting = Qnil;
+        }
+        rb_posting = next_value(rb_posting, rb_grn_cursor, rb_table, rb_lexicon);
+        if (NIL_P(rb_posting)) {
+            break;
+        }
+        rb_yield(rb_posting);
+    }
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_inverted_index_cursor_close (VALUE self)
+{
+    RbGrnInvertedIndexCursor *rb_grn_cursor;
+
+    TypedData_Get_Struct(self,
+                         RbGrnInvertedIndexCursor,
+                         &rb_grn_inverted_index_cursor_type,
+                         rb_grn_cursor);
+    if (!rb_grn_cursor->context) {
+        rb_raise(rb_eGrnClosed,
+                 "can't access already closed Groonga object: %" PRIsVALUE,
+                 self);
+    }
+
+    if (rb_grn_cursor->cursor) {
+        grn_ii_cursor_close(rb_grn_cursor->context,
+                            rb_grn_cursor->cursor);
+    }
+    rb_grn_cursor->context = NULL;
+    rb_grn_cursor->cursor = NULL;
+
+    return Qnil;
+
+}
+
+static VALUE
+rb_grn_inverted_index_cursor_is_closed (VALUE self)
+{
+    RbGrnInvertedIndexCursor *rb_grn_cursor;
+
+    TypedData_Get_Struct(self,
+                         RbGrnInvertedIndexCursor,
+                         &rb_grn_inverted_index_cursor_type,
+                         rb_grn_cursor);
+    if (rb_grn_cursor->context) {
+        return Qfalse;
+    } else {
+        return Qtrue;
+    }
+
+}
+
+void
+rb_grn_init_inverted_index_cursor (VALUE mGrn)
+{
+    rb_cGrnInvertedIndexCursor =
+      rb_define_class_under(mGrn, "InvertedIndexCursor", rb_cData);
+    rb_include_module(rb_cGrnInvertedIndexCursor, rb_mEnumerable);
+
+    rb_define_method(rb_cGrnInvertedIndexCursor, "next",
+                     rb_grn_inverted_index_cursor_next, 0);
+    rb_define_method(rb_cGrnInvertedIndexCursor, "each",
+                     rb_grn_inverted_index_cursor_each, -1);
+    rb_define_method(rb_cGrnInvertedIndexCursor, "close",
+                     rb_grn_inverted_index_cursor_close, 0);
+    rb_define_method(rb_cGrnInvertedIndexCursor, "closed?",
+                     rb_grn_inverted_index_cursor_is_closed, 0);
+}

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

@@ -1973,7 +1973,7 @@ rb_grn_object_dirty_p (VALUE self)
 void
 rb_grn_init_object (VALUE mGrn)
 {
-    rb_cGrnObject = rb_define_class_under(mGrn, "Object", rb_cObject);
+    rb_cGrnObject = rb_define_class_under(mGrn, "Object", rb_cData);
     rb_define_alloc_func(rb_cGrnObject, rb_grn_object_alloc);
 
     rb_define_attr(rb_cGrnObject, "context", GRN_TRUE, GRN_FALSE);

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

@@ -245,7 +245,7 @@ rb_grn_plugin_s_names (int argc, VALUE *argv, VALUE klass)
 void
 rb_grn_init_plugin (VALUE mGrn)
 {
-    cGrnPlugin = rb_define_class_under(mGrn, "Plugin", rb_cObject);
+    cGrnPlugin = rb_define_class_under(mGrn, "Plugin", rb_cData);
     rb_define_alloc_func(cGrnPlugin, rb_grn_plugin_alloc);
 
     rb_define_singleton_method(cGrnPlugin, "register",

data/ext/groonga/rb-grn-table-cursor.c

@@ -277,7 +277,7 @@ rb_grn_table_cursor_each (VALUE self)
 void
 rb_grn_init_table_cursor (VALUE mGrn)
 {
-    rb_cGrnTableCursor = rb_define_class_under(mGrn, "TableCursor", rb_cObject);
+    rb_cGrnTableCursor = rb_define_class_under(mGrn, "TableCursor", rb_cData);
     rb_define_alloc_func(rb_cGrnTableCursor, rb_grn_object_alloc);
 
     rb_include_module(rb_cGrnTableCursor, rb_mEnumerable);

data/ext/groonga/rb-grn-table-key-support.c

@@ -356,7 +356,11 @@ rb_grn_table_key_support_get_key (VALUE self, VALUE rb_id)
 /*
  * テーブルに主キーが _key_ のレコードがあるならtrueを返す。
  *
+ * @overload key?(key)
+ *    @since 7.0.0
+ *
  * @overload has_key?(key)
+ *    @deprecated Use {key?} instead.
  */
 static VALUE
 rb_grn_table_key_support_has_key (VALUE self, VALUE rb_key)
@@ -1123,6 +1127,8 @@ rb_grn_init_table_key_support (VALUE mGrn)
                      rb_grn_table_key_support_get_id, -1);
     rb_define_method(rb_mGrnTableKeySupport, "key",
                      rb_grn_table_key_support_get_key, 1);
+    rb_define_method(rb_mGrnTableKeySupport, "key?",
+                     rb_grn_table_key_support_has_key, 1);
     rb_define_method(rb_mGrnTableKeySupport, "has_key?",
                      rb_grn_table_key_support_has_key, 1);
 

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

@@ -1377,9 +1377,6 @@ rb_grn_table_geo_sort (int argc, VALUE *argv, VALUE self)
         offset = NUM2INT(rb_offset);
     if (!NIL_P(rb_limit))
         limit = NUM2INT(rb_limit);
-    /* TODO: Remove me when Groonga 5.1.0 is released. */
-    if (limit < 0)
-        limit = grn_table_size(context, table) + limit + 1;
 
     result = grn_table_create(context, NULL, 0, NULL, GRN_TABLE_NO_KEY,
                               NULL, table);

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

@@ -1061,13 +1061,37 @@ rb_grn_value_to_ruby_object (grn_ctx *context,
 
 grn_id
 rb_grn_id_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *table,
-                            VALUE related_object)
+                            VALUE rb_related_object)
 {
     VALUE rb_id;
 
     if (NIL_P(object))
         return Qnil;
 
+    if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnRecord)) &&
+        !RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cInteger))) {
+        VALUE rb_record;
+        if (table) {
+            VALUE rb_table;
+            rb_table = GRNOBJECT2RVAL(Qnil, context, table, GRN_FALSE);
+            if (!NIL_P(rb_table) &&
+                RVAL2CBOOL(rb_obj_is_kind_of(rb_table,
+                                             rb_mGrnTableKeySupport))) {
+                rb_record = rb_funcall(rb_table, rb_intern("[]"), 1, object);
+                if (NIL_P(rb_record)) {
+                    rb_raise(rb_eArgError,
+                             "nonexistent key: %" PRIsVALUE
+                             ": %" PRIsVALUE
+                             ": %" PRIsVALUE,
+                             object,
+                             rb_table,
+                             rb_related_object);
+                }
+                object = rb_record;
+            }
+        }
+    }
+
     if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnRecord))) {
         VALUE rb_table;
         rb_table = rb_funcall(object, rb_intern("table"), 0);
@@ -1077,9 +1101,12 @@ rb_grn_id_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *table,
             rb_expected_table =
                 GRNOBJECT2RVAL(Qnil, context, table, GRN_FALSE);
             rb_raise(rb_eGrnError,
-                     "wrong table: expected <%s>: actual <%s>",
-                     rb_grn_inspect(rb_expected_table),
-                     rb_grn_inspect(rb_table));
+                     "wrong table: expected %" PRIsVALUE
+                     ": actual %" PRIsVALUE
+                     ": %" PRIsVALUE,
+                     rb_expected_table,
+                     rb_table,
+                     rb_related_object);
         }
         rb_id = rb_funcall(object, rb_intern("id"), 0);
     } else {
@@ -1088,9 +1115,10 @@ rb_grn_id_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *table,
 
     if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_id, rb_cInteger)))
         rb_raise(rb_eGrnError,
-                 "should be unsigned integer or Groogna::Record: <%s>: <%s>",
-                 rb_grn_inspect(object),
-                 rb_grn_inspect(related_object));
+                 "should be unsigned integer or Groogna::Record: %" PRIsVALUE
+                 ": %" PRIsVALUE,
+                 object,
+                 rb_related_object);
 
     return NUM2UINT(rb_id);
 }

data/ext/groonga/rb-grn.h

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2017  Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2015-2017  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -97,9 +97,9 @@ RB_GRN_BEGIN_DECLS
 #  define debug(...)
 #endif
 
-#define RB_GRN_MAJOR_VERSION 6
-#define RB_GRN_MINOR_VERSION 1
-#define RB_GRN_MICRO_VERSION 3
+#define RB_GRN_MAJOR_VERSION 7
+#define RB_GRN_MINOR_VERSION 0
+#define RB_GRN_MICRO_VERSION 2
 
 #define RB_GRN_OBJECT(object) ((RbGrnObject *)(object))
 #define RB_GRN_NAMED_OBJECT(object) ((RbGrnNamedObject *)(object))
@@ -336,6 +336,7 @@ void           rb_grn_init_fix_size_column          (VALUE mGrn);
 void           rb_grn_init_variable_size_column     (VALUE mGrn);
 void           rb_grn_init_index_column             (VALUE mGrn);
 void           rb_grn_init_index_cursor             (VALUE mGrn);
+void           rb_grn_init_inverted_index_cursor    (VALUE mGrn);
 void           rb_grn_init_posting                  (VALUE mGrn);
 void           rb_grn_init_accessor                 (VALUE mGrn);
 void           rb_grn_init_geo_point                (VALUE mGrn);
@@ -367,6 +368,7 @@ void           rb_grn_init_request_timer            (VALUE mGrn);
 void           rb_grn_init_request_timer_id         (VALUE mGrn);
 void           rb_grn_init_id                       (VALUE mGrn);
 void           rb_grn_init_name                     (VALUE mGrn);
+void           rb_grn_init_default_cache            (VALUE mGrn);
 
 VALUE          rb_grn_rc_to_exception               (grn_rc rc);
 void           rb_grn_rc_check                      (grn_rc rc,
@@ -825,6 +827,13 @@ VALUE          rb_grn_index_cursor_to_ruby_object   (grn_ctx *context,
                                                      VALUE rb_table,
                                                      VALUE rb_lexicon,
                                                      grn_bool owner);
+VALUE          rb_grn_inverted_index_cursor_to_ruby_object
+                                                    (grn_ctx *context,
+                                                     grn_ii_cursor *cursor,
+                                                     grn_id term_id,
+                                                     int flags,
+                                                     VALUE rb_table,
+                                                     VALUE rb_lexicon);
 
 grn_operator   rb_grn_operator_from_ruby_object     (VALUE object);
 grn_operator   rb_grn_set_operator_from_ruby_object (VALUE object);

data/ext/groonga/rb-groonga.c

@@ -229,6 +229,7 @@ Init_groonga (void)
     rb_grn_init_table(mGrn);
     rb_grn_init_table_cursor(mGrn);
     rb_grn_init_index_cursor(mGrn);
+    rb_grn_init_inverted_index_cursor(mGrn);
     rb_grn_init_posting(mGrn);
     rb_grn_init_type(mGrn);
     rb_grn_init_procedure(mGrn);
@@ -255,4 +256,5 @@ Init_groonga (void)
     rb_grn_init_request_timer_id(mGrn);
     rb_grn_init_id(mGrn);
     rb_grn_init_name(mGrn);
+    rb_grn_init_default_cache(mGrn);
 }