rroonga 2.0.4-x86-mingw32 → 2.0.7-x86-mingw32

data/ext/groonga/rb-groonga.c

@@ -70,8 +70,8 @@ rb_grn_init_runtime_version (VALUE mGrn)
 
     rb_obj_freeze(runtime_version);
     /*
-     * 利用しているgroongaのバージョン。<tt>[メジャーバージョ
-     * ン, マイナーバージョン, マイクロバージョン, タグ]</tt>の
+     * 利用しているgroongaのバージョン。 @[メジャーバージョ
+     * ン, マイナーバージョン, マイクロバージョン, タグ]@ の
      * 配列。
      */
     rb_define_const(mGrn, "VERSION", runtime_version);
@@ -90,8 +90,8 @@ rb_grn_init_version (VALUE mGrn)
 				INT2NUM(GRN_MICRO_VERSION));
     rb_obj_freeze(build_version);
     /*
-     * ビルドしたgroongaのバージョン。<tt>[メジャーバージョン,
-     * マイナーバージョン, マイクロバージョン]</tt>の配列。
+     * ビルドしたgroongaのバージョン。 @[メジャーバージョン,
+     * マイナーバージョン, マイクロバージョン]@ の配列。
      */
     rb_define_const(mGrn, "BUILD_VERSION", build_version);
 
@@ -101,8 +101,8 @@ rb_grn_init_version (VALUE mGrn)
 				   INT2NUM(RB_GRN_MICRO_VERSION));
     rb_obj_freeze(bindings_version);
     /*
-     * rroongaのバージョン。<tt>[メジャーバージョン, マ
-     * イナーバージョン, マイクロバージョン]</tt>の配列。
+     * rroongaのバージョン。 @[メジャーバージョン, マ
+     * イナーバージョン, マイクロバージョン]@ の配列。
      */
     rb_define_const(mGrn, "BINDINGS_VERSION", bindings_version);
 }
@@ -136,6 +136,7 @@ Init_groonga (void)
     rb_grn_init_column(mGrn);
     rb_grn_init_accessor(mGrn);
     rb_grn_init_view_accessor(mGrn);
+    rb_grn_init_geo_point(mGrn);
     rb_grn_init_record(mGrn);
     rb_grn_init_view_record(mGrn);
     rb_grn_init_variable(mGrn);

data/lib/groonga/command.rb

@@ -20,7 +20,9 @@ module Groonga
     class Builder
       class << self
         def escape_value(value)
-          escaped_value = value.to_s.gsub(/"/, '\\"')
+          escaped_value = value.to_s.gsub(/[\\"]/) do |matched|
+            "\\#{matched}"
+          end
           "\"#{escaped_value}\""
         end
       end

data/lib/groonga/database.rb

@@ -0,0 +1,27 @@
+# -*- 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
+  class Database
+    # @return [Array<Groonga::Table>] tables defined in the database.
+    def tables
+      find_all do |object|
+        object.is_a?(Groonga::Table)
+      end
+    end
+  end
+end

data/lib/groonga/dumper.rb

@@ -18,6 +18,17 @@
 require 'stringio'
 
 module Groonga
+  module Dumper
+    module_function
+    def default_output
+      StringIO.new(utf8_string)
+    end
+
+    def utf8_string
+      ""
+    end
+  end
+
   # データベースの内容をgrn式形式の文字列として出力するクラス。
   class DatabaseDumper
     def initialize(options={})
@@ -27,7 +38,8 @@ module Groonga
     def dump
       options = @options.dup
       have_output = !@options[:output].nil?
-      options[:output] ||= StringIO.new
+      options[:output] ||= Dumper.default_output
+      options[:error_output] ||= Dumper.default_output
       if options[:database].nil?
         options[:context] ||= Groonga::Context.default
         options[:database] = options[:context].database
@@ -36,9 +48,20 @@ module Groonga
       options[:dump_schema] = true if options[:dump_schema].nil?
       options[:dump_tables] = true if options[:dump_tables].nil?
 
+      if options[:dump_schema]
+        schema_dumper = SchemaDumper.new(options.merge(:syntax => :command))
+      end
       dump_plugins(options) if options[:dump_plugins]
-      dump_schema(options) if options[:dump_schema]
+      if options[:dump_schema]
+        schema_dumper.dump_tables
+        options[:output].write("\n")
+        schema_dumper.dump_reference_columns
+      end
       dump_tables(options) if options[:dump_tables]
+      if options[:dump_schema]
+        options[:output].write("\n")
+        schema_dumper.dump_index_columns
+      end
 
       if have_output
         nil
@@ -50,7 +73,7 @@ module Groonga
     private
     def dump_plugins(options)
       plugin_paths = {}
-      options[:database].each(:order_by => :id) do |object|
+      options[:database].each(each_options(:order_by => :id)) do |object|
         next unless object.is_a?(Groonga::Procedure)
         next if object.builtin?
         path = object.path
@@ -62,13 +85,9 @@ module Groonga
       options[:output].write("\n") unless plugin_paths.empty?
     end
 
-    def dump_schema(options)
-      SchemaDumper.new(options.merge(:syntax => :command)).dump
-    end
-
     def dump_tables(options)
       first_table = true
-      options[:database].each(:order_by => :key) do |object|
+      options[:database].each(each_options(:order_by => :key)) do |object|
         next unless object.is_a?(Groonga::Table)
         next if object.size.zero?
         next if target_table?(options[:exclude_tables], object, false)
@@ -99,6 +118,10 @@ module Groonga
         name === table.name
       end
     end
+
+    def each_options(options)
+      {:ignore_missing_object => true}.merge(options)
+    end
   end
 
   # スキーマの内容をRubyスクリプトまたはgrn式形式の文字列と
@@ -109,6 +132,40 @@ module Groonga
     end
 
     def dump
+      run do |syntax|
+        syntax.dump
+      end
+    end
+
+    def dump_tables
+      run do |syntax|
+        syntax.dump_tables
+      end
+    end
+
+    def dump_reference_columns
+      run do |syntax|
+        syntax.dump_reference_columns
+      end
+    end
+
+    def dump_index_columns
+      run do |syntax|
+        syntax.dump_index_columns
+      end
+    end
+
+    private
+    def create_syntax(database, output)
+      case @options[:syntax]
+      when :command
+        CommandSyntax.new(database, output)
+      else
+        RubySyntax.new(database, output)
+      end
+    end
+
+    def run
       database = @options[:database]
       if database.nil?
         context = @options[:context] || Groonga::Context.default
@@ -118,8 +175,8 @@ module Groonga
 
       output = @options[:output]
       have_output = !output.nil?
-      output ||= StringIO.new
-      result = syntax(database, output).dump
+      output ||= Dumper.default_output
+      result = yield(create_syntax(database, output))
       if have_output
         result
       else
@@ -127,24 +184,12 @@ module Groonga
       end
     end
 
-    private
-    def syntax(database, output)
-      case @options[:syntax]
-      when :command
-        CommandSyntax.new(database, output)
-      else
-        RubySyntax.new(database, output)
-      end
-    end
-
     # @private
     class BaseSyntax
       def initialize(database, output)
         @database = database
         @output = output
         @table_defined = false
-        @index_columns = []
-        @reference_columns = []
       end
 
       def dump
@@ -154,23 +199,29 @@ module Groonga
       end
 
       def dump_schema
-        @database.each(:order_by => :key) do |object|
-          create_table(object) if object.is_a?(Groonga::Table)
+        dump_tables
+        dump_reference_columns
+        dump_index_columns
+      end
+
+      def dump_tables
+        each_table do |table|
+          create_table(table)
         end
+      end
 
-        @reference_columns.group_by do |column|
-          column.table
-        end.each do |table, columns|
+      def dump_reference_columns
+        group_columns(reference_columns).each do |table, columns|
           change_table(table) do
             columns.each do |column|
               define_reference_column(table, column)
             end
           end
         end
+      end
 
-        @index_columns.group_by do |column|
-          column.table
-        end.each do |table, columns|
+      def dump_index_columns
+        group_columns(index_columns).each do |table, columns|
           change_table(table) do
             columns.each do |column|
               define_index_column(table, column)
@@ -192,23 +243,91 @@ module Groonga
         write("")
       end
 
+      def each_table
+        each_options = {:order_by => :key, :ignore_missing_object => true}
+        @database.each(each_options) do |object|
+          yield(object) if object.is_a?(Groonga::Table)
+        end
+      end
+
+      def each_column(table, &block)
+        sorted_columns = table.columns.sort_by {|column| column.local_name}
+        sorted_columns.each(&block)
+      end
+
+      def collect_columns
+        columns = []
+        each_table do |table|
+          each_column(table) do |column|
+            columns << column if yield(column)
+          end
+        end
+        columns
+      end
+
+      def reference_columns
+        @reference_columns ||= collect_columns do |column|
+          reference_column?(column)
+        end
+      end
+
+      def index_columns
+        @index_columns ||= collect_columns do |column|
+          index_column?(column)
+        end
+      end
+
+      def group_columns(columns)
+        grouped_columns = columns.group_by do |column|
+          column.table
+        end
+        sort_grouped_columns(grouped_columns)
+      end
+
+      def sort_grouped_columns(grouped_columns)
+        grouped_columns = grouped_columns.collect do |table, columns|
+          sorted_columns = columns.sort_by do |column|
+            column.local_name
+          end
+          [table, sorted_columns]
+        end
+        grouped_columns.sort_by do |table, columns|
+          _ = columns
+          table.name
+        end
+      end
+
       def table_separator
         write("\n")
       end
 
+      def column_type(column)
+        if column.is_a?(Groonga::IndexColumn)
+          :index
+        elsif column.range.is_a?(Groonga::Table)
+          :reference
+        else
+          :normal
+        end
+      end
+
+      def index_column?(column)
+        column_type(column) == :index
+      end
+
+      def reference_column?(column)
+        column_type(column) == :reference
+      end
+
+      def normal_column?(column)
+        column_type(column) == :normal
+      end
+
       def create_table(table)
         table_separator if @table_defined
         create_table_header(table)
-        table.columns.sort_by {|column| column.local_name}.each do |column|
-          if column.is_a?(Groonga::IndexColumn)
-            @index_columns << column
-          else
-            if column.range.is_a?(Groonga::Table)
-              @reference_columns << column
-            else
-              define_column(table, column)
-            end
-          end
+        each_column(table) do |column|
+          define_column(table, column) if normal_column?(column)
         end
         create_table_footer(table)
         @table_defined = true
@@ -445,7 +564,8 @@ module Groonga
       @options = options
       @output = @options[:output]
       @have_output = !@output.nil?
-      @output ||= StringIO.new
+      @output ||= Dumper.default_output
+      @error_output = @options[:error_output]
     end
 
     def dump
@@ -462,6 +582,11 @@ module Groonga
       @output.write(content)
     end
 
+    def error_write(content)
+      return if @error_output.nil?
+      @error_output.write(content)
+    end
+
     def dump_load_command
       write("load --table #{@table.name}\n")
       write("[\n")
@@ -482,17 +607,17 @@ module Groonga
       @table.each(:order_by => @options[:order_by]) do |record|
         write(",\n")
         values = columns.collect do |column|
-          resolve_value(column[record.id])
+          resolve_value(record, column, column[record.id])
         end
         write(values.to_json)
       end
     end
 
-    def resolve_value(value)
+    def resolve_value(record, column, value)
       case value
       when ::Array
         value.collect do |v|
-          resolve_value(v)
+          resolve_value(record, column, v)
         end
       when Groonga::Record
         if value.support_key?
@@ -500,7 +625,7 @@ module Groonga
         else
           value = value.id
         end
-        resolve_value(value)
+        resolve_value(record, column, value)
       when Time
         # TODO: groonga should support UTC format literal
         # value.utc.strftime("%Y-%m-%d %H:%M:%S.%6N")
@@ -510,8 +635,38 @@ module Groonga
         # doesn't accept null.
         ""
       else
-        value
+        return value unless value.respond_to?(:valid_encoding?)
+        sanitized_value = ""
+        value = fix_encoding(value)
+        value.each_char do |char|
+          if char.valid_encoding?
+            sanitized_value << char
+          else
+            table_name = record.table.name
+            record_id = record.record_id
+            column_name = column.local_name
+            error_write("warning: ignore invalid encoding character: " +
+                          "<#{table_name}[#{record_id}].#{column_name}>: " +
+                          "<#{inspect_invalid_char(char)}>: " +
+                          "before: <#{sanitized_value}>\n")
+          end
+        end
+        sanitized_value
+      end
+    end
+
+    def fix_encoding(value)
+      if value.encoding == ::Encoding::ASCII_8BIT
+        value.force_encoding(@table.context.ruby_encoding)
+      end
+      value
+    end
+
+    def inspect_invalid_char(char)
+      bytes_in_hex = char.bytes.collect do |byte|
+        "%#0x" % byte
       end
+      bytes_in_hex.join(" ")
     end
 
     def available_columns

data/lib/groonga/expression-builder.rb

@@ -24,6 +24,7 @@ module Groonga
     attr_accessor :allow_pragma
     attr_accessor :allow_column
     attr_accessor :allow_update
+    attr_accessor :allow_leading_not
     attr_accessor :default_column
 
     VALID_COLUMN_NAME_RE = /\A[a-zA-Z\d_]+\z/
@@ -36,6 +37,7 @@ module Groonga
       @allow_pragma = nil
       @allow_column = nil
       @allow_update = nil
+      @allow_leading_not = nil
       @default_column = nil
     end
 
@@ -60,6 +62,7 @@ module Groonga
         :allow_pragma => @allow_pragma,
         :allow_column => @allow_column,
         :allow_update => @allow_update,
+        :allow_leading_not => @allow_leading_not,
         :default_column => @default_column,
       }
     end
@@ -230,6 +233,16 @@ module Groonga
         SimilarSearchExpressionBuilder.new(self, normalize(other))
       end
 
+      def term_extract(other)
+        if @column_name == "_key"
+          TermExtractExpressionBuilder.new(self, normalize(other))
+        else
+          message = "term extraction supports _key column only: " +
+            "<#{@column_name}>"
+          raise ArgumentError, message
+        end
+      end
+
       private
       def normalize(other)
         if @range.is_a?(Groonga::Table)
@@ -417,6 +430,13 @@ module Groonga
         super(Groonga::Operation::SIMILAR, column_value_builder, value)
       end
     end
+
+    # @private
+    class TermExtractExpressionBuilder < BinaryExpressionBuilder
+      def initialize(column_value_builder, value)
+        super(Groonga::Operation::TERM_EXTRACT, column_value_builder, value)
+      end
+    end
   end
 
   # @private
@@ -586,6 +606,10 @@ module Groonga
       column_expression_builder.similar_search(text)
     end
 
+    def term_extract(text)
+      column_expression_builder.term_extract(text)
+    end
+
     private
     def column_expression_builder
       ColumnValueExpressionBuilder.new(@default_column,