rroonga 1.3.0 → 1.3.1

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

@@ -211,13 +211,31 @@ VALUE
 rb_grn_context_rb_string_encode (grn_ctx *context, VALUE rb_string)
 {
 #ifdef HAVE_RUBY_ENCODING_H
-    rb_encoding *encoding, *to_encode;
+    int index, to_index;
+    rb_encoding *encoding, *to_encoding;
+    grn_encoding context_encoding;
+
+    context_encoding = context->encoding;
+    if (context->encoding == GRN_ENC_DEFAULT)
+	context->encoding = grn_get_default_encoding();
+    if (context->encoding == GRN_ENC_NONE)
+	return rb_string;
+
+    if (RSTRING_LEN(rb_string) < 0)
+	return rb_string;
 
     encoding = rb_enc_get(rb_string);
-    to_encode = rb_grn_encoding_to_ruby_encoding(context->encoding);
-    if (rb_enc_to_index(encoding) != rb_enc_to_index(to_encode))
-	rb_string = rb_str_encode(rb_string, rb_enc_from_encoding(to_encode),
-				  0, Qnil);
+    to_encoding = rb_grn_encoding_to_ruby_encoding(context_encoding);
+    index = rb_enc_to_index(encoding);
+    to_index = rb_enc_to_index(to_encoding);
+    if (index == to_index)
+	return rb_string;
+
+    if (rb_enc_asciicompat(to_encoding) && rb_enc_str_asciionly_p(rb_string))
+	return rb_string;
+
+    rb_string = rb_str_encode(rb_string, rb_enc_from_encoding(to_encoding),
+			      0, Qnil);
 #endif
     return rb_string;
 }

data/ext/groonga/rb-grn-index-column.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
@@ -453,11 +453,7 @@ rb_grn_index_column_search (int argc, VALUE *argv, VALUE self)
 
     rb_scan_args(argc, argv, "11", &rb_query, &options);
 
-    if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cGrnQuery))) {
-	grn_query *_query;
-	_query = RVAL2GRNQUERY(rb_query);
-	query = (grn_obj *)_query;
-    } else if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cInteger))) {
+    if (CBOOL2RVAL(rb_obj_is_kind_of(rb_query, rb_cInteger))) {
 	grn_id id;
 	id = NUM2UINT(rb_query);
 	GRN_TEXT_SET(context, id_query, &id, sizeof(grn_id));

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009-2011  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
@@ -20,6 +20,36 @@
 
 VALUE rb_mGrnOperator;
 
+grn_operator
+rb_grn_operator_from_ruby_object (VALUE rb_operator)
+{
+    grn_operator operator = GRN_OP_OR;
+
+    if (NIL_P(rb_operator) ||
+        rb_grn_equal_option(rb_operator, "or") ||
+        rb_grn_equal_option(rb_operator, "||")) {
+        operator = GRN_OP_OR;
+    } else if (rb_grn_equal_option(rb_operator, "and") ||
+               rb_grn_equal_option(rb_operator, "+") ||
+               rb_grn_equal_option(rb_operator, "&&")) {
+        operator = GRN_OP_AND;
+    } else if (rb_grn_equal_option(rb_operator, "but") ||
+               rb_grn_equal_option(rb_operator, "not") ||
+               rb_grn_equal_option(rb_operator, "-")) {
+        operator = GRN_OP_BUT;
+    } else if (rb_grn_equal_option(rb_operator, "adjust") ||
+               rb_grn_equal_option(rb_operator, ">")) {
+        operator = GRN_OP_ADJUST;
+    } else {
+        rb_raise(rb_eArgError,
+                 "operator should be one of "
+                 "[:or, :||, :and, :+, :&&, :but, :not, :-, :adjust, :>]: <%s>",
+                 rb_grn_inspect(rb_operator));
+    }
+
+    return operator;
+}
+
 void
 rb_grn_init_operator (VALUE mGrn)
 {

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-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
@@ -28,6 +28,80 @@ VALUE rb_cGrnVariableSizeColumn;
  * 可変長データ用のカラム。
  */
 
+/*
+ * Document-method: compressed?
+ *
+ * call-seq:
+ *   column.compressed?        -> boolean
+ *   column.compressed?(type)  -> boolean
+ *
+ * Returns whether the column is compressed or not. If
+ * @type@ is specified, it returns whether the column is
+ * compressed by @type@ or not.
+ *
+ * @return [Boolean] whether the column is compressed or not.
+ * @param [:zlib, :lzo] type (nil) If @type@ isn't @nil@,
+ *   it checks whether specified compressed type is used or
+ *   not.
+ * @since 1.3.1
+ */
+static VALUE
+rb_grn_variable_size_column_compressed_p (int argc, VALUE *argv, VALUE self)
+{
+    RbGrnColumn *rb_grn_column;
+    grn_ctx *context = NULL;
+    grn_obj *column;
+    grn_obj_flags flags;
+    VALUE type;
+    grn_bool compressed_p = GRN_FALSE;
+    grn_bool accept_any_type = GRN_FALSE;
+    grn_bool need_zlib_check = GRN_FALSE;
+    grn_bool need_lzo_check = GRN_FALSE;
+
+    rb_scan_args(argc, argv, "01", &type);
+
+    if (NIL_P(type)) {
+	accept_any_type = GRN_TRUE;
+    } else {
+	if (rb_grn_equal_option(type, "zlib")) {
+	    need_zlib_check = GRN_TRUE;
+	} else if (rb_grn_equal_option(type, "lzo")) {
+	    need_lzo_check = GRN_TRUE;
+	} else {
+	    rb_raise(rb_eArgError,
+		     "compressed type should be <:zlib> or <:lzo>: <%s>",
+		     rb_grn_inspect(type));
+	}
+    }
+
+    rb_grn_column = SELF(self);
+    rb_grn_object_deconstruct(RB_GRN_OBJECT(rb_grn_column), &column, &context,
+			      NULL, NULL,
+			      NULL, NULL);
+
+    flags = column->header.flags;
+    switch (flags & GRN_OBJ_COMPRESS_MASK) {
+      case GRN_OBJ_COMPRESS_ZLIB:
+	if (accept_any_type || need_zlib_check) {
+	    grn_obj support_p;
+	    GRN_BOOL_INIT(&support_p, 0);
+	    grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_ZLIB, &support_p);
+	    compressed_p = GRN_BOOL_VALUE(&support_p);
+	}
+	break;
+      case GRN_OBJ_COMPRESS_LZO:
+	if (accept_any_type || need_lzo_check) {
+	    grn_obj support_p;
+	    GRN_BOOL_INIT(&support_p, 0);
+	    grn_obj_get_info(context, NULL, GRN_INFO_SUPPORT_LZO, &support_p);
+	    compressed_p = GRN_BOOL_VALUE(&support_p);
+	}
+	break;
+    }
+
+    return CBOOL2RVAL(compressed_p);
+}
+
 /*
  * Document-method: defrag
  *
@@ -77,6 +151,8 @@ rb_grn_init_variable_size_column (VALUE mGrn)
     rb_cGrnVariableSizeColumn =
 	rb_define_class_under(mGrn, "VariableSizeColumn", rb_cGrnColumn);
 
+    rb_define_method(rb_cGrnVariableSizeColumn, "compressed?",
+		     rb_grn_variable_size_column_compressed_p, -1);
     rb_define_method(rb_cGrnVariableSizeColumn, "defrag",
 		     rb_grn_variable_size_column_defrag, -1);
 }

data/ext/groonga/rb-grn.h

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009-2011  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
@@ -72,7 +72,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 1
 #define RB_GRN_MINOR_VERSION 3
-#define RB_GRN_MICRO_VERSION 0
+#define RB_GRN_MICRO_VERSION 1
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 
@@ -227,7 +227,6 @@ RB_GRN_VAR VALUE rb_cGrnAccessor;
 RB_GRN_VAR VALUE rb_cGrnViewAccessor;
 RB_GRN_VAR VALUE rb_cGrnRecord;
 RB_GRN_VAR VALUE rb_cGrnViewRecord;
-RB_GRN_VAR VALUE rb_cGrnQuery;
 RB_GRN_VAR VALUE rb_cGrnLogger;
 RB_GRN_VAR VALUE rb_cGrnSnippet;
 RB_GRN_VAR VALUE rb_cGrnVariable;
@@ -270,7 +269,6 @@ void           rb_grn_init_accessor                 (VALUE mGrn);
 void           rb_grn_init_view_accessor            (VALUE mGrn);
 void           rb_grn_init_record                   (VALUE mGrn);
 void           rb_grn_init_view_record              (VALUE mGrn);
-void           rb_grn_init_query                    (VALUE mGrn);
 void           rb_grn_init_variable                 (VALUE mGrn);
 void           rb_grn_init_operator                 (VALUE mGrn);
 void           rb_grn_init_expression               (VALUE mGrn);
@@ -555,9 +553,6 @@ VALUE          rb_grn_column_expression_builder_build
 #define GRNACCESSOR2RVAL(context, accessor, owner) \
     (rb_grn_accessor_to_ruby_object(context, accessor, owner))
 
-#define RVAL2GRNQUERY(object)         (rb_grn_query_from_ruby_object(object))
-#define GRNQUERY2RVAL(context, column)(rb_grn_query_to_ruby_object(context, column))
-
 #define RVAL2GRNOPERATOR(object)      (rb_grn_operator_from_ruby_object(object))
 
 #define RVAL2GRNLOGGER(object)        (rb_grn_logger_from_ruby_object(object))
@@ -665,10 +660,6 @@ VALUE          rb_grn_index_cursor_to_ruby_object   (grn_ctx *context,
 						     grn_obj *cursor,
 						     grn_bool owner);
 
-grn_query     *rb_grn_query_from_ruby_object        (VALUE object);
-VALUE          rb_grn_query_to_ruby_object          (grn_ctx *context,
-						     grn_query *query);
-
 grn_operator   rb_grn_operator_from_ruby_object     (VALUE object);
 
 grn_logger_info *

data/ext/groonga/rb-groonga.c

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; c-file-style: "ruby" -*- */
 /*
-  Copyright (C) 2009-2011  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
@@ -138,7 +138,6 @@ Init_groonga (void)
     rb_grn_init_view_accessor(mGrn);
     rb_grn_init_record(mGrn);
     rb_grn_init_view_record(mGrn);
-    rb_grn_init_query(mGrn);
     rb_grn_init_variable(mGrn);
     rb_grn_init_operator(mGrn);
     rb_grn_init_expression(mGrn);

data/lib/groonga/command.rb

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+#
+# 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
+# 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
+
+module Groonga
+  module Command
+    class Builder
+      class << self
+        def escape_value(value)
+          escaped_value = value.to_s.gsub(/"/, '\\"')
+          "\"#{escaped_value}\""
+        end
+      end
+
+      attr_reader :command, :arguments
+      def initialize(command, arguments={})
+        @command = command
+        @arguments = arguments
+      end
+
+      def [](key)
+        @arguments[key]
+      end
+
+      def []=(key, value)
+        @arguments[key] = value
+      end
+
+      def build
+        query = "#{@command} "
+        @arguments.each do |key, value|
+          value = value.join(", ") if value.is_a?(::Array)
+          escaped_value = self.class.escape_value(value)
+          query << " --#{key} #{escaped_value}"
+        end
+        query
+      end
+    end
+
+    class Select
+      def initialize(context, table, options)
+        @context = context
+        @table = table
+        @options = normalize_options(options)
+      end
+
+      def exec
+        request_id = @context.send(query)
+        loop do
+          response_id, result = @context.receive
+          if request_id == response_id
+            drill_down_keys = @options["drilldown"]
+            if drill_down_keys.is_a?(String)
+              drill_down_keys = drill_down_keys.split(/(?:\s+|\s*,\s*)/)
+            end
+            return Result.parse(result, drill_down_keys)
+          end
+          # raise if request_id < response_id
+        end
+      end
+
+      private
+      def normalize_options(options)
+        normalized_options = {}
+        options.each do |key, value|
+          normalized_options[normalize_option_name(key)] = value
+        end
+        normalized_options
+      end
+
+      def normalize_option_name(name)
+        name = name.to_s.gsub(/-/, "_").gsub(/drill_down/, "drilldown")
+        name.gsub(/sort_by/, 'sortby')
+      end
+
+      def query
+        if @table.is_a?(String)
+          table_name = @table
+        else
+          table_name = @table.name
+        end
+        builder = Builder.new("select", @options.merge(:table => table_name))
+        builder.build
+      end
+
+      class Result < Struct.new(:n_hits, :columns, :values, :drill_down)
+        class << self
+          def parse(json, drill_down_keys)
+            select_result, *drill_down_results = JSON.parse(json)
+            result = new
+            n_hits, columns, values = extract_result(select_result)
+            result.n_hits = n_hits
+            result.columns = columns
+            result.values = values
+            if drill_down_results
+              result.drill_down = parse_drill_down_results(drill_down_results,
+                                                           drill_down_keys)
+            end
+            result
+          end
+
+          def create_records(columns, values)
+            records = []
+            values.each do |value|
+              record = {}
+              columns.each_with_index do |(name, type), i|
+                record[name] = convert_value(value[i], type)
+              end
+              records << record
+            end
+            records
+          end
+
+          private
+          def parse_drill_down_results(results, keys)
+            named_results = {}
+            results.each_with_index do |drill_down, i|
+              n_hits, columns, values = extract_result(drill_down)
+              drill_down_result = DrillDownResult.new
+              drill_down_result.n_hits = n_hits
+              drill_down_result.columns = columns
+              drill_down_result.values = values
+              named_results[keys[i]] = drill_down_result
+            end
+            named_results
+          end
+
+          def extract_result(result)
+            meta_data, columns, *values = result
+            n_hits, = meta_data
+            [n_hits, columns, values]
+          end
+
+          def convert_value(value, type)
+            case type
+            when "Time"
+              Time.at(value)
+            else
+              value
+            end
+          end
+        end
+
+        def records
+          @records ||= self.class.create_records(columns, values)
+        end
+
+        class DrillDownResult < Struct.new(:n_hits, :columns, :values)
+          def records
+            @records ||= Result.create_records(columns, values)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/groonga/context.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2010-2011  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2010-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
@@ -15,6 +15,8 @@
 # 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 "groonga/command"
+
 module Groonga
   class Context
     # _path_ にある既存のデータベースを開く。ブロックを指定した場
@@ -70,130 +72,8 @@ module Groonga
     # @option options [Array] XXX TODO
     #   TODO
     def select(table, options={})
-      select = SelectCommand.new(self, table, options)
+      select = Command::Select.new(self, table, options)
       select.exec
     end
-
-    class SelectResult < Struct.new(:n_hits, :columns, :values,
-                                    :drill_down)
-      class << self
-        def parse(json, drill_down_keys)
-          select_result, *drill_down_results = JSON.parse(json)
-          result = new
-          n_hits, columns, values = extract_result(select_result)
-          result.n_hits = n_hits
-          result.columns = columns
-          result.values = values
-          if drill_down_results
-            result.drill_down = parse_drill_down_results(drill_down_results,
-                                                         drill_down_keys)
-          end
-          result
-        end
-
-        def create_records(columns, values)
-          records = []
-          values.each do |value|
-            record = {}
-            columns.each_with_index do |(name, type), i|
-              record[name] = convert_value(value[i], type)
-            end
-            records << record
-          end
-          records
-        end
-
-        private
-        def parse_drill_down_results(results, keys)
-          named_results = {}
-          results.each_with_index do |drill_down, i|
-            n_hits, columns, values = extract_result(drill_down)
-            drill_down_result = DrillDownResult.new
-            drill_down_result.n_hits = n_hits
-            drill_down_result.columns = columns
-            drill_down_result.values = values
-            named_results[keys[i]] = drill_down_result
-          end
-          named_results
-        end
-
-        def extract_result(result)
-          meta_data, columns, *values = result
-          n_hits, = meta_data
-          [n_hits, columns, values]
-        end
-
-        def convert_value(value, type)
-          case type
-          when "Time"
-            Time.at(value)
-          else
-            value
-          end
-        end
-      end
-
-      def records
-        @records ||= self.class.create_records(columns, values)
-      end
-
-      class DrillDownResult < Struct.new(:n_hits, :columns, :values)
-        def records
-          @records ||= SelectResult.create_records(columns, values)
-        end
-      end
-    end
-
-    class SelectCommand
-      def initialize(context, table, options)
-        @context = context
-        @table = table
-        @options = normalize_options(options)
-      end
-
-      def exec
-        request_id = @context.send(query)
-        loop do
-          response_id, result = @context.receive
-          if request_id == response_id
-            drill_down_keys = @options["drilldown"]
-            if drill_down_keys.is_a?(String)
-              drill_down_keys = drill_down_keys.split(/(?:\s+|\s*,\s*)/)
-            end
-            return SelectResult.parse(result, drill_down_keys)
-          end
-          # raise if request_id < response_id
-        end
-      end
-
-      private
-      def normalize_options(options)
-        normalized_options = {}
-        options.each do |key, value|
-          normalized_options[normalize_option_name(key)] = value
-        end
-        normalized_options
-      end
-
-      def normalize_option_name(name)
-        name = name.to_s.gsub(/-/, "_").gsub(/drill_down/, "drilldown")
-        name.gsub(/sort_by/, 'sortby')
-      end
-
-      def query
-        if @table.is_a?(String)
-          table_name = @table
-        else
-          table_name = @table.name
-        end
-        _query = "select #{table_name}"
-        @options.each do |key, value|
-          value = value.join(", ") if value.is_a?(::Array)
-          escaped_value = value.to_s.gsub(/"/, '\\"')
-          _query << " --#{key} \"#{escaped_value}\""
-        end
-        _query
-      end
-    end
   end
 end