rroonga 6.1.3-x64-mingw32 → 7.0.2-x64-mingw32

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-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2017  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
@@ -54,11 +54,18 @@ void
 rb_grn_index_column_bind (RbGrnIndexColumn *rb_grn_index_column,
                           grn_ctx *context, grn_obj *column)
 {
+    RbGrnColumn *rb_grn_column;
     RbGrnObject *rb_grn_object;
 
-    rb_grn_column_bind(RB_GRN_COLUMN(rb_grn_index_column), context, column);
-    rb_grn_object = RB_GRN_OBJECT(rb_grn_index_column);
+    rb_grn_column = RB_GRN_COLUMN(rb_grn_index_column);
+    rb_grn_column_bind(rb_grn_column, context, column);
+
+    grn_obj_reinit(context,
+                   rb_grn_column->value,
+                   GRN_DB_UINT32,
+                   0);
 
+    rb_grn_object = RB_GRN_OBJECT(rb_grn_index_column);
     rb_grn_index_column->old_value = grn_obj_open(context, GRN_BULK, 0,
                                                   rb_grn_object->range_id);
     rb_grn_index_column->set_value =
@@ -191,6 +198,38 @@ rb_grn_index_column_inspect (VALUE self)
     return inspected;
 }
 
+static VALUE
+rb_grn_index_column_array_reference (VALUE self, VALUE rb_token)
+{
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_obj *domain;
+    grn_id token_id;
+    grn_obj *value;
+    VALUE rb_value;
+
+    rb_grn_index_column_deconstruct(SELF(self),
+                                    &column,
+                                    &context,
+                                    NULL,
+                                    &domain,
+                                    &value,
+                                    NULL,
+                                    NULL,
+                                    NULL,
+                                    NULL,
+                                    NULL,
+                                    NULL);
+
+    token_id = RVAL2GRNID(rb_token, context, domain, self);
+    GRN_BULK_REWIND(value);
+    grn_obj_get_value(context, column, token_id, value);
+    rb_grn_context_check(context, self);
+    rb_value = GRNVALUE2RVAL(context, value, NULL, self);
+
+    return rb_value;
+}
+
 /*
  * Adds a record that has @value@ content to inverted index for fast
  * fulltext serach. Normally, this method is not used
@@ -933,6 +972,12 @@ rb_grn_index_column_medium_p (VALUE self)
     return CBOOL2RVAL(flags & GRN_OBJ_INDEX_MEDIUM);
 }
 
+static VALUE
+call_close (VALUE object)
+{
+    return rb_funcall(object, rb_intern("close"), 0);
+}
+
 /*
  * Opens cursor to iterate posting in the index column.
  *
@@ -958,13 +1003,14 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
     grn_ctx          *context;
     grn_obj          *column;
     grn_column_flags  column_flags;
+    grn_obj          *domain_object;
     grn_obj          *range_object;
-    grn_table_cursor *table_cursor;
+    grn_table_cursor *table_cursor = NULL;
+    grn_id            token_id = GRN_ID_NIL;
     grn_id            rid_min = GRN_ID_NIL;
     grn_id            rid_max = GRN_ID_MAX;
     int               flags   = 0;
-    grn_obj          *index_cursor;
-    VALUE             rb_table_cursor;
+    VALUE             rb_table_cursor_or_token;
     VALUE             options;
     VALUE             rb_with_section, rb_with_weight, rb_with_position;
     VALUE             rb_table;
@@ -972,21 +1018,28 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
     VALUE             rb_cursor;
 
     rb_grn_index_column_deconstruct(SELF(self), &column, &context,
-                                    NULL, NULL,
+                                    NULL, &domain_object,
                                     NULL, NULL, NULL,
                                     NULL, &range_object,
                                     NULL, NULL);
 
-    rb_scan_args(argc, argv, "11", &rb_table_cursor, &options);
+    rb_scan_args(argc, argv, "11", &rb_table_cursor_or_token, &options);
     rb_grn_scan_options(options,
                         "with_section", &rb_with_section,
                         "with_weight", &rb_with_weight,
                         "with_position", &rb_with_position,
                         NULL);
 
-    table_cursor = RVAL2GRNTABLECURSOR(rb_table_cursor, NULL);
     rb_table     = GRNOBJECT2RVAL(Qnil, context, range_object, GRN_FALSE);
-    rb_lexicon   = rb_iv_get(rb_table_cursor, "@table");
+    rb_lexicon   = rb_funcall(self, rb_intern("table"), 0);
+    if (CBOOL2RVAL(rb_obj_is_kind_of(rb_table_cursor_or_token,
+                                     rb_cGrnTableCursor))) {
+        VALUE rb_table_cursor = rb_table_cursor_or_token;
+        table_cursor = RVAL2GRNTABLECURSOR(rb_table_cursor, NULL);
+    } else {
+        VALUE rb_token = rb_table_cursor_or_token;
+        token_id = RVAL2GRNID(rb_token, context, domain_object, self);
+    }
 
     column_flags = grn_column_get_flags(context, column);
 
@@ -1008,13 +1061,34 @@ rb_grn_index_column_open_cursor (int argc, VALUE *argv, VALUE self)
         flags |= GRN_OBJ_WITH_POSITION;
     }
 
-    index_cursor = grn_index_cursor_open(context, table_cursor,
-                                         column, rid_min, rid_max, flags);
-
-    rb_cursor = GRNINDEXCURSOR2RVAL(context, index_cursor, rb_table, rb_lexicon);
+    if (table_cursor) {
+        grn_obj *index_cursor;
+        index_cursor = grn_index_cursor_open(context, table_cursor,
+                                             column, rid_min, rid_max, flags);
+        rb_cursor = GRNINDEXCURSOR2RVAL(context,
+                                        index_cursor,
+                                        rb_table,
+                                        rb_lexicon);
+    } else {
+        grn_ii *ii = (grn_ii *)column;
+        grn_ii_cursor *ii_cursor;
+        ii_cursor = grn_ii_cursor_open(context,
+                                       ii,
+                                       token_id,
+                                       rid_min,
+                                       rid_max,
+                                       grn_ii_get_n_elements(context, ii),
+                                       flags);
+        rb_cursor = rb_grn_inverted_index_cursor_to_ruby_object(context,
+                                                                ii_cursor,
+                                                                token_id,
+                                                                flags,
+                                                                rb_table,
+                                                                rb_lexicon);
+    }
 
     if (rb_block_given_p())
-        return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);
+        return rb_ensure(rb_yield, rb_cursor, call_close, rb_cursor);
     else
         return rb_cursor;
 }
@@ -1337,6 +1411,10 @@ rb_grn_init_index_column (VALUE mGrn)
     rb_define_method(rb_cGrnIndexColumn, "inspect",
                      rb_grn_index_column_inspect, 0);
 
+    rb_define_method(rb_cGrnIndexColumn, "[]",
+                     rb_grn_index_column_array_reference, 1);
+    rb_undef_method(rb_cGrnIndexColumn, "[]=");
+
     rb_define_method(rb_cGrnIndexColumn, "add",
                      rb_grn_index_column_add, -1);
     rb_define_method(rb_cGrnIndexColumn, "delete",

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);