rroonga 5.0.4-x64-mingw32 → 5.0.5-x64-mingw32

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzA4MWQwNDcyZWExY2YwMjBmYjA4ZWFhMGMwNzhlOWRhMzQzY2FiNQ==
+    MmNkYTRhMGIwZTZkZDQyZTMwZTVhMjk4YzRhMjM1MzFjMzEzMDM1OQ==
   data.tar.gz: !binary |-
-    YmMyYTc1MzFkNjE4ODNjNjQ5NTM4NWE3NjM3ZmU1MjI0ZTA3YzViYQ==
+    MGU0MWQ4YmI3YjFlZGZkMTQ3NTA5Y2I4OTVlMjViNzg5NTQwMTEyNQ==
 SHA512:
   metadata.gz: !binary |-
-    YzEyYjU2NDFmZDQzYWI0ZmY1ZTMwOGRiNjM1NDBlZDRkZDRiNTIyOWNjOWU2
-    NTNjOWRjMmYxZDNkODgxNGU3OWViODlkZjcyMmU3ZTI4ZTkzNWVmMDdjMTll
-    ODE1Y2ExYmE3NmI2M2NlNzg0NTZkMzE3YTAwNGNiNTI3NDU1N2E=
+    MzhjMTE3ZjI0MWY5Nzc1Y2M3MzMzNDA0YjUwYTU0MTZkYzkxODVmODAzYTAx
+    MDllNDQxODdmYTQ2Nzk5NjBiODBlNWVkZmI4ZTVmNTM1NTk3NDBlMTA0MWZk
+    YTRmZjM4ZjAzNjdkZmI4YzEzNDE1MjM1MTE3Y2U1YmQ1OGExZjc=
   data.tar.gz: !binary |-
-    ZjE5MTNmM2I5MTcxZTI3YzMyZTk1N2QwMmZmYjk3MjFkMzI1OGJjNDZmZTBi
-    NzU5NjhhNWI0NGM4NGI0NTdjMTk1NGMyYjZlNTdlZGViYzQ5ZTQ1ZTEyNmM2
-    YzQ5OTliNWVlZjljMjMwNzU2ODBkZTQyOTcyNTdlNDNkOTQ5ZjY=
+    ODM3NDhmYzdlZGRhMjQ0N2NmMDk0NmRhNGRkMGMxODIyZGRiZTk0ZmU2NDM0
+    Zjg2N2UyMTEyMzY1YTk5MzRiOTkzNzFhNmY2N2Q5MDAwOWFlMmQ1MjQzNzUw
+    ZjdkOTViNTI5ODUzM2EyNzc1MWQ2MDE1Njc3NTE2ZTU1MTRiYTg=

data/README.md

@@ -39,8 +39,8 @@ contributed patches.)
 
 ## Dependencies
 
-* Ruby >= 1.9.3
-* Groonga >= 5.0.5
+* Ruby
+* Groonga
 
 ## Install
 

data/example/measure-data-column-disk-usage.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2015  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
+
+require "groonga"
+require "fileutils"
+
+if ARGV.size != 3
+  puts "Usage: #{$0} DB_DIR COLUMN_TYPE COLUMN_VALUE_TYPE"
+  puts " e.g.: #{$0} db scalar ShortText"
+  puts " e.g.: #{$0} db vector Time"
+  puts " e.g.: #{$0} db vector reference"
+  exit(false)
+end
+
+db_dir = ARGV.shift
+column_type = ARGV.shift
+column_value_type = ARGV.shift.to_sym
+
+FileUtils.rm_rf(db_dir)
+FileUtils.mkdir_p(db_dir)
+
+Groonga::Database.create(:path => "#{db_dir}/db")
+
+Groonga::Schema.define do |schema|
+  schema.create_table("reference",
+                      :type => :hash,
+                      :key_type => "Int32") do |table|
+  end
+
+  schema.create_table("table", :type => :array) do |table|
+    table.column("column", column_value_type, :type => column_type)
+  end
+end
+
+def measure_column_disk_usage(column)
+  puts "\# of records,total disk usage,increment"
+  table = column.domain
+  vector_p = column.vector?
+  previous_disk_usage = 0
+  loop do
+    if previous_disk_usage != column.disk_usage
+      diff = column.disk_usage - previous_disk_usage
+      puts "#{table.size},#{column.disk_usage},#{diff}"
+      $stdout.flush
+      previous_disk_usage = column.disk_usage
+      return if table.size > 200_000_000
+    end
+    if vector_p
+      value = [yield, yield, yield]
+    else
+      value = yield
+    end
+    table.add(:column => value)
+  end
+end
+
+def measure_reference_column_disk_usage(column)
+  reference_key = 0
+  reference = Groonga["reference"]
+  measure_column_disk_usage(column) do
+    reference_key += 1
+    reference.add(reference_key)
+  end
+end
+
+def measure_short_text_column_disk_usage(column)
+  key1 = 1
+  key2 = 1
+  measure_column_disk_usage(column) do
+    key = "#{key1}-#{key2}"
+    key2 += 1
+    if key2 > 100
+      key1 += 1
+      key2 = 1
+    end
+    key
+  end
+end
+
+def measure_int_column_disk_usage(column)
+  value = 1
+  measure_column_disk_usage(column) do
+    value += 1
+    value
+  end
+end
+
+def measure_time_column_disk_usage(column)
+  value = Time.at(0)
+  measure_column_disk_usage(column) do
+    value += 1
+    value
+  end
+end
+
+column = Groonga["table.column"]
+column_value_type_name = column.range.name
+case column_value_type_name
+when "reference"
+  measure_reference_column_disk_usage(column)
+when "ShortText"
+  measure_short_text_column_disk_usage(column)
+when /Int/
+  measure_int_column_disk_usage(column)
+when "Time"
+  measure_time_column_disk_usage(column)
+else
+  puts "Unsupported column value type: #{column_value_type_name}"
+  exit(false)
+end

data/example/measure-index-column-disk-usage.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2015  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
+
+require "groonga"
+require "fileutils"
+
+if ARGV.size != 4
+  puts "Usage: #{$0} DB_DIR WITH_POSITION WITH_SECTION N_POSTINGS_PER_TERM"
+  puts " e.g.: #{$0} db true false 100"
+  exit(false)
+end
+
+db_dir = ARGV.shift
+with_position_p = (ARGV.shift == "true")
+with_section_p = (ARGV.shift == "true")
+n_postings_per_term = Integer(ARGV.shift)
+
+FileUtils.rm_rf(db_dir)
+FileUtils.mkdir_p(db_dir)
+
+Groonga::Database.create(:path => "#{db_dir}/db")
+
+Groonga::Schema.define do |schema|
+  schema.create_table("table", :type => :array) do |table|
+    table.column("column", "Int32")
+  end
+
+  schema.create_table("lexicon",
+                      :type => :patricia_trie,
+                      :key_type => "Int32") do |table|
+    table.index("table.column",
+                :name => "index",
+                :with_position => with_position_p,
+                :with_section => with_section_p)
+  end
+end
+
+def measure_disk_usage(data_table, index_column, n_postings_per_term)
+  puts "\# of data records,\# of terms,total disk usage,increment"
+
+  data_table = Groonga["table"]
+  lexicon = index_column.domain
+  n_postings = 0
+  value = 0
+
+  previous_disk_usage = 0
+  loop do
+    if previous_disk_usage != index_column.disk_usage
+      diff = index_column.disk_usage - previous_disk_usage
+      puts "#{data_table.size},#{lexicon.size},#{index_column.disk_usage},#{diff}"
+      $stdout.flush
+      previous_disk_usage = index_column.disk_usage
+      return if data_table.size > 200_000_000
+    end
+    if n_postings < n_postings_per_term
+      n_postings += 1
+    else
+      n_postings = 0
+      value += 1
+    end
+    data_table.add(:column => value)
+  end
+end
+
+data_table = Groonga["table"]
+index_column = Groonga["lexicon.index"]
+measure_disk_usage(data_table, index_column, n_postings_per_term)

data/example/measure-table-disk-usage.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2015  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
+
+require "groonga"
+require "fileutils"
+
+if ARGV.size != 3
+  puts "Usage: #{$0} DB_DIR TABLE_TYPE TABLE_KEY_TYPE"
+  puts " e.g.: #{$0} db hash ShortText"
+  exit(false)
+end
+
+db_dir = ARGV.shift
+table_type = ARGV.shift
+table_key_type = ARGV.shift
+
+FileUtils.rm_rf(db_dir)
+FileUtils.mkdir_p(db_dir)
+
+Groonga::Database.create(:path => "#{db_dir}/db")
+
+Groonga::Schema.define do |schema|
+  schema.create_table("table",
+                      :type => table_type.to_sym,
+                      :key_type => table_key_type) do
+  end
+end
+
+def measure_table_disk_usage(table)
+  puts "\# of records,total disk usage,increment"
+  previous_disk_usage = 0
+  loop do
+    if previous_disk_usage != table.disk_usage
+      diff = table.disk_usage - previous_disk_usage
+      puts "#{table.size},#{table.disk_usage},#{diff}"
+      $stdout.flush
+      previous_disk_usage = table.disk_usage
+      return if table.size > 200_000_000
+    end
+    table.add(yield)
+  end
+end
+
+def measure_short_text_table_disk_usage(table)
+  key1 = 1
+  key2 = 1
+  measure_table_disk_usage(table) do
+    key = "#{key1}-#{key2}"
+    key2 += 1
+    if key2 > 100
+      key1 += 1
+      key2 = 1
+    end
+    key
+  end
+end
+
+def measure_int_table_disk_usage(table)
+  value = 1
+  measure_table_disk_usage(table) do
+    value += 1
+    value
+  end
+end
+
+def measure_time_table_disk_usage(table)
+  value = Time.at(0)
+  measure_table_disk_usage(table) do
+    value += 1
+    value
+  end
+end
+
+table = Groonga["table"]
+table_key_type_name = table.domain.name
+case table_key_type_name
+when "ShortText"
+  measure_short_text_table_disk_usage(table)
+when /Int/
+  measure_int_table_disk_usage(table)
+when "Time"
+  measure_time_table_disk_usage(table)
+else
+  puts "Unsupported table key type: #{table_key_type_name}"
+  exit(false)
+end

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

@@ -593,6 +593,36 @@ rb_grn_database_recover (VALUE self)
     return Qnil;
 }
 
+/*
+ * @overload unmap()
+ *
+ *   Unmaps all mapped tables and columns in database.
+ *
+ *   It frees resources for them.
+ *
+ *   Normally, you don't need to unmap explicitly. Because OS manages
+ *   resourced for mapped tables and columns cleverly.
+ *
+ *   @return [void]
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_database_unmap (VALUE self)
+{
+    grn_rc rc;
+    grn_ctx *context;
+    grn_obj *database;
+
+    rb_grn_database_deconstruct(SELF(self), &database, &context,
+                                NULL, NULL, NULL, NULL);
+    rc = grn_db_unmap(context, database);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
 void
 rb_grn_init_database (VALUE mGrn)
 {
@@ -626,4 +656,5 @@ rb_grn_init_database (VALUE mGrn)
     rb_define_method(rb_cGrnDatabase, "touch", rb_grn_database_touch, 0);
     rb_define_method(rb_cGrnDatabase, "defrag", rb_grn_database_defrag, -1);
     rb_define_method(rb_cGrnDatabase, "recover", rb_grn_database_recover, 0);
+    rb_define_method(rb_cGrnDatabase, "unmap", rb_grn_database_unmap, 0);
 }

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

@@ -489,17 +489,10 @@ rb_grn_double_array_trie_open_grn_prefix_cursor (int argc, VALUE *argv,
     } else if (rb_grn_equal_option(rb_order_by, "id")) {
         flags |= GRN_CURSOR_BY_ID;
     } else if (rb_grn_equal_option(rb_order_by, "key")) {
-        if (table->header.type != GRN_TABLE_PAT_KEY) {
-            rb_raise(rb_eArgError,
-                     "order_by => :key is available "
-                     "only for Groonga::DoubleArrayTrie: %s",
-                     rb_grn_inspect(self));
-        }
         flags |= GRN_CURSOR_BY_KEY;
     } else {
         rb_raise(rb_eArgError,
-                 "order_by should be one of [:id%s]: %s",
-                 table->header.type == GRN_TABLE_PAT_KEY ? ", :key" : "",
+                 "order_by should be one of [:id, :key]: %s",
                  rb_grn_inspect(rb_order_by));
     }
 

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

@@ -438,6 +438,47 @@ rb_grn_logger_s_reopen (VALUE klass)
     return Qnil;
 }
 
+/*
+ * @overload max_level
+ *   @return [Symbol] The max level of the current logger.
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_logger_s_get_max_level (VALUE klass)
+{
+    VALUE rb_context = Qnil;
+    grn_ctx *context;
+    grn_log_level max_level;
+
+    context = rb_grn_context_ensure(&rb_context);
+    max_level = grn_logger_get_max_level(context);
+
+    return GRNLOGLEVEL2RVAL(max_level);
+}
+
+/*
+ * @overload max_level=(max_level)
+ *   Sets the max level of the current logger.
+ *
+ *   @param max_level [Symbol, String] The max level.
+ *
+ *   @return [void]
+ *
+ * @since 5.0.5
+ */
+static VALUE
+rb_grn_logger_s_set_max_level (VALUE klass, VALUE rb_max_level)
+{
+    VALUE rb_context = Qnil;
+    grn_ctx *context;
+
+    context = rb_grn_context_ensure(&rb_context);
+    grn_logger_set_max_level(context, RVAL2GRNLOGLEVEL(rb_max_level));
+
+    return Qnil;
+}
+
 /*
  * Gets the current log path that is used by the default logger.
  *
@@ -587,6 +628,10 @@ rb_grn_init_logger (VALUE mGrn)
                                rb_grn_logger_s_unregister, 0);
     rb_define_singleton_method(cGrnLogger, "reopen",
                                rb_grn_logger_s_reopen, 0);
+    rb_define_singleton_method(cGrnLogger, "max_level",
+                               rb_grn_logger_s_get_max_level, 0);
+    rb_define_singleton_method(cGrnLogger, "max_level=",
+                               rb_grn_logger_s_set_max_level, 1);
     rb_define_singleton_method(cGrnLogger, "path",
                                rb_grn_logger_s_get_path, 0);
     rb_define_singleton_method(cGrnLogger, "path=",