rroonga 6.0.2-x64-mingw32 → 6.0.4-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8481cfd25295fb47cb6f4b963f2a9dcfe6e38b63
-  data.tar.gz: 781043b0f0e7d313cfb77c65a0bce2d76d202fc0
+  metadata.gz: 2781651e9799537024a1e83c3f45f5244adc119f
+  data.tar.gz: fc42a29984041ead28e497370b44fedbac341a55
 SHA512:
-  metadata.gz: 22a114ef30cdb07b244c7092794e47430f9c49c91c7a9a0f882d49941ff53c1d06a60ee54a0c250ab87b4ea194c2b12f45d18d5217ebd670d2e8bd39b1edfa63
-  data.tar.gz: b27ad9d22771e42295b8b60022e993eabc04a9e2745ff83ec69f33e81725438ce4b52d0c564a21dcb029b5e072f56be7db010228e14726f2e2ecc7529437934a
+  metadata.gz: f5eec9fc6dc6f3330ec63d947973d807c7bfb679eab60599a01f4453c6e451d3d24d7c13e6ea08cdfae5739cd764b61ff65c4b214808294d66d97efec42454e7
+  data.tar.gz: 9278c30f7db23ae2228400609c013a878519aeb7205eebe93bc9e36ed7b995a594b4a9628b70dbabb93142fb5ea383cb3598dee8da755230ab76860088c734f2

data/Rakefile

@@ -1,6 +1,6 @@
 # -*- coding: utf-8; mode: ruby -*-
 #
-# Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-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

data/doc/text/news.md

@@ -1,6 +1,23 @@
 # NEWS
 
-## 6.0.2 2016-05-18 {#version-6-0-2}
+## 6.0.4: 2016-06-14 {#version-6-0-4}
+
+### Improvements
+
+  * Supported Groonga 6.0.4. Groonga 6.0.3 or older aren't supported.
+
+  * {Groonga::WindowFunctionError}: Added a new error class.
+
+  * {Groonga::ProcedureType::WINDOW_FUNCTION}: Added a new procedure
+    type for window function.
+
+  * {Groonga::Object#window_function_procedure?}: Added a new
+    predicate for window function.
+
+  * {Groonga::DataColumn#apply_window_function}: Added a new
+    method to apply a window function.
+
+## 6.0.2: 2016-05-18 {#version-6-0-2}
 
 ### Improvements
 

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

@@ -846,7 +846,6 @@ rb_grn_init_column (VALUE mGrn)
 
     rb_define_method(rb_cGrnColumn, "rename", rb_grn_column_rename, 1);
 
-    rb_grn_init_fix_size_column(mGrn);
-    rb_grn_init_variable_size_column(mGrn);
+    rb_grn_init_data_column(mGrn);
     rb_grn_init_index_column(mGrn);
 }

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

@@ -0,0 +1,157 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim: set sts=4 sw=4 ts=8 noet: */
+/*
+  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"
+
+#define SELF(object) ((RbGrnColumn *)DATA_PTR(object))
+
+VALUE rb_cGrnDataColumn;
+
+/*
+ * Document-class: Groonga::DataColumn < Groonga::Column
+ *
+ * The superclass for data columns such as {Groonga::FixSizeColumn}
+ * and {Groonga::VariableSizeColumn}.
+ */
+
+/*
+ * Applies the window function to records in the table of the
+ * column. Results are stored into the column.
+ *
+ * @example Set the nth record.
+ *
+ *   Groonga::Schema.define do |schema|
+ *     schema.create_table("Comments") do |table|
+ *       # The column for storing window function result.
+ *       table.uint32("nth")
+ *     end
+ *   end
+ *   comments = Groonga["Comments"]
+ *   nth = Groonga["Comments.nth"]
+ *
+ *   5.times do
+ *     comments.add
+ *   end
+ *
+ *   options = {
+ *     # Sort by _id in descending order.
+ *     :sort_keys => [["_id", "desc"]],
+ *   }
+ *   nth.apply_window_function(options) do |record|
+ *     # record_number() returns Nth record in the sorted order.
+ *     record.call("record_number")
+ *   end
+ *
+ *   comments.each do |comment|
+ *     p [comment.id, comment.nth]
+ *       # -> [1, 5]
+ *       # -> [2, 4]
+ *       # -> [3, 3]
+ *       # -> [4, 2]
+ *       # -> [5, 1]
+ *   end
+ *
+ * @overload apply_window_function(options={}) {|record| }
+ *   @param options [::Hash] The name and value pairs.
+ *   @option options [::Array<String>] :sort_keys
+ *
+ *   @yield [record]
+ *     It yields an object that builds expression. The block must
+ *     build an expression that calls a window function.
+ *   @yieldparam [Groonga::RecordExpressionBuilder] record
+ *     The expression builder to create a window function call.
+ *   @yieldreturn [Groonga::ExpressionBuilder]
+ *     It must be an expression that calls a window function.
+ *
+ * @since 6.0.4
+ */
+static VALUE
+rb_grn_data_column_apply_window_function (int argc, VALUE *argv, VALUE self)
+{
+    grn_rc rc;
+    grn_ctx *context;
+    grn_obj *column;
+    grn_obj *table;
+    VALUE rb_table;
+    grn_window_definition definition;
+    grn_obj *window_function_call = NULL;
+    VALUE rb_options;
+    VALUE rb_sort_keys;
+    VALUE rb_builder;
+    VALUE rb_window_function_call;
+
+    rb_grn_column_deconstruct(SELF(self), &column, &context,
+                              NULL, &table,
+                              NULL, NULL, NULL);
+    rb_table = GRNOBJECT2RVAL(Qnil, context, table, GRN_FALSE);
+
+    memset(&definition, 0, sizeof(grn_window_definition));
+
+    rb_scan_args(argc, argv, "01", &rb_options);
+    rb_grn_scan_options(rb_options,
+                        "sort_keys", &rb_sort_keys,
+                        NULL);
+
+    if (!NIL_P(rb_sort_keys)) {
+        VALUE rb_table;
+
+        if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys, rb_cArray)))
+            rb_raise(rb_eArgError, ":sort_keys should be an array of key: <%s>",
+                     rb_grn_inspect(rb_sort_keys));
+
+        definition.n_sort_keys = RARRAY_LEN(rb_sort_keys);
+        definition.sort_keys = ALLOCA_N(grn_table_sort_key,
+                                        definition.n_sort_keys);
+        rb_table = GRNOBJECT2RVAL(Qnil, context, table, GRN_FALSE);
+        rb_grn_table_sort_keys_fill(context,
+                                    definition.sort_keys,
+                                    definition.n_sort_keys,
+                                    rb_sort_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);
+    rb_grn_object_deconstruct(RB_GRN_OBJECT(DATA_PTR(rb_window_function_call)),
+                              &window_function_call, NULL,
+                              NULL, NULL, NULL, NULL);
+
+    rc = grn_table_apply_window_function(context,
+                                         table,
+                                         column,
+                                         &definition,
+                                         window_function_call);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return self;
+}
+
+void
+rb_grn_init_data_column (VALUE mGrn)
+{
+    rb_cGrnDataColumn = rb_define_class_under(mGrn, "DataColumn", rb_cGrnColumn);
+
+    rb_define_method(rb_cGrnDataColumn, "apply_window_function",
+                     rb_grn_data_column_apply_window_function, -1);
+
+    rb_grn_init_fix_size_column(mGrn);
+    rb_grn_init_variable_size_column(mGrn);
+}

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

@@ -101,6 +101,7 @@ static VALUE eGrnCommandError;
 static VALUE eGrnPluginError;
 static VALUE eGrnScorerError;
 static VALUE eGrnCancel;
+static VALUE eGrnWindowFunctionError;
 
 VALUE
 rb_grn_rc_to_exception (grn_rc rc)
@@ -345,6 +346,9 @@ rb_grn_rc_to_exception (grn_rc rc)
       case GRN_CANCEL:
         exception = eGrnCancel;
         break;
+      case GRN_WINDOW_FUNCTION_ERROR:
+        exception = eGrnWindowFunctionError;
+        break;
     }
 
     if (NIL_P(exception))
@@ -596,6 +600,9 @@ rb_grn_rc_to_message (grn_rc rc)
       case GRN_CANCEL:
         message = "cancel";
         break;
+      case GRN_WINDOW_FUNCTION_ERROR:
+        message = "window function error";
+        break;
     }
 
     if (!message)
@@ -1295,4 +1302,14 @@ rb_grn_init_exception (VALUE mGrn)
      */
     eGrnCancel =
         rb_define_class_under(mGrn, "Cancel", rb_eGrnError);
+
+    /*
+     * Document-class: Groonga::WindowFunctionError
+     *
+     * It is used when window function causes an error.
+     *
+     * @since 6.0.4
+     */
+    eGrnWindowFunctionError =
+        rb_define_class_under(mGrn, "WindowFunctionError", rb_eGrnError);
 }

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2010  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-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
@@ -227,7 +227,7 @@ void
 rb_grn_init_fix_size_column (VALUE mGrn)
 {
     rb_cGrnFixSizeColumn =
-        rb_define_class_under(mGrn, "FixSizeColumn", rb_cGrnColumn);
+        rb_define_class_under(mGrn, "FixSizeColumn", rb_cGrnDataColumn);
 
     rb_define_method(rb_cGrnFixSizeColumn, "[]",
                      rb_grn_fix_size_column_array_reference, 1);

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

@@ -1678,6 +1678,33 @@ rb_grn_object_scorer_procedure_p (VALUE self)
     return CBOOL2RVAL(scorer_procedure_p);
 }
 
+/*
+ * Checks whether the object is windows function procedure or not.
+ *
+ * @overload window_function_procedure?
+ *   @return [Boolean] `true` if the object is window function procedure,
+ *     `false` otherwise.
+ *
+ * @since 6.0.4
+ */
+static VALUE
+rb_grn_object_window_function_procedure_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool window_function_procedure_p = GRN_FALSE;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+
+    if (context && object) {
+        window_function_procedure_p =
+            grn_obj_is_window_function_proc(context, object);
+    }
+
+    return CBOOL2RVAL(window_function_procedure_p);
+}
+
 /*
  * Checks whether the object is accessor or not.
  *
@@ -1785,6 +1812,8 @@ rb_grn_init_object (VALUE mGrn)
                      rb_grn_object_selector_only_procedure_p, 0);
     rb_define_method(rb_cGrnObject, "scorer_procedure?",
                      rb_grn_object_scorer_procedure_p, 0);
+    rb_define_method(rb_cGrnObject, "window_function_procedure?",
+                     rb_grn_object_window_function_procedure_p, 0);
     rb_define_method(rb_cGrnObject, "accessor?",
                      rb_grn_object_accessor_p, 0);
     rb_define_method(rb_cGrnObject, "key_accessor?",

data/ext/groonga/rb-grn-procedure-type.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2014  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2014-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
@@ -41,4 +41,12 @@ rb_grn_init_procedure_type (VALUE mGrn)
                     "TOKEN_FILTER", INT2NUM(GRN_PROC_TOKEN_FILTER));
     rb_define_const(rb_mGrnProcedureType,
                     "SCORER", INT2NUM(GRN_PROC_SCORER));
+
+    /*
+     * It's a type for window function.
+     *
+     * @since 6.0.4
+     */
+    rb_define_const(rb_mGrnProcedureType,
+                    "WINDOW_FUNCTION", INT2NUM(GRN_PROC_WINDOW_FUNCTION));
 }

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

@@ -0,0 +1,85 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  Copyright (C) 2009-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"
+
+void
+rb_grn_table_sort_keys_fill (grn_ctx *context,
+                             grn_table_sort_key *sort_keys,
+                             size_t n_sort_keys,
+                             VALUE rb_sort_keys,
+                             VALUE rb_table)
+{
+    int i;
+
+    for (i = 0; i < n_sort_keys; i++) {
+        VALUE rb_sort_key;
+        VALUE rb_sort_options;
+        VALUE rb_key;
+        VALUE rb_resolved_key;
+        VALUE rb_order;
+
+        rb_sort_key = RARRAY_PTR(rb_sort_keys)[i];
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_key, rb_cHash))) {
+            rb_sort_options = rb_sort_key;
+        } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_key, rb_cArray))) {
+            rb_sort_options = rb_hash_new();
+            rb_hash_aset(rb_sort_options,
+                         RB_GRN_INTERN("key"),
+                         rb_ary_entry(rb_sort_key, 0));
+            rb_hash_aset(rb_sort_options,
+                         RB_GRN_INTERN("order"),
+                         rb_ary_entry(rb_sort_key, 1));
+        } else {
+            rb_sort_options = rb_hash_new();
+            rb_hash_aset(rb_sort_options,
+                         RB_GRN_INTERN("key"),
+                         rb_sort_key);
+        }
+        rb_grn_scan_options(rb_sort_options,
+                            "key", &rb_key,
+                            "order", &rb_order,
+                            NULL);
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
+            rb_resolved_key = rb_grn_table_get_column(rb_table, rb_key);
+        } else {
+            rb_resolved_key = rb_key;
+        }
+        sort_keys[i].key = RVAL2GRNOBJECT(rb_resolved_key, &context);
+        if (!sort_keys[i].key) {
+            rb_raise(rb_eGrnNoSuchColumn,
+                     "no such column: <%s>: <%s>",
+                     rb_grn_inspect(rb_key),
+                     rb_grn_inspect(rb_table));
+        }
+        if (NIL_P(rb_order) ||
+            rb_grn_equal_option(rb_order, "asc") ||
+            rb_grn_equal_option(rb_order, "ascending")) {
+            sort_keys[i].flags = GRN_TABLE_SORT_ASC;
+        } else if (rb_grn_equal_option(rb_order, "desc") ||
+                   rb_grn_equal_option(rb_order, "descending")) {
+            sort_keys[i].flags = GRN_TABLE_SORT_DESC;
+        } else {
+            rb_raise(rb_eArgError,
+                     "order should be one of "
+                     "[nil, :desc, :descending, :asc, :ascending]: %s",
+                     rb_grn_inspect(rb_order));
+        }
+    }
+
+}

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

@@ -19,12 +19,6 @@
 
 #include "rb-grn.h"
 
-grn_obj *grn_table_open(grn_ctx *ctx,
-                        const char *name, unsigned name_size, const char *path);
-grn_obj *grn_column_open(grn_ctx *ctx, grn_obj *table,
-                         const char *name, unsigned name_size,
-                         const char *path, grn_obj *type);
-
 #define SELF(object) ((RbGrnTable *)DATA_PTR(object))
 
 VALUE rb_cGrnTable;
@@ -1218,11 +1212,10 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
     grn_obj *table;
     grn_obj *result;
     grn_table_sort_key *keys;
-    int i, n_keys;
+    int n_keys;
     int offset = 0, limit = -1;
     VALUE rb_keys, options;
     VALUE rb_offset, rb_limit;
-    VALUE *rb_sort_keys;
     VALUE exception;
 
     rb_grn_table_deconstruct(SELF(self), &table, &context,
@@ -1237,56 +1230,8 @@ rb_grn_table_sort (int argc, VALUE *argv, VALUE self)
                  rb_grn_inspect(rb_keys));
 
     n_keys = RARRAY_LEN(rb_keys);
-    rb_sort_keys = RARRAY_PTR(rb_keys);
     keys = ALLOCA_N(grn_table_sort_key, n_keys);
-    for (i = 0; i < n_keys; i++) {
-        VALUE rb_sort_options, rb_key, rb_resolved_key, rb_order;
-
-        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cHash))) {
-            rb_sort_options = rb_sort_keys[i];
-        } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_sort_keys[i], rb_cArray))) {
-            rb_sort_options = rb_hash_new();
-            rb_hash_aset(rb_sort_options,
-                         RB_GRN_INTERN("key"),
-                         rb_ary_entry(rb_sort_keys[i], 0));
-            rb_hash_aset(rb_sort_options,
-                         RB_GRN_INTERN("order"),
-                         rb_ary_entry(rb_sort_keys[i], 1));
-        } else {
-            rb_sort_options = rb_hash_new();
-            rb_hash_aset(rb_sort_options,
-                         RB_GRN_INTERN("key"),
-                         rb_sort_keys[i]);
-        }
-        rb_grn_scan_options(rb_sort_options,
-                            "key", &rb_key,
-                            "order", &rb_order,
-                            NULL);
-        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_key, rb_cString))) {
-            rb_resolved_key = rb_grn_table_get_column(self, rb_key);
-        } else {
-            rb_resolved_key = rb_key;
-        }
-        keys[i].key = RVAL2GRNOBJECT(rb_resolved_key, &context);
-        if (!keys[i].key) {
-            rb_raise(rb_eGrnNoSuchColumn,
-                     "no such column: <%s>: <%s>",
-                     rb_grn_inspect(rb_key), rb_grn_inspect(self));
-        }
-        if (NIL_P(rb_order) ||
-            rb_grn_equal_option(rb_order, "asc") ||
-            rb_grn_equal_option(rb_order, "ascending")) {
-            keys[i].flags = GRN_TABLE_SORT_ASC;
-        } else if (rb_grn_equal_option(rb_order, "desc") ||
-                   rb_grn_equal_option(rb_order, "descending")) {
-            keys[i].flags = GRN_TABLE_SORT_DESC;
-        } else {
-            rb_raise(rb_eArgError,
-                     "order should be one of "
-                     "[nil, :desc, :descending, :asc, :ascending]: %s",
-                     rb_grn_inspect(rb_order));
-        }
-    }
+    rb_grn_table_sort_keys_fill(context, keys, n_keys, rb_keys, self);
 
     rb_grn_scan_options(options,
                         "offset", &rb_offset,