rroonga 6.1.3 → 7.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a44ed5f4456e72a24167e4077f73fd94b242fe26
-  data.tar.gz: d5f416c9f3e0751810397e114a5adbeb046f1626
+  metadata.gz: 1349d0af1d5185ee0bdd44af2b212dcf55a28e7a
+  data.tar.gz: cfa39b3cf8128946bb1d22d9ee39bc8c39c0860c
 SHA512:
-  metadata.gz: ba25928a5113c6550972b540f269ca1ad2b5eac2ed0c72e156011332b641f722337895c2bb1dcd3ef5e73fef5c5fea8c3102f50b81dcabeb198e3c009facb370
-  data.tar.gz: 8d869ffd01942c02055cf4b5f70b97717a818a467caf9ca590dd51f190dc380f71a844bd0bb8ff958060cf2945ad19cf1b7428ba74c0ed9b5690d13c9dd7c5f2
+  metadata.gz: b4a58abe995dd332f77d4e6e36ad837469e6a9653bb3be44ed2fe297c3cfdf5c061f7a76b90de2b045454e79215ac913eb32a9d29718bbafb38dfad65bc44fd8
+  data.tar.gz: 1a89ed23b0b257a227998309d9297ccfd10fe5f14feb7d77974ce21ea9d0e34d530c6ffbf35e4fb8ff21236b1f43f7dec7dbce76c1f7f3b9c62c403306ffb875

data/doc/text/news.md

@@ -1,5 +1,33 @@
 # NEWS
 
+## 7.0.2: 2017-04-29 {#version-7-0-2}
+
+### Improvements
+
+  * Supported Groonga 7.0.2. Groonga 7.0.1 or older aren't supported.
+
+  * {Groonga::IndexColumn#open_cursor}: Supported opening a cursor by
+    token.
+
+  * {Groonga::IndexColumn#[]}: Supported a token.
+
+  * {Groonga::InvertedIndexCursor#closed?}: Added.
+
+  * {Groonga::TableKeySupport#key?}: Added.
+
+  * {Groonga::TableKeySupport#has_key?}: Deprecated. Use
+    {Groonga::TableKeySupport#key?} instead.
+
+  * {Groonga::DataColumn#apply_window_function}: Supported `:group_keys`.
+
+  * {Groonga::Column#weight_vector?}: Added.
+
+  * {Groonga::DataColumn#apply_expression}: Added.
+
+  * {Groonga::Column#data?}: Added.
+
+  * {Groonga::DefaultCache}: Added.
+
 ## 6.1.3: 2017-01-12 {#version-6-1-3}
 
 ### Improvements

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

@@ -609,12 +609,11 @@ rb_grn_column_truncate (VALUE self)
 }
 
 /*
- * _column_ が {Groonga::IndexColumn} の場合は +true+ を返し、
- * そうでない場合は +false+ を返す。
+ * @overload index?
+ *   @return [Bool] `true` if the column is an index column
+ *     ({Groonga::IndexColumn}), `false` otherwise.
  *
  * @since 1.0.5
- *
- * @overload index?
  */
 static VALUE
 rb_grn_column_index_p (VALUE self)
@@ -634,64 +633,83 @@ rb_grn_column_index_p (VALUE self)
 }
 
 /*
- * _column_ がベクターカラムの場合は +true+ を返し、
- * そうでない場合は +false+ を返す。
+ * @overload vector?
+ *   @return [Bool] `true` if the column is a vector column,
+ *     `false` otherwise.
  *
  * @since 1.0.5
- *
- * @overload vector?
  */
 static VALUE
 rb_grn_column_vector_p (VALUE self)
 {
     grn_ctx *context;
     grn_obj *column;
-    grn_column_flags flags;
-    grn_column_flags column_type;
 
     rb_grn_column_deconstruct(SELF(self), &column, &context,
                              NULL, NULL,
                              NULL, NULL, NULL);
 
-    if (column->header.type != GRN_COLUMN_VAR_SIZE) {
-        return Qfalse;
-    }
+    return CBOOL2RVAL(grn_obj_is_vector_column(context, column));
+}
 
-    flags = grn_column_get_flags(context, column);
-    column_type = (flags & GRN_OBJ_COLUMN_TYPE_MASK);
-    return CBOOL2RVAL(column_type == GRN_OBJ_COLUMN_VECTOR);
+/*
+ * @overload weight_vector?
+ *   @return [Bool] `true` if the column is a weight vector column,
+ *     `false` otherwise.
+ *
+ * @since 7.0.2
+ */
+static VALUE
+rb_grn_column_weight_vector_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *column;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                             NULL, NULL,
+                             NULL, NULL, NULL);
+
+    return CBOOL2RVAL(grn_obj_is_weight_vector_column(context, column));
 }
 
 /*
- * _column_ がスカラーカラムの場合は +true+ を返し、
- * そうでない場合は +false+ を返す。
+ * @overload scalar?
+ *   @return [Bool] `true` if the column is a scalar column,
+ *     `false` otherwise.
  *
  * @since 1.0.5
- *
- * @overload scalar?
  */
 static VALUE
 rb_grn_column_scalar_p (VALUE self)
 {
     grn_ctx *context;
     grn_obj *column;
-    grn_column_flags flags;
-    grn_column_flags column_type;
 
     rb_grn_column_deconstruct(SELF(self), &column, &context,
                              NULL, NULL,
                              NULL, NULL, NULL);
 
-    switch (column->header.type) {
-    case GRN_COLUMN_FIX_SIZE:
-        return Qtrue;
-    case GRN_COLUMN_VAR_SIZE:
-        flags = grn_column_get_flags(context, column);
-        column_type = (flags & GRN_OBJ_COLUMN_TYPE_MASK);
-        return CBOOL2RVAL(column_type == GRN_OBJ_COLUMN_SCALAR);
-    default:
-        return Qfalse;
-    }
+    return CBOOL2RVAL(grn_obj_is_scalar_column(context, column));
+}
+
+/*
+ * @overload data?
+ *   @return [Bool] `true` if the column is a data column (a scalar
+ *     column or a vector column), `false` otherwise.
+ *
+ * @since 7.0.2
+ */
+static VALUE
+rb_grn_column_data_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *column;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                             NULL, NULL,
+                             NULL, NULL, NULL);
+
+    return CBOOL2RVAL(grn_obj_is_data_column(context, column));
 }
 
 /*
@@ -842,7 +860,10 @@ rb_grn_init_column (VALUE mGrn)
     /* deprecated: backward compatibility */
     rb_define_alias(rb_cGrnColumn, "index_column?", "index?");
     rb_define_method(rb_cGrnColumn, "vector?", rb_grn_column_vector_p, 0);
+    rb_define_method(rb_cGrnColumn, "weight_vector?",
+                     rb_grn_column_weight_vector_p, 0);
     rb_define_method(rb_cGrnColumn, "scalar?", rb_grn_column_scalar_p, 0);
+    rb_define_method(rb_cGrnColumn, "data?", rb_grn_column_data_p, 0);
 
     rb_define_method(rb_cGrnColumn, "with_weight?",
                      rb_grn_column_with_weight_p, 0);

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

@@ -991,7 +991,7 @@ rb_grn_context_object_created (VALUE rb_context, VALUE rb_object)
 void
 rb_grn_init_context (VALUE mGrn)
 {
-    cGrnContext = rb_define_class_under(mGrn, "Context", rb_cObject);
+    cGrnContext = rb_define_class_under(mGrn, "Context", rb_cData);
     rb_define_alloc_func(cGrnContext, rb_grn_context_alloc);
 
     rb_cv_set(cGrnContext, "@@default", Qnil);

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

@@ -70,6 +70,9 @@ VALUE rb_cGrnDataColumn;
  * @overload apply_window_function(options={}) {|record| }
  *   @param options [::Hash] The name and value pairs.
  *   @option options [::Array<String>] :sort_keys
+ *     TODO: Description.
+ *   @option options [::Array<String>] :group_keys
+ *     TODO: Description.
  *
  *   @yield [record]
  *     It yields an object that builds expression. The block must
@@ -93,6 +96,7 @@ rb_grn_data_column_apply_window_function (int argc, VALUE *argv, VALUE self)
     grn_obj *window_function_call = NULL;
     VALUE rb_options;
     VALUE rb_sort_keys;
+    VALUE rb_group_keys;
     VALUE rb_builder;
     VALUE rb_window_function_call;
 
@@ -106,6 +110,7 @@ rb_grn_data_column_apply_window_function (int argc, VALUE *argv, VALUE self)
     rb_scan_args(argc, argv, "01", &rb_options);
     rb_grn_scan_options(rb_options,
                         "sort_keys", &rb_sort_keys,
+                        "group_keys", &rb_group_keys,
                         NULL);
 
     if (!NIL_P(rb_sort_keys)) {
@@ -126,6 +131,24 @@ rb_grn_data_column_apply_window_function (int argc, VALUE *argv, VALUE self)
                                     rb_table);
     }
 
+    if (!NIL_P(rb_group_keys)) {
+        VALUE rb_table;
+
+        if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_group_keys, rb_cArray)))
+            rb_raise(rb_eArgError, ":group_keys should be an array of key: <%s>",
+                     rb_grn_inspect(rb_group_keys));
+
+        definition.n_group_keys = RARRAY_LEN(rb_group_keys);
+        definition.group_keys = ALLOCA_N(grn_table_sort_key,
+                                         definition.n_group_keys);
+        rb_table = GRNOBJECT2RVAL(Qnil, context, table, GRN_FALSE);
+        rb_grn_table_sort_keys_fill(context,
+                                    definition.group_keys,
+                                    definition.n_group_keys,
+                                    rb_group_keys,
+                                    rb_table);
+    }
+
     rb_builder = rb_grn_record_expression_builder_new(rb_table, Qnil);
     rb_window_function_call =
         rb_grn_record_expression_builder_build(rb_builder);
@@ -144,6 +167,84 @@ rb_grn_data_column_apply_window_function (int argc, VALUE *argv, VALUE self)
     return self;
 }
 
+/*
+ * Applies the expression to all records in the table of the
+ * column. Results are stored into the column.
+ *
+ * @example Compute column values from other column values.
+ *
+ *   Groonga::Schema.define do |schema|
+ *     schema.create_table("Comments") do |table|
+ *       # The column that has base data to compute "plus1" column data.
+ *       table.uint32("base")
+ *       # The column for storing computed value with "base" column data.
+ *       table.uint32("plus1")
+ *     end
+ *   end
+ *   comments = Groonga["Comments"]
+ *   plus1 = Groonga["Comments.plus1"]
+ *
+ *   3.times do |i|
+ *     comments.add(:base => i)
+ *   end
+ *
+ *   plus1.apply_expression do |record|
+ *     # Computes "base" column value plus one.
+ *     record.base + 1
+ *   end
+ *
+ *   comments.each do |comment|
+ *     p [comment.base, comment.plus1]
+ *       # -> [0, 1]
+ *       # -> [1, 2]
+ *       # -> [2, 3]
+ *   end
+ *
+ * @overload apply_expression {|record| }
+ *
+ *   @yield [record]
+ *     It yields an object that builds expression. The block must
+ *     build an expression to be applied to all records.
+ *   @yieldparam [Groonga::RecordExpressionBuilder] record
+ *     The expression builder to create an expression.
+ *   @yieldreturn [Groonga::ExpressionBuilder]
+ *     It must be an expression.
+ *
+ * @since 7.0.2
+ */
+static VALUE
+rb_grn_data_column_apply_expression (VALUE self)
+{
+    grn_rc rc;
+    grn_ctx *context;
+    grn_obj *column;
+    grn_obj *table;
+    VALUE rb_table;
+    grn_obj *expression = NULL;
+    VALUE rb_builder;
+    VALUE rb_expression;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, &table,
+                              NULL, NULL, NULL);
+    rb_table = GRNOBJECT2RVAL(Qnil, context, table, GRN_FALSE);
+
+    rb_builder = rb_grn_record_expression_builder_new(rb_table, Qnil);
+    rb_expression = rb_grn_record_expression_builder_build(rb_builder);
+    rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_expression)),
+                              &expression, NULL,
+                              NULL, NULL, NULL, NULL);
+
+    rc = grn_table_apply_expr(context,
+                              table,
+                              column,
+                              expression);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return self;
+}
+
 void
 rb_grn_init_data_column (VALUE mGrn)
 {
@@ -151,6 +252,8 @@ rb_grn_init_data_column (VALUE mGrn)
 
     rb_define_method(rb_cGrnDataColumn, "apply_window_function",
                      rb_grn_data_column_apply_window_function, -1);
+    rb_define_method(rb_cGrnDataColumn, "apply_expression",
+                     rb_grn_data_column_apply_expression, 0);
 
     rb_grn_init_fix_size_column(mGrn);
     rb_grn_init_variable_size_column(mGrn);

data/ext/groonga/rb-grn-default-cache.c

@@ -0,0 +1,104 @@
+/* -*- 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"
+
+/*
+ * Document-module: Groonga::DefaultCache
+ *
+ * This module provides the default cache related features.
+ *
+ * @since 7.0.2
+ */
+
+/*
+ * @overload base_path
+ *   @return [String, nil] the default cache base path or `nil`.
+ *
+ * @since 7.0.2
+ */
+static VALUE
+rb_grn_default_cache_s_get_base_path (VALUE klass)
+{
+    const char *base_path;
+
+    base_path = grn_get_default_cache_base_path();
+    if (base_path) {
+        return rb_str_new_cstr(base_path);
+    } else {
+        return Qnil;
+    }
+}
+
+/*
+ * @overload base_path=(base_path)
+ *   @param base_path [String, nil] The new default cache base path.
+ *      If you specify `String`, the default cache will be persistent.
+ *      If you specify `nil`, the default cache will be just on memory.
+ *      You need to call {.reopen} to apply this change.
+ *   @return [String, nil] The `base_path` itself.
+ *
+ * @since 7.0.2
+ */
+static VALUE
+rb_grn_default_cache_s_set_base_path (VALUE klass, VALUE rb_base_path)
+{
+    if (NIL_P(rb_base_path)) {
+        grn_set_default_cache_base_path(NULL);
+    } else {
+        const char *base_path;
+        base_path = StringValueCStr(rb_base_path);
+        grn_set_default_cache_base_path(base_path);
+    }
+
+    return rb_base_path;
+}
+
+/*
+ * @overload reopen
+ *   Reopens the default cache.
+ *
+ *   @return [void]
+ *
+ * @since 7.0.2
+ */
+static VALUE
+rb_grn_default_cache_s_reopen (VALUE klass)
+{
+    grn_rc rc;
+
+    rc = grn_cache_default_reopen();
+    rb_grn_rc_check(rc, klass);
+
+    return Qnil;
+}
+
+void
+rb_grn_init_default_cache (VALUE mGrn)
+{
+    VALUE mGrnDefaultCache;
+
+    mGrnDefaultCache = rb_define_module_under(mGrn, "DefaultCache");
+
+    rb_define_singleton_method(mGrnDefaultCache, "base_path",
+                               rb_grn_default_cache_s_get_base_path, 0);
+    rb_define_singleton_method(mGrnDefaultCache, "base_path=",
+                               rb_grn_default_cache_s_set_base_path, 1);
+    rb_define_singleton_method(mGrnDefaultCache, "reopen",
+                               rb_grn_default_cache_s_reopen, 0);
+}

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",