rroonga 7.0.2-x64-mingw32 → 7.1.1-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf0e8d2887b35e2e864b61616b13f10193e188d3
-  data.tar.gz: 2da32ffba4baa9166faaca09788867825e80cf4c
+  metadata.gz: f8e1cc467837233319b48a4a4bf9fdd5923ec27e
+  data.tar.gz: 84c364c9a6bd80e5a56b656e29731210ef494382
 SHA512:
-  metadata.gz: 6272915440a6a8271a0ba8a6b546f8936f7949b2e7d42f417fea0c97155d784bf1a48837eb99e66b41da60b93fe4519718fe8da2d608a5db7bfc60dec37611b4
-  data.tar.gz: 64b7ee7d62856107a211294e1c538bd736621d11987bfefba47e168c09a9bc417dbe103ede3b1c860632c3b06427337130462a4570aa8a468018f400d7388b61
+  metadata.gz: 6884f54a212ada8139222c21e618c9c4207314ea6509b56881dc2e9f4c1efeddf7df4643eb70a3961ae7e9f223e0a4c29233188ae09fb583bcf77e115e3ed23b
+  data.tar.gz: 3b085c4a0f0b0dc57fd28bb95059f3ea9ab9305788d7b5710ebd6e466550bfdf78f083d9d14d25f2e75636ba38717bb4e0a10447075c4ac8cec55f75f3139493

data/Rakefile

@@ -1,6 +1,6 @@
 # -*- coding: utf-8; mode: ruby -*-
 #
-# Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2018  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2017  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -158,7 +158,7 @@ windows_architectures = [:x86, :x64]
 
 namespace :build do
   namespace :windows do
-    ruby_versions = "2.1.6:2.2.2:2.3.0:2.4.0"
+    ruby_versions = "2.1.6:2.2.2:2.3.0:2.4.0:2.5.0"
 
     windows_architectures.each do |architecture|
       desc "Build gem for Windows #{architecture}"

data/doc/text/news.md

@@ -1,5 +1,44 @@
 # NEWS
 
+## 7.1.1: 2018-01-30 {#version-7-1-1}
+
+### Improvements
+
+  * Added Groonga 7.1.1 support. Groonga 7.1.0 or older aren't supported.
+
+  * Added Apache Arrow support:
+
+    * {Groonga::Table#load_arrow}
+
+    * {Groonga::Table#dump_arrow}
+
+  * Windows: Added Ruby 2.4 or later support.
+    [groonga-dev,04565][Reported by ongaeshi]
+
+  * {Groonga::ColumnCache}: Added.
+
+  * {Groonga::Expression#parse}: Added `:no_syntax_error` option.
+
+  * {Groonga::Context#support_arrow?}: Added.
+
+  * {Groonga::Procedure#stable?}: Added.
+
+  * {Groonga::Array}: Removed queue support.
+
+  * {Groonga::QueryLogger.flags}: Added.
+
+  * {Groonga::QueryLogger.flags=}: Added.
+
+  * {Groonga::Object#corrupt?}: Added.
+
+  * {Groonga::Object#disk_usage}: Added.
+
+### Thanks
+
+  * naofumi-fujii
+
+  * ongaeshi
+
 ## 7.0.2: 2017-04-29 {#version-7-0-2}
 
 ### Improvements
@@ -13,10 +52,10 @@
 
   * {Groonga::InvertedIndexCursor#closed?}: Added.
 
-  * {Groonga::TableKeySupport#key?}: Added.
+  * {Groonga::Table::KeySupport#key?}: Added.
 
-  * {Groonga::TableKeySupport#has_key?}: Deprecated. Use
-    {Groonga::TableKeySupport#key?} instead.
+  * {Groonga::Table::KeySupport#has_key?}: Deprecated. Use
+    {Groonga::Table::KeySupport#key?} instead.
 
   * {Groonga::DataColumn#apply_window_function}: Supported `:group_keys`.
 
@@ -252,7 +291,7 @@
   * Added {Groonga::Object#accessor?}.
   * Added {Groonga::Object#key_accessor?}.
   * Added {Groonga::Database#reindex}.
-  * Added {Groonga::TableKeySupport#reindex}.
+  * Added {Groonga::Table::KeySupport#reindex}.
   * Added {Groonga::FixSizeColumn#reindex}.
   * Added {Groonga::VariableSizeColumn#reindex}.
   * Added {Groonga::IndexColumn#reindex}.
@@ -1435,7 +1474,7 @@
 
 * Used :key as the default value of `:order_by` of
   `Groonga::PatriciaTrie#open_cursor`.
-* Removed a deprecated Groonga::TableKeySupport#find.
+* Removed a deprecated Groonga::Table::KeySupport#find.
 * Used ShortText as the default key type of
   Groonga::Hash#create and Groonga::PatriciaTrie#create.
 * Renamed Groonga::Schema#load to Groonga::Schema#restore.
@@ -1562,7 +1601,7 @@
   * Groonga::Table#find -> Groonga::Table#[]
   * Groonga::Table#find -> obsolete
   * Groonga::Table#[]= -> removed
-  * Groonga::TableKeySupport#[]= is alias of Groonga::TableKeySupport#add
+  * Groonga::Table::KeySupport#[]= is alias of Groonga::Table::KeySupport#add
   * Changed exception class to Groonga::NoSuchColumn from
     Groonga::InvalidArgument when Groonga::Record accesses nonexistent
     a column.
@@ -1604,7 +1643,7 @@
 
 ## 0.0.3: 2009-07-18
 
-* Added Groonga::TableKeySupport#has_key? [#26145] [Tasuku SUENAGA]
+* Added Groonga::Table::KeySupport#has_key? [#26145] [Tasuku SUENAGA]
 * Groonga::Record#[] raises an exception for nonexistent
   column name. [#26146] [Tasuku SUENAGA]
 * Supported 32bit environment [niku]

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2013  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2018  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
@@ -192,274 +192,6 @@ rb_grn_array_add (int argc, VALUE *argv, VALUE self)
     }
 }
 
-typedef struct _YieldRecordCallbackData
-{
-    VALUE self;
-    VALUE record;
-    grn_id id;
-    int status;
-} YieldRecordCallbackData;
-
-static VALUE
-yield_record (VALUE user_data)
-{
-    YieldRecordCallbackData *data = (YieldRecordCallbackData *)user_data;
-    volatile VALUE record;
-
-    if (data->id == GRN_ID_NIL) {
-        record = Qnil;
-    } else {
-        record = rb_grn_record_new(data->self, data->id, Qnil);
-    }
-    data->record = record;
-
-    return rb_yield(record);
-}
-
-static void
-yield_record_callback (grn_ctx *ctx, grn_array *array,
-                       grn_id id, void *user_data)
-{
-    YieldRecordCallbackData *data = user_data;
-
-    data->id = id;
-    rb_protect(yield_record, (VALUE)(data), &(data->status));
-}
-
-/*
- * Pushes a record to the array. The record should be filled in the
- * given block. The pushed record can be pulled by
- * {Groonga::Array#pull}.
- *
- * @example A program that pushes a job without error handling
- *   queue = Groonga::Array.create(:name => "CrawlURLQueue")
- *   queue.define_column("url", "ShortText")
- *   urls = ["http://groonga.org/", "http://ranguba.org/"]
- *   urls.each do |url|
- *     queue.push do |record|
- *       record.url = url
- *     end
- *   end
- *
- * @example A program that pulls a job without error handling
- *   queue = Groonga::Array.open(:name => "CrawlURLQueue")
- *   loop do
- *     url = nil
- *     queue.pull do |record|
- *       url = record.url
- *       record.delete
- *     end
- *     # Crawl URL
- *   end
- *
- * The record that is passed to the given block may be nil. You need
- * to handle the case. For example, just ignoring it or reports an
- * error.
- *
- * @example A program that pushes a job with error handling
- *   queue = Groonga::Array.create(:name => "CrawlURLQueue")
- *   queue.define_column("url", "ShortText")
- *   urls = ["http://groonga.org/", "http://ranguba.org/"]
- *   urls.each do |url|
- *     queue.push do |record|
- *       record.url = url if record # check record is not nil
- *     end
- *   end
- *
- * If an error is occurred in the given block, the pushed record may
- * not be filled completely. You should handle the case in pull side.
- *
- * @example A program that has an error in push block
- *   queue = Groonga::Array.create(:name => "CrawlURLQueue")
- *   queue.define_column("url", "ShortText")
- *   urls = ["http://groonga.org/", "http://ranguba.org/"]
- *   urls.each do |url|
- *     queue.push do |record|
- *       record.url = uri # Typo! It should be ur*l* not ur*i*
- *       # record.url isn't set
- *     end
- *   end
- *
- * @example A program that pulls a job with error handling
- *   queue = Groonga::Array.open(:name => "CrawlURLQueue")
- *   loop do
- *     url = nil
- *     queue.pull do |record|
- *       url = record.url # record.url is nil!
- *       record.delete
- *     end
- *     next if url.nil? # Ignore an uncompleted added job
- *     # Crawl URL
- *   end
- *
- * @overload push
- *   @yield [record] Filles columns of a pushed record in the given block.
- *   @yieldparam record [Groonga::Record or nil]
- *     A pushed record. It is nil when pushing is failed.
- *   @return [Groonga::Record or nil] A pushed record that is yielded.
- *
- */
-static VALUE
-rb_grn_array_push (VALUE self)
-{
-    grn_ctx *context = NULL;
-    grn_obj *table;
-    YieldRecordCallbackData data;
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError,
-                 "tried to call Groonga::Array#push without a block");
-    }
-
-    table = SELF(self, &context);
-
-    data.self = self;
-    data.record = Qnil;
-    data.status = 0;
-    grn_array_push(context, (grn_array *)table, yield_record_callback, &data);
-    if (data.status != 0) {
-        rb_jump_tag(data.status);
-    }
-    rb_grn_context_check(context, self);
-
-    return data.record;
-}
-
-/*
- * Pulls a record from the array. The required values should be
- * retrieved in the given block.
- *
- * If {Groonga::Array#push} failes to fill values of the pushed
- * record, the pulled record may be uncompleted. It should be handled
- * by your application.
- *
- * If you passes @:block? => true@ option, the pull operation blocks
- * until a pushed record is pushed. It is the default behavior.
- *
- * If you passes @:block? => false@ option, the pull operation returns
- * immediately, the given block isn't called and returns nil when no
- * record exist in the array.
- *
- * @example A program that pulls with non-block mode
- *   queue = Groonga::Array.open(:name => "CrawlURLQueue")
- *   loop do
- *     url = nil
- *     # The case for no pushed records in the array.
- *     pulled_record = queue.pull(:block? => false) do |record|
- *       # This block isn't called
- *       url = record.url
- *       record.delete
- *     end
- *     p pulled_record.nil? # => true
- *   end
- *
- * Note that your signal handlers can't be ran while a pull
- * operation. You need to use {Groonga::Array#unblock} from
- * another process to unblock the pull operation. If you call
- * {Groonga::Array#unblock}, signal handler can be ran.
- *
- * @example Signal handler isn't called
- *   queue = Groonga::Array.open(:name => "CrawlURLQueue")
- *   trap(:INT) do
- *     p :not_called!
- *   end
- *   queue.pull do |record|
- *     # Send SIGINT while blocking the pull operation.
- *     # The signal handler isn't called.
- *   end
- *
- * @see Groonga::Array#push Examples exist in the push documentation.
- *
- * @overload pull(options={})
- *   @param [::Hash] options The option parameters.
- *   @option options [Boolean] :block? (true)
- *     Whether the pull operation is blocked or not when no record exist
- *     in the array.
- *   @yield [record] Gets required values for a pull record in the given block.
- *   @yieldparam record [Groonga::Record or nil]
- *     A pulled record. It is nil when no records exist in the array
- *     and @block?@ parameter is not @true@.
- *   @return [Groonga::Record or nil] A pulled record that is yielded.
- *
- */
-static VALUE
-rb_grn_array_pull (int argc, VALUE *argv, VALUE self)
-{
-    grn_ctx *context = NULL;
-    grn_obj *table;
-    VALUE options;
-    VALUE rb_block_p;
-    YieldRecordCallbackData data;
-
-    rb_scan_args(argc, argv, "01", &options);
-
-    rb_grn_scan_options(options,
-                        "block?", &rb_block_p,
-                        NULL);
-
-    if (!rb_block_given_p()) {
-        rb_raise(rb_eArgError,
-                 "tried to call Groonga::Array#pull without a block");
-    }
-
-    table = SELF(self, &context);
-
-    if (NIL_P(rb_block_p)) {
-        rb_block_p = Qtrue;
-    }
-
-    data.self = self;
-    data.record = Qnil;
-    data.status = 0;
-    grn_array_pull(context, (grn_array *)table, RVAL2CBOOL(rb_block_p),
-                   yield_record_callback, &data);
-    if (data.status != 0) {
-        rb_jump_tag(data.status);
-    }
-    rb_grn_context_check(context, self);
-
-    return data.record;
-}
-
-/*
- * Unblocks all {Groonga::Array#pull} operations for the array.
- *
- * @example Pull, unblock and signal
- *   # pull.rb
- *   queue = Groonga::Array.open(:name => "CrawlURLQueue")
- *   trap(:INT) do
- *     p :called!
- *   end
- *   queue.pull do |record|
- *     # 1. Send SIGINT while blocking the pull operation.
- *     #    The signal handler isn't called.
- *     # 2. Run unblock.rb.
- *     #    The signal handler is called!
- *   end
- *
- *   # unblock.rb
- *   queue = Groonga::Array.open(:name => "CrawlURLQueue")
- *   queue.unblock
- *
- * @see Groonga::Array#pull
- *
- * @overload unblock
- *   @return [void]
- *
- */
-static VALUE
-rb_grn_array_unblock (VALUE self)
-{
-    grn_ctx *context = NULL;
-    grn_obj *table;
-
-    table = SELF(self, &context);
-
-    grn_array_unblock(context, (grn_array *)table);
-
-    return Qnil;
-}
-
 void
 rb_grn_init_array (VALUE mGrn)
 {
@@ -469,7 +201,4 @@ rb_grn_init_array (VALUE mGrn)
                                rb_grn_array_s_create, -1);
 
     rb_define_method(rb_cGrnArray, "add", rb_grn_array_add, -1);
-    rb_define_method(rb_cGrnArray, "push", rb_grn_array_push, 0);
-    rb_define_method(rb_cGrnArray, "pull", rb_grn_array_pull, -1);
-    rb_define_method(rb_cGrnArray, "unblock", rb_grn_array_unblock, 0);
 }

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

@@ -0,0 +1,240 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set sts=4 sw=4 ts=8 noet: */
+/*
+  Copyright (C) 2018  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-class: Groonga::ColumnCache
+ *
+ * This is a class for accelerating column value read.
+ *
+ * {Groonga::FixSizeColumn} is only supported for now.
+ *
+ * @since 7.1.1
+ */
+
+VALUE rb_cGrnColumnCache;
+
+static void
+rb_grn_column_cache_mark(void *data)
+{
+    RbGrnColumnCache *rb_grn_column_cache = data;
+
+    if (!rb_grn_column_cache->column_cache)
+        return;
+
+    rb_gc_mark(rb_grn_column_cache->rb_column);
+}
+
+static void
+rb_grn_column_cache_free(void *data)
+{
+    RbGrnColumnCache *rb_grn_column_cache = data;
+
+    if (!rb_grn_column_cache->column_cache)
+        return;
+
+    GRN_OBJ_FIN(rb_grn_column_cache->context,
+                &(rb_grn_column_cache->buffer));
+    grn_column_cache_close(rb_grn_column_cache->context,
+                           rb_grn_column_cache->column_cache);
+}
+
+static rb_data_type_t data_type = {
+    "Groonga::ColumnCache",
+    {
+        rb_grn_column_cache_mark,
+        rb_grn_column_cache_free,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE
+rb_grn_column_cache_allocate (VALUE klass)
+{
+    return TypedData_Wrap_Struct(klass, &data_type, NULL);
+}
+
+static VALUE rb_grn_column_cache_close (VALUE self);
+
+/*
+ * Opens a new column cache and passes to the given block. The opened
+ * column cache is closed after the given block is finished.
+ *
+ * @overload open(column) {|column_cache| ...}
+ *   @param column [Groonga::Column] The column to be cached.
+ *
+ *   @yieldparam [Groonga::ColumnCache] The opened column cache.
+ *
+ *   @return [Object] The object returned by the given block.
+ */
+static VALUE
+rb_grn_column_cache_s_open (VALUE klass, VALUE rb_column)
+{
+    VALUE rb_column_cache;
+
+    rb_column_cache = rb_funcall(klass, rb_intern("new"), 1, rb_column);
+    if (rb_block_given_p()) {
+        return rb_ensure(rb_yield, rb_column_cache,
+                         rb_grn_column_cache_close, rb_column_cache);
+    } else {
+        return rb_column_cache;
+    }
+}
+
+/*
+ * @overload initialize(column)
+ *   @param column [Groonga::Column] The column to be cached.
+ *
+ *   @return [Groonga::ColumnCache] Create a new column cache.
+ */
+static VALUE
+rb_grn_column_cache_initialize (VALUE self, VALUE rb_column)
+{
+    RbGrnColumnCache *rb_grn_column_cache;
+    grn_ctx *context;
+    grn_obj *column;
+    grn_id range_id;
+
+    rb_grn_column_cache = ALLOC(RbGrnColumnCache);
+    rb_grn_column_cache->self = self;
+    rb_grn_column_cache->context = NULL;
+    rb_grn_column_cache->rb_column = rb_column;
+    rb_grn_column_cache->column_cache = NULL;
+    DATA_PTR(self) = rb_grn_column_cache;
+
+    column = RVAL2GRNCOLUMN(rb_column, &(rb_grn_column_cache->context));
+    context = rb_grn_column_cache->context;
+    rb_grn_column_cache->column_cache = grn_column_cache_open(context, column);
+    if (!rb_grn_column_cache->column_cache) {
+        rb_raise(rb_eArgError,
+                 "failed to create column cache: %s%s%" PRIsVALUE,
+                 context->rc == GRN_SUCCESS ? "" : context->errbuf,
+                 context->rc == GRN_SUCCESS ? "" : ": ",
+                 rb_column);
+    }
+
+    range_id = grn_obj_get_range(context, column);
+    GRN_VALUE_FIX_SIZE_INIT(&(rb_grn_column_cache->buffer),
+                            GRN_OBJ_DO_SHALLOW_COPY,
+                            range_id);
+    rb_grn_column_cache->range = grn_ctx_at(context, range_id);
+    rb_grn_column_cache->table = grn_ctx_at(context, column->header.domain);
+
+    return Qnil;
+}
+
+/*
+ * @overload [](id)
+ *   @param id [Integer, Groonga::Record] The record ID for the
+ *     column value.
+ *
+ *   @return [Object] The value for the record ID.
+ */
+static VALUE
+rb_grn_column_cache_array_reference (VALUE self, VALUE rb_id)
+{
+    RbGrnColumnCache *rb_grn_column_cache;
+    grn_id id;
+    void *value;
+    size_t value_size = 0;
+
+    TypedData_Get_Struct(self,
+                         RbGrnColumnCache,
+                         &data_type,
+                         rb_grn_column_cache);
+
+    if (!rb_grn_column_cache->column_cache) {
+        return Qnil;
+    }
+
+    id = rb_grn_id_from_ruby_object(rb_id,
+                                    rb_grn_column_cache->context,
+                                    rb_grn_column_cache->table,
+                                    self);
+    value = grn_column_cache_ref(rb_grn_column_cache->context,
+                                 rb_grn_column_cache->column_cache,
+                                 id,
+                                 &value_size);
+    rb_grn_context_check(rb_grn_column_cache->context, self);
+    GRN_TEXT_SET_REF(&(rb_grn_column_cache->buffer),
+                     value,
+                     value_size);
+
+    return GRNBULK2RVAL(rb_grn_column_cache->context,
+                        &(rb_grn_column_cache->buffer),
+                        rb_grn_column_cache->range,
+                        self);
+}
+
+/*
+ * @overload close
+ *   @return [void] Close the column cache.
+ */
+static VALUE
+rb_grn_column_cache_close (VALUE self)
+{
+    RbGrnColumnCache *rb_grn_column_cache;
+
+    TypedData_Get_Struct(self,
+                         RbGrnColumnCache,
+                         &data_type,
+                         rb_grn_column_cache);
+
+    if (rb_grn_column_cache->column_cache) {
+        GRN_OBJ_FIN(rb_grn_column_cache->context,
+                    &(rb_grn_column_cache->buffer));
+        grn_column_cache_close(rb_grn_column_cache->context,
+                               rb_grn_column_cache->column_cache);
+        rb_grn_column_cache->column_cache = NULL;
+        rb_grn_context_check(rb_grn_column_cache->context, self);
+    }
+
+    return Qnil;
+}
+
+void
+rb_grn_init_column_cache (VALUE mGrn)
+{
+    rb_cGrnColumnCache =
+        rb_define_class_under(mGrn, "ColumnCache", rb_cData);
+
+    rb_define_alloc_func(rb_cGrnColumnCache, rb_grn_column_cache_allocate);
+
+    rb_define_singleton_method(rb_cGrnColumnCache,
+                               "open",
+                               rb_grn_column_cache_s_open,
+                               1);
+
+    rb_define_method(rb_cGrnColumnCache,
+                     "initialize",
+                     rb_grn_column_cache_initialize,
+                     1);
+    rb_define_method(rb_cGrnColumnCache,
+                     "[]",
+                     rb_grn_column_cache_array_reference,
+                     1);
+    rb_define_method(rb_cGrnColumnCache,
+                     "close",
+                     rb_grn_column_cache_close,
+                     0);
+}