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

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

@@ -54,7 +54,7 @@ grn_obj *
 rb_grn_column_from_ruby_object (VALUE object, grn_ctx **context)
 {
     if (!RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnColumn))) {
-        rb_raise(rb_eTypeError, "not a groonga column");
+        rb_raise(rb_eTypeError, "not a Groonga column");
     }
 
     return RVAL2GRNOBJECT(object, context);

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2010-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2010-2018  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
@@ -700,10 +700,10 @@ rb_grn_context_support_lz4_p (VALUE self)
 }
 
 /*
- * If Groonga supports Zstandard compression, it returns `true`,
- * otherwise it returns `false`.
- *
  * @overload support_zstd?
+ *
+ *   @return [Boolean] `true` if Groonga supports Zstandard compression,
+ *     `false` otherwise.
  */
 static VALUE
 rb_grn_context_support_zstd_p (VALUE self)
@@ -721,6 +721,28 @@ rb_grn_context_support_zstd_p (VALUE self)
     return rb_support_p;
 }
 
+/*
+ * @overload support_arrow?
+ *
+ *   @return [Boolean] `true` if Groonga supports Apache Arrow,
+ *     `false` otherwise.
+ */
+static VALUE
+rb_grn_context_support_arrow_p (VALUE self)
+{
+    VALUE rb_support_p;
+    grn_ctx *context;
+    grn_obj support_p;
+
+    context = SELF(self);
+    GRN_BOOL_INIT(&support_p, 0);
+    grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_ARROW, &support_p);
+    rb_support_p = CBOOL2RVAL(GRN_BOOL_VALUE(&support_p));
+    GRN_OBJ_FIN(context, &support_p);
+
+    return rb_support_p;
+}
+
 /*
  * コンテキストが使うデータベースを返す。
  *
@@ -1030,6 +1052,8 @@ rb_grn_init_context (VALUE mGrn)
                      rb_grn_context_support_lz4_p, 0);
     rb_define_method(cGrnContext, "support_zstd?",
                      rb_grn_context_support_zstd_p, 0);
+    rb_define_method(cGrnContext, "support_arrow?",
+                     rb_grn_context_support_arrow_p, 0);
 
     rb_define_method(cGrnContext, "database", rb_grn_context_get_database, 0);
 

data/ext/groonga/rb-grn-expression.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-2018  Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2014  Masafumi Yokoyama <myokoym@gmail.com>
 
   This library is free software; you can redistribute it and/or
@@ -424,6 +424,18 @@ rb_grn_expression_append_operation (VALUE self, VALUE rb_operation,
  *     デフォルトでは更新操作を利用できる。
  *
  *     参考: "Groongaのクエリ構文のドキュメント":http://groonga.org/ja/docs/reference/grn_expr/query_syntax.html
+ *   @option options :no_syntax_error
+ *     Specifies whether preventing syntax error in query syntax.
+ *
+ *     If it's `true`, special characters are treated as normal
+ *     characters on syntax error.
+ *
+ *     If it's `false`, syntax error is reported on syntax error.
+ *     It's the default.
+ *
+ *     You can't use this option in script syntax.
+ *
+ *     @see [Query syntax document in Groonga](http://groonga.org/docs/reference/grn_expr/query_syntax.html)
  */
 static VALUE
 rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
@@ -440,6 +452,7 @@ rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
     VALUE options, rb_query, rb_default_column, rb_default_operator;
     VALUE rb_default_mode, rb_syntax;
     VALUE rb_allow_pragma, rb_allow_column, rb_allow_update, rb_allow_leading_not;
+    VALUE rb_no_syntax_error;
     VALUE exception = Qnil;
 
     rb_scan_args(argc, argv, "11", &rb_query, &options);
@@ -452,6 +465,7 @@ rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
                         "allow_column", &rb_allow_column,
                         "allow_update", &rb_allow_update,
                         "allow_leading_not", &rb_allow_leading_not,
+                        "no_syntax_error", &rb_no_syntax_error,
                         NULL);
 
     query = StringValuePtr(rb_query);
@@ -521,6 +535,14 @@ rb_grn_expression_parse (int argc, VALUE *argv, VALUE self)
             flags |= GRN_EXPR_ALLOW_LEADING_NOT;
     }
 
+    if (!NIL_P(rb_no_syntax_error)) {
+        if ((flags & GRN_EXPR_SYNTAX_SCRIPT))
+            rb_raise(rb_eArgError,
+                     ":no_syntax_error isn't allowed in script syntax");
+        if (RVAL2CBOOL(rb_no_syntax_error))
+            flags |= GRN_EXPR_QUERY_NO_SYNTAX_ERROR;
+    }
+
     rc = grn_expr_parse(context, expression, query, query_size,
                         default_column, default_mode, default_operator,
                         flags);

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

@@ -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-2018  Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -1970,6 +1970,44 @@ rb_grn_object_dirty_p (VALUE self)
     return CBOOL2RVAL(is_dirty);
 }
 
+/*
+ * @overload corrupt?
+ *   @return [Boolean] `true` if the object is corrupt, `false` otherwise.
+ *
+ * @since 7.1.1
+ */
+static VALUE
+rb_grn_object_corrupt_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    grn_bool is_corrupt;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+    is_corrupt = grn_obj_is_corrupt(context, object);
+    return CBOOL2RVAL(is_corrupt);
+}
+
+/*
+ * @overload disk_usage
+ *   @return [Integer] The number of bytes used by this object in disk.
+ *
+ * @since 7.1.1
+ */
+static VALUE
+rb_grn_object_get_disk_usage (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *object;
+    size_t disk_usage;
+
+    rb_grn_object_deconstruct(SELF(self), &object, &context,
+                              NULL, NULL, NULL, NULL);
+    disk_usage = grn_obj_get_disk_usage(context, object);
+    return UINT2NUM(disk_usage);
+}
+
 void
 rb_grn_init_object (VALUE mGrn)
 {
@@ -2032,4 +2070,9 @@ rb_grn_init_object (VALUE mGrn)
                      rb_grn_object_get_last_modified, 0);
     rb_define_method(rb_cGrnObject, "dirty?",
                      rb_grn_object_dirty_p, 0);
+    rb_define_method(rb_cGrnObject, "corrupt?",
+                     rb_grn_object_corrupt_p, 0);
+
+    rb_define_method(rb_cGrnObject, "disk_usage",
+                     rb_grn_object_get_disk_usage, 0);
 }

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2014  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
@@ -50,6 +50,19 @@ rb_grn_procedure_get_type (VALUE self)
     return INT2NUM(type);
 }
 
+static VALUE
+rb_grn_procedure_stable_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *procedure;
+    grn_bool is_stable;
+
+    procedure = RVAL2GRNOBJECT(self, &context);
+    is_stable = grn_proc_is_stable(context, procedure);
+
+    return CBOOL2RVAL(is_stable);
+}
+
 void
 rb_grn_init_procedure (VALUE mGrn)
 {
@@ -62,4 +75,6 @@ rb_grn_init_procedure (VALUE mGrn)
     rb_define_const(rb_cGrnProcedure, "MECAB", INT2NUM(GRN_DB_MECAB));
 
     rb_define_method(rb_cGrnProcedure, "type", rb_grn_procedure_get_type, 0);
+
+    rb_define_method(rb_cGrnProcedure, "stable?", rb_grn_procedure_stable_p, 0);
 }

data/ext/groonga/rb-grn-query-logger.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2012-2015  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2012-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
@@ -390,10 +390,11 @@ rb_grn_query_logger_s_get_rotate_threshold_size (VALUE klass)
  *   Groonga::QueryLogger.rotate_threshold_size = 0
  *
  * @overload rotate_threshold_size=(size)
- *   @param size [Integer] The log path for the default query logger.
- *     If nil is specified, log rotate by the default query logger is
- *     disabled.
- *   @return void
+ *   @param size [Integer] The rotate threshold size for the default
+ *     query logger. If `nil` is specified, log rotate by the default
+ *     query logger is disabled.
+ *
+ *   @return `size` itself.
  *
  * @since 5.0.2
  */
@@ -402,7 +403,49 @@ rb_grn_query_logger_s_set_rotate_threshold_size (VALUE klass, VALUE rb_size)
 {
     grn_default_query_logger_set_rotate_threshold_size(NUM2OFFT(rb_size));
 
-    return Qnil;
+    return rb_size;
+}
+
+/*
+ * Gets the current flags that are used by the default query logger.
+ *
+ * @overload flags
+ *   @return [Integer] The current flags
+ *
+ * @since 7.1.1
+ */
+static VALUE
+rb_grn_query_logger_s_get_flags (VALUE klass)
+{
+    return UINT2NUM(grn_default_query_logger_get_flags());
+}
+
+/*
+ * Sets the flags that are used by the default query logger. If you're
+ * using custom query logger by {.register}, the flags aren't
+ * used. Because it is for the default query logger.
+ *
+ * @example Changes the rotate threshold size for the default query logger
+ *   Groonga::QueryLogger.rotate_threshold_size = 1 * 1024 * 1024 # 1MiB
+ *
+ * @example Disables log ration by the default query logger
+ *   Groonga::QueryLogger.rotate_threshold_size = 0
+ *
+ * @overload flags=(flags)
+ *   @param flags [Integer] The flags for the default query logger.
+ *   @return void
+ *
+ * @since 7.1.1
+ */
+static VALUE
+rb_grn_query_logger_s_set_flags (VALUE klass, VALUE rb_flags)
+{
+    VALUE rb_parsed_flags;
+
+    rb_parsed_flags = rb_funcall(mGrnQueryLoggerFlags, id_parse, 1, rb_flags);
+    grn_default_query_logger_set_flags(NUM2UINT(rb_parsed_flags));
+
+    return rb_flags;
 }
 
 void
@@ -441,6 +484,12 @@ rb_grn_init_query_logger (VALUE mGrn)
     rb_define_singleton_method(cGrnQueryLogger, "rotate_threshold_size=",
                                rb_grn_query_logger_s_set_rotate_threshold_size,
                                1);
+    rb_define_singleton_method(cGrnQueryLogger, "flags",
+                               rb_grn_query_logger_s_get_flags,
+                               0);
+    rb_define_singleton_method(cGrnQueryLogger, "flags=",
+                               rb_grn_query_logger_s_set_flags,
+                               1);
 
     mGrnQueryLoggerFlags = rb_define_module_under(cGrnQueryLogger, "Flags");
 #define DEFINE_FLAG(NAME)                                       \

data/ext/groonga/rb-grn-table.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) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -2646,6 +2646,172 @@ rb_grn_table_rename (VALUE self, VALUE rb_name)
     return self;
 }
 
+/*
+ * @overload load_arrow(path)
+ *
+ *   Loads records from Apache Arrow file format file.
+ *
+ *   @param path [String, #to_path] the path of file in Apache Arrow
+ *     file format.
+ *
+ *   @return [void]
+ *
+ *   @since 7.0.3
+ */
+static VALUE
+rb_grn_table_load_arrow (VALUE self, VALUE rb_path)
+{
+    int rc;
+    grn_ctx *context;
+    grn_obj *table;
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+                             NULL, NULL, NULL,
+                             NULL, NULL,
+                             NULL);
+
+    {
+        VALUE rb_path_string;
+        rb_path_string = rb_grn_check_convert_to_string(rb_path);
+        if (NIL_P(rb_path_string)) {
+            ID to_path;
+            CONST_ID(to_path, "to_path");
+            rb_path_string = rb_check_funcall(rb_path, to_path, 0, 0);
+            if (rb_path_string == Qundef) {
+                rb_path_string = rb_path;
+            }
+            rb_path = rb_grn_convert_to_string(rb_path_string);
+        }
+    }
+
+    rc = grn_arrow_load(context, table, StringValueCStr(rb_path));
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return self;
+}
+
+/*
+ * @overload dump_arrow(path, options)
+ *
+ *   Dump records to file in Apache Arrow file format.
+ *
+ *   @param path [String, #to_path] the output file path.
+ *
+ *   @param options [::Hash] the options.
+ *
+ *   @option options :columns [::Array<Groonga::Column>] (nil) the
+ *     columns to be dumped.
+ *
+ *     If you don't specify neither `:columns` and `:column_names`,
+ *     all columns are dumped. It's the default.
+ *
+ *   @option options :column_names [::Array<Groonga::Column>] (nil)
+ *     the column names to be dumped. If `:columns` is specified,
+ *     `:column_names` is ignored.
+ *
+ *     If you don't specify neither `:columns` and `:column_names`,
+ *     all columns are dumped. It's the default.
+ *
+ *   @return [void]
+ *
+ *   @since 7.0.3
+ */
+static VALUE
+rb_grn_table_dump_arrow (int argc, VALUE *argv, VALUE self)
+{
+    int rc;
+    grn_ctx *context;
+    grn_obj *table;
+    const char *path;
+    VALUE rb_path;
+    VALUE rb_options;
+    VALUE rb_columns = Qnil;
+    VALUE rb_column_names = Qnil;
+
+    rb_scan_args(argc, argv, "11", &rb_path, &rb_options);
+    rb_grn_scan_options(rb_options,
+                        "columns", &rb_columns,
+                        "column_names", &rb_column_names,
+                        NULL);
+
+    rb_grn_table_deconstruct(SELF(self), &table, &context,
+                             NULL, NULL, NULL,
+                             NULL, NULL,
+                             NULL);
+
+    {
+        VALUE rb_path_string;
+        rb_path_string = rb_grn_check_convert_to_string(rb_path);
+        if (NIL_P(rb_path_string)) {
+            ID to_path;
+            CONST_ID(to_path, "to_path");
+            rb_path_string = rb_check_funcall(rb_path, to_path, 0, 0);
+            if (rb_path_string == Qundef) {
+                rb_path_string = rb_path;
+            }
+            rb_path = rb_grn_convert_to_string(rb_path_string);
+        }
+    }
+    path = StringValueCStr(rb_path);
+
+    if (NIL_P(rb_columns) && NIL_P(rb_column_names)) {
+        rc = grn_arrow_dump(context, table, path);
+    } else if (!NIL_P(rb_columns)) {
+        grn_obj columns;
+        int i, n;
+
+        rb_columns = rb_grn_convert_to_array(rb_columns);
+
+        GRN_PTR_INIT(&columns, GRN_OBJ_VECTOR, GRN_ID_NIL);
+        n = RARRAY_LEN(rb_columns);
+        for (i = 0; i < n; i++) {
+            VALUE rb_column = RARRAY_PTR(rb_columns)[i];
+            grn_obj *column;
+
+            column = RVAL2GRNOBJECT(rb_column, &context);
+            GRN_PTR_PUT(context, &columns, column);
+        }
+        rc = grn_arrow_dump_columns(context, table, &columns, path);
+        GRN_OBJ_FIN(context, &columns);
+    } else if (!NIL_P(rb_column_names)) {
+        grn_obj columns;
+        int i, n;
+
+        rb_column_names = rb_grn_convert_to_array(rb_column_names);
+
+        GRN_PTR_INIT(&columns, GRN_OBJ_VECTOR, GRN_ID_NIL);
+        n = RARRAY_LEN(rb_column_names);
+        for (i = 0; i < n; i++) {
+            VALUE rb_column_name = RARRAY_PTR(rb_column_names)[i];
+            grn_obj *column;
+
+            column = grn_obj_column(context, table,
+                                    RSTRING_PTR(rb_column_name),
+                                    RSTRING_LEN(rb_column_name));
+            if (!column) {
+                continue;
+            }
+            GRN_PTR_PUT(context, &columns, column);
+        }
+        rc = grn_arrow_dump_columns(context, table, &columns, path);
+        n = GRN_BULK_VSIZE(&columns) / sizeof(grn_obj *);
+        for (i = 0; i < n; i++) {
+            grn_obj *column;
+
+            column = GRN_PTR_VALUE_AT(&columns, i);
+            if (column->header.type == GRN_ACCESSOR) {
+                grn_obj_unlink(context, column);
+            }
+        }
+        GRN_OBJ_FIN(context, &columns);
+    }
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return self;
+}
+
 void
 rb_grn_init_table (VALUE mGrn)
 {
@@ -2733,6 +2899,9 @@ rb_grn_init_table (VALUE mGrn)
 
     rb_define_method(rb_cGrnTable, "rename", rb_grn_table_rename, 1);
 
+    rb_define_method(rb_cGrnTable, "load_arrow", rb_grn_table_load_arrow, 1);
+    rb_define_method(rb_cGrnTable, "dump_arrow", rb_grn_table_dump_arrow, -1);
+
     rb_grn_init_table_key_support(mGrn);
     rb_grn_init_array(mGrn);
     rb_grn_init_hash(mGrn);