rroonga 2.0.6 → 2.0.7

data/Rakefile

@@ -44,6 +44,10 @@ $LOAD_PATH.unshift(groonga_lib_dir)
 ENV["RUBYLIB"] = "#{groonga_lib_dir}:#{groonga_ext_dir}:#{ENV['RUBYLIB']}"
 
 helper = Bundler::GemHelper.new(base_dir)
+def helper.version_tag
+  version
+end
+
 helper.install
 spec = helper.gemspec
 

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

@@ -64,7 +64,7 @@ rb_grn_index_column_bind (RbGrnIndexColumn *rb_grn_index_column,
 						 rb_grn_object->domain_id);
     rb_grn_index_column->string_query = grn_obj_open(context, GRN_BULK,
 						     GRN_OBJ_DO_SHALLOW_COPY,
-						     GRN_ID_NIL);
+						     GRN_DB_SHORT_TEXT);
 }
 
 void
@@ -540,23 +540,29 @@ rb_grn_index_column_open_cursor (VALUE self, VALUE rb_table_cursor)
 {
     grn_ctx *context;
     grn_obj *column;
+    grn_obj *range_object;
     grn_table_cursor *table_cursor;
     grn_id rid_min = GRN_ID_NIL;
     grn_id rid_max = GRN_ID_MAX;
     int flags = 0;
     grn_obj *index_cursor;
+    VALUE rb_table;
+    VALUE rb_lexicon;
     VALUE rb_cursor;
 
     rb_grn_index_column_deconstruct(SELF(self), &column, &context,
 				    NULL, NULL,
-				    NULL, NULL, NULL, NULL,
+				    NULL, NULL,
+				    NULL, &range_object,
 				    NULL, 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");
 
     index_cursor = grn_index_cursor_open(context, table_cursor,
 					 column, rid_min, rid_max, flags);
 
-    rb_cursor = GRNINDEXCURSOR2RVAL(context, index_cursor);
+    rb_cursor = GRNINDEXCURSOR2RVAL(context, index_cursor, rb_table, rb_lexicon);
 
     if (rb_block_given_p())
 	return rb_ensure(rb_yield, rb_cursor, rb_grn_object_close, rb_cursor);

data/ext/groonga/rb-grn-index-cursor.c

@@ -26,9 +26,17 @@ VALUE rb_cGrnIndexCursor;
 VALUE
 rb_grn_index_cursor_to_ruby_object (grn_ctx *context,
 				    grn_obj *cursor,
+				    VALUE rb_table,
+				    VALUE rb_lexicon,
 				    grn_bool owner)
 {
-    return GRNOBJECT2RVAL(rb_cGrnIndexCursor, context, cursor, owner);
+    VALUE rb_cursor;
+
+    rb_cursor = GRNOBJECT2RVAL(rb_cGrnIndexCursor, context, cursor, owner);
+    rb_iv_set(rb_cursor, "@table", rb_table);
+    rb_iv_set(rb_cursor, "@lexicon", rb_lexicon);
+
+    return rb_cursor;
 }
 
 void
@@ -48,6 +56,20 @@ rb_grn_index_cursor_deconstruct (RbGrnIndexCursor *rb_grn_index_cursor,
 			      range_id, range);
 }
 
+static VALUE
+next_value (grn_ctx *context, grn_obj *cursor, VALUE rb_table, VALUE rb_lexicon)
+{
+    grn_posting *posting;
+    grn_id term_id;
+
+    posting = grn_index_cursor_next(context, cursor, &term_id);
+    if (!posting) {
+	return Qnil;
+    }
+
+    return rb_grn_posting_new(posting, term_id, rb_table, rb_lexicon);
+}
+
 static VALUE
 rb_grn_index_cursor_next (VALUE self)
 {
@@ -57,16 +79,12 @@ rb_grn_index_cursor_next (VALUE self)
 
     rb_grn_index_cursor_deconstruct(SELF(self), &cursor, &context,
 				    NULL, NULL, NULL, NULL);
-
     if (context && cursor) {
-	grn_posting *posting;
-	grn_id tid;
-
-	posting = grn_index_cursor_next(context, cursor, &tid);
-
-	if (posting) {
-	    rb_posting = rb_grn_posting_new(posting, tid);
-	}
+	VALUE rb_table;
+	VALUE rb_lexicon;
+	rb_table = rb_iv_get(self, "@table");
+	rb_lexicon = rb_iv_get(self, "@lexicon");
+	rb_posting = next_value(context, cursor, rb_table, rb_lexicon);
     }
 
     return rb_posting;
@@ -78,19 +96,31 @@ rb_grn_index_cursor_each (VALUE self)
 {
     grn_obj *cursor;
     grn_ctx *context;
+    VALUE rb_table;
+    VALUE rb_lexicon;
 
     RETURN_ENUMERATOR(self, 0, NULL);
 
     rb_grn_index_cursor_deconstruct(SELF(self), &cursor, &context,
 				    NULL, NULL, NULL, NULL);
 
-    if (context && cursor) {
-	grn_posting *posting;
-	grn_id tid;
+    if (!context) {
+	return Qnil;
+    }
+
+    if (!cursor) {
+	return Qnil;
+    }
 
-	while ((posting = grn_index_cursor_next(context, cursor, &tid))) {
-	    rb_yield(rb_grn_posting_new(posting, tid));
+    rb_table = rb_iv_get(self, "@table");
+    rb_lexicon = rb_iv_get(self, "@lexicon");
+    while (GRN_TRUE) {
+	VALUE rb_posting;
+	rb_posting = next_value(context, cursor, rb_table, rb_lexicon);
+	if (NIL_P(rb_posting)) {
+	    break;
 	}
+	rb_yield(rb_posting);
     }
 
     return Qnil;

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

@@ -821,12 +821,26 @@ rb_grn_object_inspect_content_flags_with_label (VALUE inspected,
       case GRN_COLUMN_FIX_SIZE:
       case GRN_COLUMN_VAR_SIZE:
       case GRN_TYPE:
-	if (flags & GRN_OBJ_KEY_UINT)
-	    rb_ary_push(inspected_flags, rb_str_new2("KEY_UINT"));
-	if (flags & GRN_OBJ_KEY_INT)
-	    rb_ary_push(inspected_flags, rb_str_new2("KEY_INT"));
-	if (flags & GRN_OBJ_KEY_FLOAT)
-	    rb_ary_push(inspected_flags, rb_str_new2("KEY_FLOAT"));
+	if (flags & GRN_OBJ_KEY_VAR_SIZE) {
+	    rb_ary_push(inspected_flags, rb_str_new2("KEY_VAR_SIZE"));
+	} else {
+	    switch (flags & GRN_OBJ_KEY_MASK) {
+	      case GRN_OBJ_KEY_UINT:
+		rb_ary_push(inspected_flags, rb_str_new2("KEY_UINT"));
+		break;
+	      case GRN_OBJ_KEY_INT:
+		rb_ary_push(inspected_flags, rb_str_new2("KEY_INT"));
+		break;
+	      case GRN_OBJ_KEY_FLOAT:
+		rb_ary_push(inspected_flags, rb_str_new2("KEY_FLOAT"));
+		break;
+	      case GRN_OBJ_KEY_GEO_POINT:
+		rb_ary_push(inspected_flags, rb_str_new2("KEY_GEO_POINT"));
+		break;
+	      default:
+		break;
+	    }
+	}
 	break;
       default:
 	break;

data/ext/groonga/rb-grn-patricia-trie.c

@@ -19,7 +19,7 @@
 
 #include "rb-grn.h"
 
-grn_rc grn_obj_cast(grn_ctx *ctx, grn_obj *src, grn_obj *dest, int addp);
+grn_rc grn_obj_cast(grn_ctx *ctx, grn_obj *src, grn_obj *dest, grn_bool addp);
 
 #define SELF(object) ((RbGrnTableKeySupport *)DATA_PTR(object))
 
@@ -770,7 +770,7 @@ rb_grn_patricia_trie_open_grn_near_cursor (int argc, VALUE *argv, VALUE self,
 				   grn_ctx_at(*context, table->header.domain));
     GRN_OBJ_INIT(&casted_key, GRN_BULK, 0, table->header.domain);
     if (key_p->header.domain != table->header.domain) {
-	grn_obj_cast(*context, key_p, &casted_key, 0);
+	grn_obj_cast(*context, key_p, &casted_key, GRN_FALSE);
 	grn_obj_unlink(*context, key_p);
 	key_p = &casted_key;
     }

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

@@ -1,6 +1,7 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
   Copyright (C) 2011  Haruka Yoshihara <yoshihara@clear-code.com>
+  Copyright (C) 2012  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
@@ -21,7 +22,8 @@
 VALUE rb_cGrnPosting;
 
 VALUE
-rb_grn_posting_new (grn_posting *posting, grn_id term_id)
+rb_grn_posting_new (grn_posting *posting, grn_id term_id,
+		    VALUE rb_table, VALUE rb_lexicon)
 {
     VALUE parameters;
 
@@ -40,6 +42,9 @@ rb_grn_posting_new (grn_posting *posting, grn_id term_id)
 
 #undef SET_PARAMETER
 
+    rb_hash_aset(parameters, ID2SYM(rb_intern("table")), rb_table);
+    rb_hash_aset(parameters, ID2SYM(rb_intern("lexicon")), rb_lexicon);
+
     return rb_funcall(rb_cGrnPosting, rb_intern("new"), 1,
 		      parameters);
 }

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2012  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
@@ -129,12 +129,115 @@ rb_grn_type_initialize (int argc, VALUE *argv, VALUE self)
     return Qnil;
 }
 
+static VALUE
+rb_grn_type_size (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *type;
+
+    type = RVAL2GRNOBJECT(self, &context);
+
+    return UINT2NUM(grn_obj_get_range(context, type));
+}
+
+static VALUE
+rb_grn_type_flags (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *type;
+
+    type = RVAL2GRNOBJECT(self, &context);
+
+    return UINT2NUM(type->header.flags);
+}
+
+static VALUE
+rb_grn_type_fixed_size_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *type;
+
+    type = RVAL2GRNOBJECT(self, &context);
+
+    return CBOOL2RVAL(!(type->header.flags & GRN_OBJ_KEY_VAR_SIZE));
+}
+
+static VALUE
+rb_grn_type_variable_size_p (VALUE self)
+{
+    grn_ctx *context;
+    grn_obj *type;
+
+    type = RVAL2GRNOBJECT(self, &context);
+
+    return CBOOL2RVAL(type->header.flags & GRN_OBJ_KEY_VAR_SIZE);
+}
+
+static VALUE
+rb_grn_type_unsigned_integer_p (VALUE self)
+{
+    grn_obj *type;
+    grn_obj_flags key_type;
+
+    type = RVAL2GRNOBJECT(self, NULL);
+    key_type = type->header.flags & GRN_OBJ_KEY_MASK;
+    return CBOOL2RVAL(key_type == GRN_OBJ_KEY_UINT);
+}
+
+static VALUE
+rb_grn_type_integer_p (VALUE self)
+{
+    grn_obj *type;
+    grn_obj_flags key_type;
+
+    type = RVAL2GRNOBJECT(self, NULL);
+    key_type = type->header.flags & GRN_OBJ_KEY_MASK;
+    return CBOOL2RVAL(key_type == GRN_OBJ_KEY_INT);
+}
+
+static VALUE
+rb_grn_type_float_p (VALUE self)
+{
+    grn_obj *type;
+    grn_obj_flags key_type;
+
+    type = RVAL2GRNOBJECT(self, NULL);
+    key_type = type->header.flags & GRN_OBJ_KEY_MASK;
+    return CBOOL2RVAL(key_type == GRN_OBJ_KEY_FLOAT);
+}
+
+static VALUE
+rb_grn_type_geo_point_p (VALUE self)
+{
+    grn_obj *type;
+    grn_obj_flags key_type;
+
+    type = RVAL2GRNOBJECT(self, NULL);
+    key_type = type->header.flags & GRN_OBJ_KEY_MASK;
+    return CBOOL2RVAL(key_type == GRN_OBJ_KEY_GEO_POINT);
+}
+
 void
 rb_grn_init_type (VALUE mGrn)
 {
     rb_cGrnType = rb_define_class_under(mGrn, "Type", rb_cGrnObject);
 
     rb_define_method(rb_cGrnType, "initialize", rb_grn_type_initialize, -1);
+    rb_define_method(rb_cGrnType, "size", rb_grn_type_size, 0);
+    rb_define_method(rb_cGrnType, "flags", rb_grn_type_flags, 0);
+    rb_define_method(rb_cGrnType, "fixed_size?", rb_grn_type_fixed_size_p, 0);
+    rb_define_method(rb_cGrnType, "variable_size?",
+		     rb_grn_type_variable_size_p, 0);
+
+    rb_define_method(rb_cGrnType, "unsigned_integer?",
+		     rb_grn_type_unsigned_integer_p, 0);
+    rb_define_alias(rb_cGrnType, "uint?", "unsigned_integer?");
+
+    rb_define_method(rb_cGrnType, "integer?", rb_grn_type_integer_p, 0);
+    rb_define_alias(rb_cGrnType, "int?", "integer?");
+
+    rb_define_method(rb_cGrnType, "float?", rb_grn_type_float_p, 0);
+    rb_define_method(rb_cGrnType, "geo_point?", rb_grn_type_geo_point_p, 0);
 
     /* 任意のテーブルに属する全てのレコード(Object型はv1.2で
        サポートされます)。 */

data/ext/groonga/rb-grn.h

@@ -76,7 +76,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 2
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 6
+#define RB_GRN_MICRO_VERSION 7
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 
@@ -503,7 +503,9 @@ void           rb_grn_expression_finalizer          (grn_ctx *context,
 						     RbGrnExpression *rb_grn_expression);
 
 VALUE          rb_grn_posting_new                   (grn_posting *posting,
-						     grn_id term_id);
+						     grn_id term_id,
+						     VALUE rb_table,
+						     VALUE rb_lexicon);
 
 VALUE          rb_grn_tokyo_geo_point_new           (int   latitude,
 						     int   longitude);
@@ -582,8 +584,9 @@ VALUE          rb_grn_column_expression_builder_build
 #define GRNCOLUMN2RVAL(klass, context, column, owner) \
     (rb_grn_column_to_ruby_object(klass, context, column, owner))
 
-#define GRNINDEXCURSOR2RVAL(context, cursor) \
-    (rb_grn_index_cursor_to_ruby_object(context, cursor, GRN_TRUE))
+#define GRNINDEXCURSOR2RVAL(context, cursor, rb_table, rb_lexicon) \
+    (rb_grn_index_cursor_to_ruby_object(context, cursor, rb_table, rb_lexicon, \
+					GRN_TRUE))
 
 #define RVAL2GRNACCESSOR(object) \
     (rb_grn_accessor_from_ruby_object(object))
@@ -695,6 +698,8 @@ VALUE          rb_grn_column_to_ruby_object         (VALUE klass,
 						     grn_bool owner);
 VALUE          rb_grn_index_cursor_to_ruby_object   (grn_ctx *context,
 						     grn_obj *cursor,
+						     VALUE rb_table,
+						     VALUE rb_lexicon,
 						     grn_bool owner);
 
 grn_operator   rb_grn_operator_from_ruby_object     (VALUE object);

data/lib/groonga.rb

@@ -96,5 +96,5 @@ require 'groonga/patricia-trie'
 require 'groonga/dumper'
 require 'groonga/schema'
 require 'groonga/pagination'
-require 'groonga/query-log'
+# require 'groonga/query-log'
 require 'groonga/grntest-log'

data/lib/groonga/posting.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2011  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2011-2012  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
@@ -43,6 +43,12 @@ module Groonga
     # The number of rest posting information for the term ID.
     attr_accessor :n_rest_postings
 
+    # @return [Groonga::Table] The table of the record ID.
+    attr_reader :table
+
+    # @return [Groonga::Table] The table of the term ID.
+    attr_reader :lexicon
+
     # Creates a new Posting.
     #
     # @return The new Posting.
@@ -61,6 +67,8 @@ module Groonga
     # @option parameters [Integer] :term_frequency The term_frequency.
     # @option parameters [Integer] :weight The weight.
     # @option parameters [Integer] :n_rest_postings The n_rest_postings.
+    # @option parameters [Groonga::Table] :table The table of the record ID.
+    # @option parameters [Groonga::Table] :lexicon The table of the term ID.
     def update(parameters)
       @record_id = parameters[:record_id] || nil
       @section_id = parameters[:section_id] || nil
@@ -69,6 +77,8 @@ module Groonga
       @term_frequency = parameters[:term_frequency] || 0
       @weight = parameters[:weight] || 0
       @n_rest_postings = parameters[:n_rest_postings] || 0
+      @table = parameters[:table]
+      @lexicon = parameters[:lexicon]
     end
 
     # Returns Hash created from attributes.
@@ -83,5 +93,23 @@ module Groonga
         :n_rest_postings => @n_rest_postings
       }
     end
+
+    # @return [Groonga::Record, nil] The record for the record ID.
+    #   If table isn't assosiated, nil is returned.
+    #
+    # @since 2.0.6
+    def record
+      return nil unless @table
+      Record.new(@table, @record_id)
+    end
+
+    # @return [Groonga::Record, nil] The record for the term ID.
+    #   If lexicon isn't assosiated, nil is returned.
+    #
+    # @since 2.0.6
+    def term
+      return nil unless @lexicon
+      Record.new(@lexicon, @term_id)
+    end
   end
 end

data/test/test-index-cursor.rb

@@ -66,6 +66,30 @@ class IndexCursorTest < Test::Unit::TestCase
     assert_true(opened)
   end
 
+  def test_record
+    record = nil
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        posting = cursor.next
+        record = posting.record
+      end
+    end
+
+    assert_equal("1", record.key)
+  end
+
+  def test_term
+    term = nil
+    @terms.open_cursor do |table_cursor|
+      @content_index.open_cursor(table_cursor) do |cursor|
+        posting = cursor.next
+        term = posting.term
+      end
+    end
+
+    assert_equal("l", term.key)
+  end
+
   private
   def create_hashes(keys, values)
     hashes = []
@@ -81,7 +105,9 @@ class IndexCursorTest < Test::Unit::TestCase
 
   def setup_schema
     Groonga::Schema.define do |schema|
-      schema.create_table("Articles") do |table|
+      schema.create_table("Articles",
+                          :type => :hash,
+                          :key_type => :short_text) do |table|
         table.text("content")
       end
 
@@ -98,9 +124,9 @@ class IndexCursorTest < Test::Unit::TestCase
   end
 
   def setup_records
-    @articles.add(:content => "l")
-    @articles.add(:content => "ll")
-    @articles.add(:content => "hello")
+    @articles.add("1", :content => "l")
+    @articles.add("2", :content => "ll")
+    @articles.add("3", :content => "hello")
   end
 
   def expected_postings

data/test/test-schema.rb

@@ -338,7 +338,7 @@ class SchemaTest < Test::Unit::TestCase
                    "path: <#{path}>, " +
                    "domain: <Posts>, " +
                    "range: <Niku>, " +
-                   "flags: <COMPRESS_LZO>>",
+                   "flags: <KEY_VAR_SIZE|COMPRESS_LZO>>",
                    column.inspect)
     end
   end

data/test/test-type.rb

@@ -33,6 +33,63 @@ class TypeTest < Test::Unit::TestCase
                  exception.message)
   end
 
+  def test_size
+    assert_equal(4, Groonga["Int32"].size)
+  end
+
+  def test_flags
+    key_int = 0x01 << 3
+    assert_equal(key_int, Groonga["Int32"].flags)
+  end
+
+  def test_fixed_size?
+    assert_true(Groonga["Int32"].fixed_size?)
+  end
+
+  def test_not_fixed_size?
+    assert_false(Groonga["ShortText"].fixed_size?)
+  end
+
+  def test_variable_size?
+    assert_true(Groonga["ShortText"].variable_size?)
+  end
+
+  def test_not_variable_size?
+    assert_false(Groonga["Int32"].variable_size?)
+  end
+
+  def test_unsigned_integer?
+    assert_true(Groonga["UInt32"].unsigned_integer?)
+  end
+
+  def test_not_unsigned_integer?
+    assert_false(Groonga["Int32"].unsigned_integer?)
+  end
+
+  def test_integer?
+    assert_true(Groonga["Int32"].integer?)
+  end
+
+  def test_not_integer?
+    assert_false(Groonga["UInt32"].integer?)
+  end
+
+  def test_float?
+    assert_true(Groonga["Float"].float?)
+  end
+
+  def test_not_float?
+    assert_false(Groonga["UInt32"].float?)
+  end
+
+  def test_geo_point?
+    assert_true(Groonga["WGS84GeoPoint"].geo_point?)
+  end
+
+  def test_not_geo_point?
+    assert_false(Groonga["UInt32"].geo_point?)
+  end
+
   def test_builtins
     assert_equal_type("Object", Groonga::Type::OBJECT) # FIXME!!!
     assert_equal_type("Bool", Groonga::Type::BOOLEAN)
@@ -58,7 +115,7 @@ class TypeTest < Test::Unit::TestCase
                  "path: (temporary), " +
                  "domain: (nil), " +
                  "range: <2147483648>, " +
-                 "flags: <>>",
+                 "flags: <KEY_VAR_SIZE>>",
                  context["<longtext>"].inspect)
   end
 

data/test/test-variable-size-column.rb

@@ -99,7 +99,7 @@ class VariableSizeColumnTest < Test::Unit::TestCase
                  "path: <#{@users_name_column_path}>, " +
                  "domain: <Users>, " +
                  "range: <ShortText>, " +
-                 "flags: <>" +
+                 "flags: <KEY_VAR_SIZE>" +
                  ">",
                  @name.inspect)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rroonga
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-25 00:00:00.000000000 Z
+date: 2012-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pkg-config
@@ -224,7 +224,6 @@ files:
 - lib/groonga/context.rb
 - lib/groonga/grntest-log.rb
 - lib/groonga/geo-point.rb
-- lib/groonga/query-log.rb
 - lib/groonga/pagination.rb
 - lib/groonga/command.rb
 - lib/groonga/schema.rb
@@ -312,7 +311,6 @@ files:
 - test/groonga-test-utils.rb
 - test/test-table-dumper.rb
 - test/test-schema-type.rb
-- test/test-query-log.rb
 - test/test-patricia-trie.rb
 - test/test-version.rb
 - test/test-table-traverse.rb
@@ -349,7 +347,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4521341651743360062
+      hash: 3736378040968072494
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -358,7 +356,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4521341651743360062
+      hash: 3736378040968072494
 requirements: []
 rubyforge_project: groonga
 rubygems_version: 1.8.23
@@ -396,7 +394,6 @@ test_files:
 - test/groonga-test-utils.rb
 - test/test-table-dumper.rb
 - test/test-schema-type.rb
-- test/test-query-log.rb
 - test/test-patricia-trie.rb
 - test/test-version.rb
 - test/test-table-traverse.rb

data/lib/groonga/query-log.rb

@@ -1,348 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2011  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-require "English"
-require "shellwords"
-require "cgi"
-
-module Groonga
-  module QueryLog
-    class Command
-      class << self
-        @@registered_commands = {}
-        def register(name, klass)
-          @@registered_commands[name] = klass
-        end
-
-        def parse(input)
-          if input.start_with?("/d/")
-            parse_uri_path(input)
-          else
-            parse_command_line(input)
-          end
-        end
-
-        private
-        def parse_uri_path(path)
-          name, parameters_string = path.split(/\?/, 2)
-          parameters = {}
-          if parameters_string
-            parameters_string.split(/&/).each do |parameter_string|
-              key, value = parameter_string.split(/\=/, 2)
-              parameters[key] = CGI.unescape(value)
-            end
-          end
-          name = name.gsub(/\A\/d\//, '')
-          name, output_type = name.split(/\./, 2)
-          parameters["output_type"] = output_type if output_type
-          command_class = @@registered_commands[name] || self
-          command = command_class.new(name, parameters)
-          command.original_format = :uri
-          command
-        end
-
-        def parse_command_line(command_line)
-          name, *options = Shellwords.shellwords(command_line)
-          parameters = {}
-          options.each_slice(2) do |key, value|
-            parameters[key.gsub(/\A--/, '')] = value
-          end
-          command_class = @@registered_commands[name] || self
-          command = command_class.new(name, parameters)
-          command.original_format = :command
-          command
-        end
-      end
-
-      attr_reader :name, :parameters
-      attr_accessor :original_format
-      def initialize(name, parameters)
-        @name = name
-        @parameters = parameters
-        @original_format = nil
-      end
-
-      def ==(other)
-        other.is_a?(self.class) and
-          @name == other.name and
-          @parameters == other.parameters
-      end
-
-      def uri_format?
-        @original_format == :uri
-      end
-
-      def command_format?
-        @original_format == :command
-      end
-
-      def to_uri_format
-        path = "/d/#{@name}"
-        parameters = @parameters.dup
-        output_type = parameters.delete("output_type")
-        path << ".#{output_type}" if output_type
-        unless parameters.empty?
-          sorted_parameters = parameters.sort_by do |name, _|
-            name.to_s
-          end
-          uri_parameters = sorted_parameters.collect do |name, value|
-            "#{CGI.escape(name)}=#{CGI.escape(value)}"
-          end
-          path << "?"
-          path << uri_parameters.join("&")
-        end
-        path
-      end
-
-      def to_command_format
-        command_line = [@name]
-        sorted_parameters = @parameters.sort_by do |name, _|
-          name.to_s
-        end
-        sorted_parameters.each do |name, value|
-          escaped_value = value.gsub(/[\n"\\]/) do
-            special_character = $MATCH
-            case special_character
-            when "\n"
-              "\\n"
-            else
-              "\\#{special_character}"
-            end
-          end
-          command_line << "--#{name}"
-          command_line << "\"#{escaped_value}\""
-        end
-        command_line.join(" ")
-      end
-    end
-
-    class SelectCommand < Command
-      register("select", self)
-
-      def sortby
-        @parameters["sortby"]
-      end
-
-      def scorer
-        @parameters["scorer"]
-      end
-
-      def query
-        @parameters["query"]
-      end
-
-      def filter
-        @parameters["filter"]
-      end
-
-      def conditions
-        @conditions ||= filter.split(/(?:&&|&!|\|\|)/).collect do |condition|
-          condition = condition.strip
-          condition = condition.gsub(/\A[\s\(]*/, '')
-          condition = condition.gsub(/[\s\)]*\z/, '') unless /\(/ =~ condition
-          condition
-        end
-      end
-
-      def drilldowns
-        @drilldowns ||= (@parameters["drilldown"] || "").split(/\s*,\s*/)
-      end
-
-      def output_columns
-        @parameters["output_columns"]
-      end
-    end
-
-    class Statistic
-      attr_reader :context_id, :start_time, :raw_command
-      attr_reader :elapsed, :return_code
-      attr_accessor :slow_operation_threshold, :slow_response_threshold
-      def initialize(context_id)
-        @context_id = context_id
-        @start_time = nil
-        @command = nil
-        @raw_command = nil
-        @operations = []
-        @elapsed = nil
-        @return_code = 0
-        @slow_operation_threshold = 0.1
-        @slow_response_threshold = 0.2
-      end
-
-      def start(start_time, command)
-        @start_time = start_time
-        @raw_command = command
-      end
-
-      def finish(elapsed, return_code)
-        @elapsed = elapsed
-        @return_code = return_code
-      end
-
-      def command
-        @command ||= Command.parse(@raw_command)
-      end
-
-      def elapsed_in_seconds
-        nano_seconds_to_seconds(@elapsed)
-      end
-
-      def last_time
-        @start_time + elapsed_in_seconds
-      end
-
-      def slow?
-        elapsed_in_seconds >= @slow_response_threshold
-      end
-
-      def each_operation
-        previous_elapsed = 0
-        ensure_parse_command
-        operation_context_context = {
-          :filter_index => 0,
-          :drilldown_index => 0,
-        }
-        @operations.each_with_index do |operation, i|
-          relative_elapsed = operation[:elapsed] - previous_elapsed
-          relative_elapsed_in_seconds = nano_seconds_to_seconds(relative_elapsed)
-          previous_elapsed = operation[:elapsed]
-          parsed_operation = {
-            :i => i,
-            :elapsed => operation[:elapsed],
-            :elapsed_in_seconds => nano_seconds_to_seconds(operation[:elapsed]),
-            :relative_elapsed => relative_elapsed,
-            :relative_elapsed_in_seconds => relative_elapsed_in_seconds,
-            :name => operation[:name],
-            :context => operation_context(operation[:name],
-                                          operation_context_context),
-            :n_records => operation[:n_records],
-            :slow? => slow_operation?(relative_elapsed_in_seconds),
-          }
-          yield parsed_operation
-        end
-      end
-
-      def add_operation(operation)
-        @operations << operation
-      end
-
-      def operations
-        _operations = []
-        each_operation do |operation|
-          _operations << operation
-        end
-        _operations
-      end
-
-      def select_command?
-        command.name == "select"
-      end
-
-      private
-      def nano_seconds_to_seconds(nano_seconds)
-        nano_seconds / 1000.0 / 1000.0 / 1000.0
-      end
-
-      def operation_context(label, context)
-        case label
-        when "filter"
-          if @select_command.query and context[:query_used].nil?
-            context[:query_used] = true
-            "query: #{@select_command.query}"
-          else
-            index = context[:filter_index]
-            context[:filter_index] += 1
-            @select_command.conditions[index]
-          end
-        when "sort"
-          @select_command.sortby
-        when "score"
-          @select_command.scorer
-        when "output"
-          @select_command.output_columns
-        when "drilldown"
-          index = context[:drilldown_index]
-          context[:drilldown_index] += 1
-          @select_command.drilldowns[index]
-        else
-          nil
-        end
-      end
-
-      def ensure_parse_command
-        return unless select_command?
-        @select_command = SelectCommand.parse(@raw_command)
-      end
-
-      def slow_operation?(elapsed)
-        elapsed >= @slow_operation_threshold
-      end
-    end
-
-    class Parser
-      def initialize
-      end
-
-      def parse(input, &block)
-        current_statistics = {}
-        input.each_line do |line|
-          case line
-          when /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)\.(\d+)\|(.+?)\|([>:<])/
-            year, month, day, hour, minutes, seconds, micro_seconds =
-              $1, $2, $3, $4, $5, $6, $7
-            context_id = $8
-            type = $9
-            rest = $POSTMATCH.strip
-            time_stamp = Time.local(year, month, day, hour, minutes, seconds,
-                                    micro_seconds)
-            parse_line(current_statistics,
-                       time_stamp, context_id, type, rest, &block)
-          end
-        end
-      end
-
-      private
-      def parse_line(current_statistics,
-                     time_stamp, context_id, type, rest, &block)
-        case type
-        when ">"
-          statistic = Statistic.new(context_id)
-          statistic.start(time_stamp, rest)
-          current_statistics[context_id] = statistic
-        when ":"
-          return unless /\A(\d+) (.+)\((\d+)\)/ =~ rest
-          elapsed = $1
-          name = $2
-          n_records = $3.to_i
-          statistic = current_statistics[context_id]
-          return if statistic.nil?
-          statistic.add_operation(:name => name,
-                                  :elapsed => elapsed.to_i,
-                                  :n_records => n_records)
-        when "<"
-          return unless /\A(\d+) rc=(\d+)/ =~ rest
-          elapsed = $1
-          return_code = $2
-          statistic = current_statistics.delete(context_id)
-          return if statistic.nil?
-          statistic.finish(elapsed.to_i, return_code.to_i)
-          block.call(statistic)
-        end
-      end
-    end
-  end
-end

data/test/test-query-log.rb

@@ -1,258 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (C) 2011  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
-require "cgi"
-
-module QueryLogTest
-  module CommandParseTestUtils
-    private
-    def command(name, parameters)
-      Groonga::QueryLog::Command.new(name, parameters)
-    end
-
-    def parse_http_path(command, parameters)
-      path = "/d/#{command}.json"
-      unless parameters.empty?
-        uri_parameters = parameters.collect do |key, value|
-          [CGI.escape(key.to_s), CGI.escape(value.to_s)].join("=")
-        end
-        path << "?"
-        path << uri_parameters.join("&")
-      end
-      Groonga::QueryLog::Command.parse(path)
-    end
-
-    def parse_command_line(command, parameters)
-      command_line = "#{command} --output_type json"
-      parameters.each do |key, value|
-        if /"| / =~ value
-          escaped_value = '"' + value.gsub(/"/, '\"') + '"'
-        else
-          escaped_value = value
-        end
-        command_line << " --#{key} #{escaped_value}"
-      end
-      Groonga::QueryLog::Command.parse(command_line)
-    end
-  end
-
-  module HTTPCommandParseTestUtils
-    private
-    def parse(command, parameters={})
-      parse_http_path(command, parameters)
-    end
-  end
-
-  module CommandLineCommandParseTestUtils
-    private
-    def parse(command, parameters={})
-      parse_command_line(command, parameters)
-    end
-  end
-
-  module SelectCommandParseTests
-    include CommandParseTestUtils
-
-    def test_parameters
-      select = parse("select",
-                     :table => "Users",
-                     :filter => "age<=30")
-      assert_equal(command("select",
-                           "table" => "Users",
-                           "filter" => "age<=30",
-                           "output_type" => "json"),
-                   select)
-    end
-
-    def test_scorer
-      select = parse("select",
-                     :table => "Users",
-                     :filter => "age<=30",
-                     :scorer => "_score = random()")
-      assert_equal("_score = random()", select.scorer)
-    end
-
-    def test_to_uri_format
-      select = parse("select",
-                     :table => "Users",
-                     :filter => "age<=30")
-      assert_equal("/d/select.json?filter=age%3C%3D30&table=Users",
-                   select.to_uri_format)
-    end
-
-    def test_to_command_format
-      select = parse("select",
-                     :table => "Users",
-                     :filter => "age<=30")
-      assert_equal("select --filter \"age<=30\" " +
-                   "--output_type \"json\" --table \"Users\"",
-                   select.to_command_format)
-    end
-  end
-
-  module SelectCommandParseFilterTests
-    include CommandParseTestUtils
-
-    def test_parenthesis
-      filter = 'geo_in_rectangle(location,' +
-                                '"35.73360x139.7394","62614x139.7714") && ' +
-               '((type == "たいやき" || type == "和菓子")) && ' +
-               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
-      select = parse("select",
-                     :table => "Users",
-                     :filter => filter)
-      assert_equal(['geo_in_rectangle(location,' +
-                                     '"35.73360x139.7394","62614x139.7714")',
-                     'type == "たいやき"',
-                     'type == "和菓子"',
-                     'keyword @ "たいやき"',
-                     'keyword @ "白"',
-                     'keyword @ "養殖"'],
-                   select.conditions)
-    end
-
-    def test_to_uri_format
-      filter = 'geo_in_rectangle(location,' +
-                                '"35.73360x139.7394","62614x139.7714") && ' +
-               '((type == "たいやき" || type == "和菓子")) && ' +
-               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
-      select = parse("select",
-                     :table => "Users",
-                     :filter => filter)
-      assert_equal("/d/select.json?filter=geo_in_rectangle%28location%2C" +
-                   "%2235.73360x139.7394%22%2C%2262614x139.7714%22%29+" +
-                   "%26%26+%28%28type+" +
-                   "%3D%3D+%22%E3%81%9F%E3%81%84%E3%82%84%E3%81%8D%22+" +
-                   "%7C%7C+type+%3D%3D+" +
-                   "%22%E5%92%8C%E8%8F%93%E5%AD%90%22%29%29+" +
-                   "%26%26+keyword+%40+" +
-                   "%22%E3%81%9F%E3%81%84%E3%82%84%E3%81%8D%22+%26%21+" +
-                   "keyword+%40+%22%E7%99%BD%22+%26%21+" +
-                   "keyword+%40+%22%E9%A4%8A%E6%AE%96%22&table=Users",
-                   select.to_uri_format)
-    end
-
-    def test_to_command_format
-      filter = 'geo_in_rectangle(location,' +
-                                '"35.73360x139.7394","62614x139.7714") && ' +
-               '((type == "たいやき" || type == "和菓子")) && ' +
-               'keyword @ "たいやき" &! keyword @ "白" &! keyword @ "養殖"'
-      select = parse("select",
-                     :table => "Users",
-                     :filter => filter)
-      assert_equal("select " +
-                   "--filter " +
-                     "\"geo_in_rectangle(location," +
-                     "\\\"35.73360x139.7394\\\",\\\"62614x139.7714\\\") && " +
-                     "((type == \\\"たいやき\\\" || " +
-                       "type == \\\"和菓子\\\")) && " +
-                     "keyword @ \\\"たいやき\\\" &! keyword @ \\\"白\\\" &! " +
-                     "keyword @ \\\"養殖\\\"\" " +
-                   "--output_type \"json\" --table \"Users\"",
-                   select.to_command_format)
-    end
-  end
-
-  class HTTPSelectCommandParseTest < Test::Unit::TestCase
-    include SelectCommandParseTests
-    include SelectCommandParseFilterTests
-    include HTTPCommandParseTestUtils
-
-    def test_uri_format?
-      command = parse("status")
-      assert_predicate(command, :uri_format?)
-    end
-
-    def test_command_format?
-      command = parse("status")
-      assert_not_predicate(command, :command_format?)
-    end
-  end
-
-  class CommandLineSelecCommandParseTest < Test::Unit::TestCase
-    include SelectCommandParseTests
-    include SelectCommandParseFilterTests
-    include CommandLineCommandParseTestUtils
-
-    def test_uri_format?
-      command = parse("status")
-      assert_not_predicate(command, :uri_format?)
-    end
-
-    def test_command_format?
-      command = parse("status")
-      assert_predicate(command, :command_format?)
-    end
-  end
-
-  class StatisticOperationParseTest < Test::Unit::TestCase
-    def test_context
-      operations = statistics.first.operations.collect do |operation|
-        [operation[:name], operation[:context]]
-      end
-      expected = [
-        ["filter", "local_name @ \"gsub\""],
-        ["filter", "description @ \"string\""],
-        ["select", nil],
-        ["sort", "_score"],
-        ["output", "_key"],
-        ["drilldown", "name"],
-        ["drilldown", "class"],
-      ]
-      assert_equal(expected, operations)
-    end
-
-    def test_n_records
-      operations = statistics.first.operations.collect do |operation|
-        [operation[:name], operation[:n_records]]
-      end
-      expected = [
-        ["filter", 15],
-        ["filter", 13],
-        ["select", 13],
-        ["sort", 10],
-        ["output", 10],
-        ["drilldown", 3],
-        ["drilldown", 2],
-      ]
-      assert_equal(expected, operations)
-    end
-
-    private
-    def log
-      <<-EOL
-2011-06-02 16:27:04.731685|5091e5c0|>/d/select.join?table=Entries&filter=local_name+%40+%22gsub%22+%26%26+description+%40+%22string%22&sortby=_score&output_columns=_key&drilldown=name,class
-2011-06-02 16:27:04.733539|5091e5c0|:000000001849451 filter(15)
-2011-06-02 16:27:04.734978|5091e5c0|:000000003293459 filter(13)
-2011-06-02 16:27:04.735012|5091e5c0|:000000003327415 select(13)
-2011-06-02 16:27:04.735096|5091e5c0|:000000003411824 sort(10)
-2011-06-02 16:27:04.735232|5091e5c0|:000000003547265 output(10)
-2011-06-02 16:27:04.735606|5091e5c0|:000000003921419 drilldown(3)
-2011-06-02 16:27:04.735762|5091e5c0|:000000004077552 drilldown(2)
-2011-06-02 16:27:04.735808|5091e5c0|<000000004123726 rc=0
-EOL
-    end
-
-    def statistics
-      statistics = []
-      parser = Groonga::QueryLog::Parser.new
-      parser.parse(StringIO.new(log)) do |statistic|
-        statistics << statistic
-      end
-      statistics
-    end
-  end
-end