groonga 0.0.2 → 0.0.3

data/ext/rb-groonga.c

@@ -84,6 +84,10 @@ Init_groonga (void)
     rb_grn_init_accessor(mGrn);
     rb_grn_init_record(mGrn);
     rb_grn_init_query(mGrn);
+    rb_grn_init_variable(mGrn);
+    rb_grn_init_operation(mGrn);
+    rb_grn_init_expression(mGrn);
+    rb_grn_init_expression_builder(mGrn);
     rb_grn_init_logger(mGrn);
     rb_grn_init_snippet(mGrn);
 }

data/extconf.rb

@@ -21,6 +21,7 @@ require 'English'
 require 'mkmf'
 require 'pkg-config'
 require 'fileutils'
+require 'shellwords'
 
 checking_for(checking_message("GCC")) do
   if macro_defined?("__GNUC__", "")
@@ -35,18 +36,45 @@ package_name = "groonga"
 module_name = "groonga"
 ext_dir_name = "ext"
 src_dir = File.join(File.expand_path(File.dirname(__FILE__)), ext_dir_name)
-major, minor, micro = 0, 0, 8
+major, minor, micro = 0, 1, 0
+
+def local_groonga_base_dir
+  File.join(File.dirname(__FILE__), "vendor")
+end
+
+def local_groonga_install_dir
+  File.expand_path(File.join(local_groonga_base_dir, "local"))
+end
+
+def have_local_groonga?(package_name, major, minor, micro)
+  return false unless File.exist?(File.join(local_groonga_install_dir, "lib"))
+
+  prepend_pkg_config_path_for_local_groonga
+  PKGConfig.have_package(package_name, major, minor, micro)
+end
+
+def prepend_pkg_config_path_for_local_groonga
+  pkg_config_dir = File.join(local_groonga_install_dir, "lib", "pkgconfig")
+  PackageConfig.prepend_default_path(pkg_config_dir)
+
+  lib_dir = File.join(local_groonga_install_dir, "lib")
+  original_LDFLAGS = $LDFLAGS
+  checking_for(checking_message("-Wl,-rpath is available")) do
+    $LDFLAGS += " -Wl,-rpath,#{Shellwords.escape(lib_dir)}"
+    available = try_compile("int main() {return 0;}")
+    $LDFLAGS = original_LDFLAGS unless available
+    available
+  end
+end
 
 def install_groonga_locally(major, minor, micro)
   require 'open-uri'
   require 'shellwords'
 
   tar_gz = "groonga-#{major}.#{minor}.#{micro}.tar.gz"
-  base_dir = File.join(File.dirname(__FILE__), "vendor")
-  install_dir = File.expand_path(File.join(base_dir, "local"))
-  FileUtils.mkdir_p(base_dir)
+  FileUtils.mkdir_p(local_groonga_base_dir)
 
-  Dir.chdir(base_dir) do
+  Dir.chdir(local_groonga_base_dir) do
     url = "http://groonga.org/files/groonga/#{tar_gz}"
     message("downloading %s...", url)
     open(url, "rb") do |input|
@@ -69,7 +97,7 @@ def install_groonga_locally(major, minor, micro)
     groonga_source_dir = "groonga-#{major}.#{minor}.#{micro}"
     Dir.chdir(groonga_source_dir) do
       message("configuring...")
-      if xsystem("./configure --prefix=#{Shellwords.escape(install_dir)}")
+      if xsystem("./configure CFLAGS='-g -O0' --prefix=#{Shellwords.escape(install_dir)}")
         message(" done\n")
       else
         message(" failed\n")
@@ -94,16 +122,14 @@ def install_groonga_locally(major, minor, micro)
     end
   end
 
-  pkg_config_dir = File.join(install_dir, "lib", "pkgconfig")
-  PackageConfig.prepend_default_path(pkg_config_dir)
-
-  lib_dir = File.join(install_dir, "lib")
-  $LDFLAGS += " -Wl,-rpath,#{Shellwords.escape(lib_dir)}"
+  prepend_pkg_config_path_for_local_groonga
 end
 
 unless PKGConfig.have_package(package_name, major, minor, micro)
-  install_groonga_locally(major, minor, micro)
-  PKGConfig.have_package(package_name, major, minor, micro) or exit 1
+  unless have_local_groonga?(package_name, major, minor, micro)
+    install_groonga_locally(major, minor, micro)
+    PKGConfig.have_package(package_name, major, minor, micro) or exit 1
+  end
 end
 
 real_version = PKGConfig.modversion(package_name)

data/html/index.html

@@ -42,7 +42,7 @@
 
 	<h3>Ruby/groongaの最新リリース</h3>
 	<p>
-	  2009-04-30にリリースされた0.0.1が最新です。
+	  2009-06-04にリリースされた0.0.2が最新です。
         </p>
 
 	<h3 id="install-ruby-groonga">Ruby/groongaのインストール</h3>
@@ -79,7 +79,7 @@
 
 	<h3>ActiveGroongaの最新リリース</h3>
 	<p>
-	  2009-04-30にリリースされた0.0.1が最新です。
+	  2009-06-05にリリースされた0.0.2が最新です。
         </p>
 
 	<h3 id="install-active-groonga">ActiveGroongaのインストール</h3>

data/lib/groonga.rb

@@ -15,7 +15,27 @@
 # 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 'pathname'
+
+base_dir = Pathname.new(__FILE__).dirname.dirname
+local_groonga_library_dir = base_dir + "vendor" + "local" + "lib"
+if local_groonga_library_dir.exist?
+  prepend_path = Proc.new do |environment_name, separator|
+    paths = (ENV[environment_name] || '').split(/#{separator}/)
+    unless paths.include?(local_groonga_library_dir.to_s)
+      paths = [local_groonga_library_dir.to_s] + paths
+      ENV[environment_name] = paths.join(separator)
+    end
+  end
+
+  case RUBY_PLATFORM
+  when /mingw|mswin/
+    prepend_path.call("PATH", ";")
+  end
+end
+
 require 'groonga/record'
+require 'groonga/expression-builder'
 require 'groonga.so'
 
 ##
@@ -48,3 +68,5 @@ module Groonga
     end
   end
 end
+
+require 'groonga/schema'

data/lib/groonga/expression-builder.rb

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009  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 ExpressionBuildable
+    attr_accessor :builder, :expression, :variable
+    def initialize(*args)
+      @builder = self
+      @expression = nil
+      @variable = nil
+      @table = nil
+      @name = nil
+      @query = nil
+      @default_column = nil
+    end
+
+    def build
+      @expression = Expression.new(:table => @table,
+                                   :name => @name,
+                                   :query => @query,
+                                   :default_column => @default_column)
+      if block_given?
+        @variable = @expression.define_variable(:domain => @table)
+        @expression.append_object(@variable)
+        yield(self)
+        @expression.compile
+      end
+      @expression
+    end
+  end
+
+  class RecordExpressionBuilder
+    include ExpressionBuildable
+
+    def initialize(table, name)
+      super
+      @table = table
+      @name = name
+    end
+
+    def [](name)
+      column = @table.column(name)
+      if column.nil?
+        message = "unknown column <#{name.inspect}> " +
+          "for table <#{@table.inspect}>"
+        raise ArgumentError, message
+      end
+      builder = ColumnExpressionBuilder.new(column, nil, nil)
+      builder.builder = @builder
+      builder.expression = @expression
+      builder.variable = @variable
+      builder
+    end
+
+    def &(other)
+      @expression.append_operation(Groonga::Operation::AND, 2)
+      @builder
+    end
+  end
+
+  class ColumnExpressionBuilder
+    include ExpressionBuildable
+
+    def initialize(column, name, query)
+      super
+      @table = column.table
+      @column = column
+      @default_column = column.local_name
+      @name = name
+      @query = query
+    end
+
+    def ==(other)
+      @expression.append_object(@variable)
+      @expression.append_constant(@column.local_name)
+      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+      @expression.append_constant(other)
+      @expression.append_operation(Groonga::Operation::EQUAL, 2)
+      @builder
+    end
+
+    def =~(other)
+      @expression.append_object(@variable)
+      @expression.append_constant(@column.local_name)
+      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+      @expression.append_constant(other)
+      @expression.append_operation(Groonga::Operation::MATCH, 2)
+      @builder
+    end
+
+    def <(other)
+      @expression.append_object(@variable)
+      @expression.append_constant(@column.local_name)
+      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+      @expression.append_constant(other)
+      @expression.append_operation(Groonga::Operation::LESS, 2)
+      @builder
+    end
+
+    def <=(other)
+      @expression.append_object(@variable)
+      @expression.append_constant(@column.local_name)
+      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+      @expression.append_constant(other)
+      @expression.append_operation(Groonga::Operation::LESS_EQUAL, 2)
+      @builder
+    end
+
+    def >(other)
+      @expression.append_object(@variable)
+      @expression.append_constant(@column.local_name)
+      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+      @expression.append_constant(other)
+      @expression.append_operation(Groonga::Operation::GREATER, 2)
+      @builder
+    end
+
+    def >=(other)
+      @expression.append_object(@variable)
+      @expression.append_constant(@column.local_name)
+      @expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+      @expression.append_constant(other)
+      @expression.append_operation(Groonga::Operation::GREATER_EQUAL, 2)
+      @builder
+    end
+  end
+end

data/lib/groonga/record.rb

@@ -34,7 +34,7 @@ module Groonga
     end
 
     def [](column_name)
-      (column(column_name) || {})[@id]
+      column(column_name, true)[@id]
     end
 
     def []=(column_name, value)
@@ -73,6 +73,14 @@ module Groonga
       @table[@id] = value
     end
 
+    def increment!(name, delta=nil)
+      column(name, true).increment!(@id, delta)
+    end
+
+    def decrement!(name, delta=nil)
+      column(name, true).decrement!(@id, delta)
+    end
+
     def columns
       @table.columns
     end
@@ -91,6 +99,22 @@ module Groonga
       @table.delete(@id)
     end
 
+    def lock(options={}, &block)
+      @table.lock(options.merge(:id => @id), &block)
+    end
+
+    def unlock(options={})
+      @table.unlock(options.merge(:id => @id))
+    end
+
+    def clear_lock(options={})
+      @table.clear_lock(options.merge(:id => @id))
+    end
+
+    def locked?(options={})
+      @table.locked?(options.merge(:id => @id))
+    end
+
     private
     def column(name, required=false)
       _column = @table.column(name.to_s)

data/lib/groonga/schema.rb

@@ -0,0 +1,418 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009  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
+
+  # groongaのスキーマ（データ構造）を管理するクラス。
+  class Schema
+    class << self
+
+      # call-seq:
+      #   Groonga::Schema.define(options={}) {|schema| ...}
+      #
+      # スキーマを定義する。ブロックにはGroonga::Schemaオブ
+      # ジェクトがわたるので、そのオブジェクトを利用してスキー
+      # マを定義する。
+      #
+      # _options_に指定可能な値は以下の通り。
+      #
+      # [+:context+]
+      #   スキーマ定義時に使用するGroonga::Contextを指定する。
+      #   省略した場合はGroonga::Context.defaultを使用する。
+      def define(options={})
+        schema = new(options)
+        yield(schema)
+        schema.define
+      end
+
+      # call-seq:
+      #   Groonga::Schema.create_table(name, options={}) {|table| ...}
+      #
+      # 名前が_name_のテーブルを作成する。以下の省略形。
+      #
+      #   Groonga::Schema.define do |schema|
+      #     schema.create_table(name, options) do |table|
+      #       ...
+      #     end
+      #   end
+      #
+      # ブロックにはGroonga::Schema::TableDefinitionオブジェ
+      # クトがわたるので、そのオブジェクトを利用してテーブル
+      # の詳細を定義する。
+      #
+      # _options_に指定可能な値は以下の通り。
+      #
+      # [+:context+]
+      #   スキーマ定義時に使用するGroonga::Contextを指定する。
+      #   省略した場合はGroonga::Context.defaultを使用する。
+      #
+      # [+:path+]
+      #   テーブルを保存するパスを指定する。パスを指定すると
+      #   永続テーブルになる。
+      #
+      # [+:persistent+]
+      #   テーブルを永続テーブルとする。+:path:+を省略した場
+      #   合はパス名は自動的に作成される。デフォルトでは永続
+      #   テーブルとなる。
+      #
+      # [+:value_size+]
+      #   値のサイズを指定する。デフォルトは0。
+      def create_table(name, options={}, &block)
+        define do |schema|
+          schema.create_table(name, options, &block)
+        end
+      end
+
+      # スキーマの内容を文字列で返す。返された値は
+      # Groonga::Schema#restoreすることによりスキーマ内に組
+      # み込むことができる。
+      #
+      #   dump.rb:
+      #     File.open("/tmp/groonga-schema.rb", "w") do |schema|
+      #       dumped_text = Groonga::Schema.dump
+      #     end
+      #
+      #   restore.rb:
+      #     dumped_text = Groonga::Schema.dump
+      #     Groonga::Database.create(:path => "/tmp/new-db.grn")
+      #     Groonga::Schema.define do |schema|
+      #       schema.restore(dumped_text)
+      #     end
+      #
+      # _options_に指定可能な値は以下の通り。
+      #
+      # [+:context+]
+      #   スキーマ定義時に使用するGroonga::Contextを指定する。
+      #   省略した場合はGroonga::Context.defaultを使用する。
+      def dump(options={})
+        Dumper.new(options).dump
+      end
+
+      def normalize_type(type) # :nodoc:
+        return type if type.nil?
+        return type if type.is_a?(Groonga::Object)
+        case type.to_s
+        when "string"
+          "ShortText"
+        when "text"
+          "Text"
+        when "int", "integer"
+          "Int32"
+        when "float"
+          "Float"
+        when "decimal"
+          "Int64"
+        when "datetime", "timestamp", "time", "date"
+          "Time"
+        when "binary"
+          "LongText"
+        when "boolean"
+          "Bool"
+        else
+          type
+        end
+      end
+    end
+
+    # スキーマ定義を開始する。
+    #
+    # _options_に指定可能な値は以下の通り。
+    #
+    # [+:context+]
+    #   スキーマ定義時に使用するGroonga::Contextを指定する。
+    #   省略した場合はGroonga::Context.defaultを使用する。
+    def initialize(options={})
+      @options = (options || {}).dup
+      @definitions = []
+    end
+
+    # 定義されたスキーマ定義を実際に実行する。
+    def define
+      @definitions.each do |definition|
+        definition.define
+      end
+    end
+
+    # Groonga::Schema.dumpで返されたスキーマの内容を読み込む。
+    #
+    # 読み込まれた内容は#defineを呼び出すまでは実行されない
+    # ことに注意すること。
+    def restore(dumped_text)
+      instance_eval(dumped_text)
+    end
+
+    # 名前が_name_のテーブルを作成する。
+    #
+    # 作成したテーブルは#defineを呼び出すまでは実行されない
+    # ことに注意すること。
+    #
+    # _options_に指定可能な値は以下の通り。
+    #
+    # [+:context+]
+    #   スキーマ定義時に使用するGroonga::Contextを指定する。
+    #   省略した場合はGroonga::Schema.newで指定した
+    #   Groonga::Contextを使用する。Groonga::Schema.newで指
+    #   定していない場合はGroonga::Context.defaultを使用する。
+    #
+    # [+:path+]
+    #   テーブルを保存するパスを指定する。パスを指定すると
+    #   永続テーブルになる。
+    #
+    # [+:persistent+]
+    #   テーブルを永続テーブルとする。+:path:+を省略した場
+    #   合はパス名は自動的に作成される。デフォルトでは永続
+    #   テーブルとなる。
+    #
+    # [+:value_size+]
+    #   値のサイズを指定する。デフォルトは0。
+    def create_table(name, options={})
+      definition = TableDefinition.new(name, @options.merge(options || {}))
+      yield(definition)
+      @definitions << definition
+    end
+
+    class TableDefinition
+      def initialize(name, options)
+        @name = name
+        @name = @name.to_s if @name.is_a?(Symbol)
+        @columns = []
+        @options = options
+        @table_type = table_type
+      end
+
+      def define
+        table = @table_type.create(create_options)
+        @columns.each do |column|
+          column.define(table)
+        end
+        table
+      end
+
+      def column(name, type, options={})
+        column = self[name] || ColumnDefinition.new(name, options)
+        column.type = type
+        column.options.merge!(options)
+        @columns << column unless @columns.include?(column)
+        self
+      end
+
+      def integer32(name, options={})
+        column(name, "Int32", options)
+      end
+      alias_method :integer, :integer32
+      alias_method :int32, :integer32
+
+      def integer64(name, options={})
+        column(name, "Int64", options)
+      end
+      alias_method :int64, :integer64
+
+      def unsigned_integer32(name, options={})
+        column(name, "UInt32", options)
+      end
+      alias_method :unsigned_integer, :unsigned_integer32
+      alias_method :uint32, :unsigned_integer32
+
+      def unsigned_integer64(name, options={})
+        column(name, "UInt64", options)
+      end
+      alias_method :uint64, :unsigned_integer64
+
+      def float(name, options={})
+        column(name, "Float", options)
+      end
+
+      def time(name, options={})
+        column(name, "Time", options)
+      end
+
+      def short_text(name, options={})
+        column(name, "ShortText", options)
+      end
+      alias_method :string, :short_text
+
+      def text(name, options={})
+        column(name, "Text", options)
+      end
+
+      def long_text(name, options={})
+        column(name, "LongText", options)
+      end
+
+      def index(name, target_column, options={})
+        column = self[name] || IndexColumnDefinition.new(name, options)
+        column.target = target_column
+        column.options.merge!(options)
+        @columns << column unless @columns.include?(column)
+        self
+      end
+
+      def [](name)
+        @columns.find {|column| column.name == name}
+      end
+
+      private
+      def table_type
+        type = @options[:type]
+        case type
+        when :array, nil
+          Groonga::Array
+        when :hash
+          Groonga::Hash
+        when :patricia_trie
+          Groonga::PatriciaTrie
+        else
+          raise ArgumentError, "unknown table type: #{type.inspect}"
+        end
+      end
+
+      def create_options
+        common = {
+          :name => @name,
+          :path => @options[:path],
+          :persistent => persistent?,
+          :value_size => @options[:value_size],
+          :context => context,
+        }
+        key_support_table_common = {
+          :key_type => Schema.normalize_type(@options[:key_type]),
+          :default_tokenizer => @options[:default_tokenizer],
+        }
+
+        if @table_type == Groonga::Array
+          common
+        elsif @table_type == Groonga::Hash
+          common.merge(key_support_table_common)
+        elsif @table_type == Groonga::PatriciaTrie
+          options = {
+            :key_normalize => @options[:key_normalize],
+            :key_with_sis => @options[:key_with_sis],
+          }
+          common.merge(key_support_table_common).merge(options)
+        else
+          raise ArgumentError, "unknown table type: #{@table_type.inspect}"
+        end
+      end
+
+      def persistent?
+        @options[:persistent].nil? ? true : @options[:persistent]
+      end
+
+      def context
+        @options[:context] || Groonga::Context.default
+      end
+    end
+
+    class ColumnDefinition
+      attr_accessor :name, :type
+      attr_reader :options
+
+      def initialize(name, options={})
+        @name = name
+        @name = @name.to_s if @name.is_a?(Symbol)
+        @options = (options || {}).dup
+        @type = nil
+      end
+
+      def define(table)
+        table.define_column(@name,
+                            Schema.normalize_type(@type),
+                            @options)
+      end
+    end
+
+    class IndexColumnDefinition
+      attr_accessor :name, :target
+      attr_reader :options
+
+      def initialize(name, options={})
+        @name = name
+        @name = @name.to_s if @name.is_a?(Symbol)
+        @options = (options || {}).dup
+        @target = nil
+      end
+
+      def define(table)
+        target = @target
+        target = context[target] unless target.is_a?(Groonga::Object)
+        index = table.define_index_column(@name,
+                                          target.table,
+                                          @options)
+        index.source = target
+        index
+      end
+
+      private
+      def context
+        @options[:context] || Groonga::Context.default
+      end
+    end
+
+    class Dumper
+      def initialize(options={})
+        @options = (options || {}).dup
+      end
+
+      def dump
+        context = @options[:context] || Groonga::Context.default
+        database = context.database
+        return nil if database.nil?
+
+        schema = ""
+        database.each do |object|
+          next unless object.is_a?(Groonga::Table)
+          next if object.name == "<ranguba:objects>"
+          schema << "create_table(#{object.name.inspect}) do |table|\n"
+          object.columns.each do |column|
+            type = column_method(column)
+            name = column.local_name
+            schema << "  table.#{type}(#{name.inspect})\n"
+          end
+          schema << "end\n"
+        end
+        schema
+      end
+
+      private
+      def column_method(column)
+        case column.range.name
+        when "Int32"
+          "integer32"
+        when "Int64"
+          "integer64"
+        when "UInt32"
+          "unsigned_integer32"
+        when "UInt64"
+          "unsigned_integer64"
+        when "Float"
+          "float"
+        when "Time"
+          "time"
+        when "ShortText"
+          "short_text"
+        when "Text"
+          "text"
+        when "LongText"
+          "long_text"
+        else
+          raise ArgumentError, "unsupported column: #{column.inspect}"
+        end
+      end
+    end
+  end
+end