groonga 0.0.6 → 0.0.7

data/ext/rb-grn-utils.c

@@ -94,32 +94,39 @@ rb_grn_bulk_to_ruby_object_by_range_id (grn_ctx *context, grn_obj *bulk,
 
     switch (range_id) {
       case GRN_DB_VOID:
-	*rb_value = rb_str_new(GRN_BULK_HEAD(bulk), GRN_BULK_VSIZE(bulk));
+	*rb_value = rb_str_new(GRN_TEXT_VALUE(bulk), GRN_TEXT_LEN(bulk));
 	break;
       case GRN_DB_INT32:
-	*rb_value = INT2NUM(*((int *)GRN_BULK_HEAD(bulk)));
+	*rb_value = INT2NUM(GRN_INT32_VALUE(bulk));
 	break;
       case GRN_DB_UINT32:
-	*rb_value = UINT2NUM(*((int *)GRN_BULK_HEAD(bulk)));
+	*rb_value = UINT2NUM(GRN_UINT32_VALUE(bulk));
 	break;
       case GRN_DB_INT64:
-	*rb_value = LL2NUM(*((long long *)GRN_BULK_HEAD(bulk)));
+	*rb_value = LL2NUM(GRN_INT64_VALUE(bulk));
+	break;
+      case GRN_DB_UINT64:
+	*rb_value = ULL2NUM(GRN_UINT64_VALUE(bulk));
 	break;
       case GRN_DB_FLOAT:
-	*rb_value = rb_float_new(*((double *)GRN_BULK_HEAD(bulk)));
+	*rb_value = rb_float_new(GRN_FLOAT_VALUE(bulk));
 	break;
       case GRN_DB_TIME:
 	{
-	    int64_t time_value = GRN_TIME_VALUE(bulk);
+	    int64_t time_value, sec, usec;
+
+	    time_value = GRN_TIME_VALUE(bulk);
+	    GRN_TIME_UNPACK(time_value, sec, usec);
 	    *rb_value = rb_funcall(rb_cTime, rb_intern("at"), 2,
-				   LL2NUM(time_value / RB_GRN_USEC_PER_SEC),
-				   LL2NUM(time_value % RB_GRN_USEC_PER_SEC));
+				   LL2NUM(sec), LL2NUM(usec));
 	}
 	break;
       case GRN_DB_SHORT_TEXT:
       case GRN_DB_TEXT:
       case GRN_DB_LONG_TEXT:
-	*rb_value = rb_str_new(GRN_BULK_HEAD(bulk), GRN_BULK_VSIZE(bulk));
+	*rb_value = rb_grn_context_rb_string_new(context,
+						 GRN_TEXT_VALUE(bulk),
+						 GRN_TEXT_LEN(bulk));
 	break;
       default:
 	success = RB_GRN_FALSE;
@@ -185,7 +192,9 @@ rb_grn_bulk_to_ruby_object (grn_ctx *context, grn_obj *bulk,
 						 related_object, &rb_value))
 	return rb_value;
 
-    return rb_str_new(GRN_BULK_HEAD(bulk), GRN_BULK_VSIZE(bulk));
+    return rb_grn_context_rb_string_new(context,
+					GRN_BULK_HEAD(bulk),
+					GRN_BULK_VSIZE(bulk));
 }
 
 grn_obj *
@@ -200,6 +209,11 @@ rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
     grn_id id_value;
     grn_obj_flags flags = 0;
 
+    if (bulk && bulk->header.domain == GRN_DB_TIME)
+        return rb_grn_bulk_from_ruby_object_with_type(
+            object, context, bulk, bulk->header.domain,
+            grn_ctx_at(context, bulk->header.domain));
+
     switch (TYPE(object)) {
       case T_NIL:
 	string = NULL;
@@ -217,8 +231,14 @@ rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
 	break;
       case T_BIGNUM:
 	int64_value = NUM2LL(object);
-	string = (const char *)&int64_value;
-	size = sizeof(int64_value);
+        if (int64_value <= INT32_MAX) {
+            int32_value = int64_value;
+            string = (const char *)&int32_value;
+            size = sizeof(int32_value);
+        } else {
+            string = (const char *)&int64_value;
+            size = sizeof(int64_value);
+        }
 	break;
       case T_FLOAT:
 	double_value = NUM2DBL(object);
@@ -231,7 +251,7 @@ rb_grn_bulk_from_ruby_object (VALUE object, grn_ctx *context, grn_obj *bulk)
 
 	    sec = rb_funcall(object, rb_intern("to_i"), 0);
 	    usec = rb_funcall(object, rb_intern("usec"), 0);
-	    time_value = NUM2LL(sec) * RB_GRN_USEC_PER_SEC + NUM2LL(usec);
+	    time_value = GRN_TIME_PACK(NUM2LL(sec), NUM2LL(usec));
 	    string = (const char *)&time_value;
 	    size = sizeof(time_value);
 	} else if (RVAL2CBOOL(rb_obj_is_kind_of(object, rb_cGrnObject))) {
@@ -273,10 +293,11 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
     int32_t int32_value;
     uint32_t uint32_value;
     int64_t int64_value;
+    uint64_t uint64_value;
     int64_t time_value;
     double double_value;
     grn_id range;
-    VALUE rb_type;
+    VALUE rb_type_object;
     grn_obj_flags flags = 0;
 
     switch (type_id) {
@@ -295,6 +316,11 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
 	string = (const char *)&int64_value;
 	size = sizeof(int64_value);
 	break;
+      case GRN_DB_UINT64:
+	uint64_value = NUM2ULL(object);
+	string = (const char *)&uint64_value;
+	size = sizeof(uint64_value);
+	break;
       case GRN_DB_FLOAT:
 	double_value = NUM2DBL(object);
 	string = (const char *)&double_value;
@@ -302,11 +328,31 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
 	break;
       case GRN_DB_TIME:
 	{
-	    VALUE sec, usec;
-
-	    sec = rb_funcall(object, rb_intern("to_i"), 0);
-	    usec = rb_funcall(object, rb_intern("usec"), 0);
-	    time_value = NUM2LL(sec) * RB_GRN_USEC_PER_SEC + NUM2LL(usec);
+	    VALUE rb_sec, rb_usec;
+            int64_t sec;
+            int32_t usec;
+
+            switch (TYPE(object)) {
+            case T_FIXNUM:
+            case T_BIGNUM:
+                sec = NUM2LL(object);
+                usec = 0;
+                break;
+            case T_FLOAT:
+                rb_sec = rb_funcall(object, rb_intern("to_i"), 0);
+                rb_usec = rb_funcall(object, rb_intern("remainder"), 1,
+				     INT2NUM(1));
+
+                sec = NUM2LL(rb_sec);
+                usec = (int32_t)(NUM2DBL(rb_usec) * 1000000);
+                break;
+            default:
+                sec = NUM2LL(rb_funcall(object, rb_intern("to_i"), 0));
+                usec = NUM2INT(rb_funcall(object, rb_intern("usec"), 0));
+                break;
+            }
+
+	    time_value = GRN_TIME_PACK(sec, usec);
 	}
 	string = (const char *)&time_value;
 	size = sizeof(time_value);
@@ -329,10 +375,10 @@ rb_grn_bulk_from_ruby_object_with_type (VALUE object, grn_ctx *context,
       case GRN_DB_BIGRAM:
       case GRN_DB_TRIGRAM:
       case GRN_DB_MECAB:
-	rb_type = GRNOBJECT2RVAL(Qnil, context, type, RB_GRN_FALSE);
+	rb_type_object = GRNOBJECT2RVAL(Qnil, context, type, RB_GRN_FALSE);
 	rb_raise(rb_eArgError,
 		 "unbulkable type: %s",
-		 rb_grn_inspect(rb_type));
+		 rb_grn_inspect(rb_type_object));
 	break;
       default:
 	return RVAL2GRNBULK(object, context, bulk);
@@ -479,6 +525,25 @@ rb_grn_value_to_ruby_object (grn_ctx *context,
 	    value->header.domain = grn_obj_id(context, range);
 	return GRNBULK2RVAL(context, value, related_object);
 	break;
+      case GRN_UVECTOR:
+	{
+	    VALUE rb_value, rb_range = Qnil;
+	    grn_id *uvector, *uvector_end;
+
+	    rb_value = rb_ary_new();
+	    if (range)
+		rb_range = GRNTABLE2RVAL(context, range, RB_GRN_FALSE);
+	    uvector = (grn_id *)GRN_BULK_HEAD(value);
+	    uvector_end = (grn_id *)GRN_BULK_CURR(value);
+	    for (; uvector < uvector_end; uvector++) {
+		VALUE record = Qnil;
+		if (*uvector != GRN_ID_NIL)
+		    record = rb_grn_record_new(rb_range, *uvector, Qnil);
+		rb_ary_push(rb_value, record);
+	    }
+	    return rb_value;
+	}
+	break;
       default:
 	rb_raise(rb_eGrnError,
 		 "unsupported value type: 0x%0x: %s",
@@ -616,7 +681,7 @@ rb_grn_obj_from_ruby_object (VALUE rb_object, grn_ctx *context, grn_obj **_obj)
 
 	    sec = rb_funcall(rb_object, rb_intern("to_i"), 0);
 	    usec = rb_funcall(rb_object, rb_intern("usec"), 0);
-	    time_value = NUM2LL(sec) * RB_GRN_USEC_PER_SEC + NUM2LL(usec);
+	    time_value = GRN_TIME_PACK(NUM2LL(sec), NUM2LL(usec));
 	    grn_obj_reinit(context, obj, GRN_DB_TIME, 0);
 	    GRN_TIME_SET(context, obj, time_value);
 	} else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_object, rb_cGrnObject))) {

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

@@ -23,7 +23,7 @@
 VALUE rb_cGrnVariableSizeColumn;
 
 /*
- * Document-class: Groonga::FixSizeColumn < Groonga::Column
+ * Document-class: Groonga::VariableSizeColumn < Groonga::Column
  *
  * 可変長データ用のカラム。
  */

data/ext/rb-grn.h

@@ -21,6 +21,10 @@
 
 #include <ruby.h>
 
+#ifdef HAVE_RUBY_ENCODING_H
+#  include <ruby/encoding.h>
+#endif
+
 #include <groonga.h>
 
 #if defined(__cplusplus)
@@ -65,7 +69,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 0
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 6
+#define RB_GRN_MICRO_VERSION 7
 
 typedef int rb_grn_boolean;
 #define RB_GRN_FALSE (0)
@@ -75,8 +79,6 @@ typedef int rb_grn_boolean;
 
 #include <stdint.h>
 
-#define RB_GRN_USEC_PER_SEC 1000000
-
 #define RB_GRN_OBJECT(object) ((RbGrnObject *)(object))
 #define RB_GRN_TABLE(object) ((RbGrnTable *)(object))
 #define RB_GRN_TABLE_KEY_SUPPORT(object) ((RbGrnTableKeySupport *)(object))
@@ -91,7 +93,7 @@ typedef void (*RbGrnUnbindFunction) (void *object);
 typedef struct _RbGrnContext RbGrnContext;
 struct _RbGrnContext
 {
-    grn_ctx context;
+    grn_ctx *context;
 };
 
 typedef struct _RbGrnObject RbGrnObject;
@@ -156,6 +158,8 @@ struct _RbGrnExpression
     grn_obj *value;
 };
 
+RB_GRN_VAR rb_grn_boolean rb_grn_exited;
+
 RB_GRN_VAR VALUE rb_eGrnError;
 RB_GRN_VAR VALUE rb_cGrnObject;
 RB_GRN_VAR VALUE rb_mGrnEncodingSupport;
@@ -225,6 +229,7 @@ const char    *rb_grn_rc_to_message                 (grn_rc rc);
 void           rb_grn_rc_check                      (grn_rc rc,
 						     VALUE related_object);
 
+void           rb_grn_context_fin                   (grn_ctx *context);
 grn_ctx       *rb_grn_context_ensure                (VALUE *context);
 VALUE          rb_grn_context_get_default           (void);
 VALUE          rb_grn_context_to_exception          (grn_ctx *context,
@@ -475,13 +480,26 @@ VALUE          rb_grn_column_expression_builder_build
 #define RVAL2GRNVARIABLE(object, context) \
     (rb_grn_variable_from_ruby_object(object, context))
 
+#define GRNSNIPPET2RVAL(context, snippet, owner)		\
+    (rb_grn_snippet_to_ruby_object(context, snippet, owner))
+#define RVAL2GRNSNIPPET(snippet) \
+    (rb_grn_snippet_from_ruby_object(snippet))
+
 
 grn_encoding   rb_grn_encoding_from_ruby_object     (VALUE object,
 						     grn_ctx *context);
 VALUE          rb_grn_encoding_to_ruby_object       (grn_encoding encoding);
+#ifdef HAVE_RUBY_ENCODING_H
+rb_encoding   *rb_grn_encoding_to_ruby_encoding     (grn_encoding encoding);
+#endif
 
 grn_ctx       *rb_grn_context_from_ruby_object      (VALUE object);
 VALUE          rb_grn_context_to_ruby_object        (grn_ctx *context);
+VALUE          rb_grn_context_rb_string_new         (grn_ctx *context,
+						     const char *string,
+						     long length);
+VALUE          rb_grn_context_rb_string_encode      (grn_ctx *context,
+						     VALUE rb_string);
 
 grn_obj       *rb_grn_object_from_ruby_object       (VALUE object,
 						     grn_ctx **context);
@@ -592,6 +610,11 @@ VALUE          rb_grn_obj_to_ruby_object            (VALUE klass,
 						     grn_obj *obj,
 						     VALUE related_object);
 
+grn_snip      *rb_grn_snippet_from_ruby_object      (VALUE rb_snippet);
+VALUE          rb_grn_snippet_to_ruby_object        (grn_ctx *context,
+						     grn_snip *snippet,
+						     rb_grn_boolean owner);
+
 RB_GRN_END_DECLS
 
 #endif

data/ext/rb-groonga.c

@@ -18,12 +18,22 @@
 
 #include "rb-grn.h"
 
+rb_grn_boolean rb_grn_exited = RB_GRN_FALSE;
 extern grn_ctx grn_gctx;
 
 static void
-finish_groonga (void)
+finish_groonga (VALUE data)
 {
+    grn_ctx *context = grn_gctx.next;
+
+    debug("finish\n");
+    while (context && context != &grn_gctx) {
+	rb_grn_context_fin(context);
+	context = context->next;
+    }
     grn_fin();
+    debug("finish: done\n");
+    rb_grn_exited = RB_GRN_TRUE;
 }
 
 void
@@ -68,7 +78,7 @@ Init_groonga (void)
     rb_grn_init_exception(mGrn);
 
     rb_grn_rc_check(grn_init(), Qnil);
-    atexit(finish_groonga);
+    rb_set_end_proc(finish_groonga, Qnil);
 
     rb_grn_init_utils(mGrn);
     rb_grn_init_encoding(mGrn);

data/extconf.rb

@@ -36,7 +36,7 @@ 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, 1, 1
+major, minor, micro = 0, 1, 4
 
 def local_groonga_base_dir
   File.join(File.dirname(__FILE__), "vendor")
@@ -143,6 +143,7 @@ have_header("ruby/st.h") unless have_macro("HAVE_RUBY_ST_H", "ruby.h")
 have_func("rb_errinfo", "ruby.h")
 have_type("enum ruby_value_type", "ruby.h")
 
+$INSTALLFILES ||= []
 $INSTALLFILES << ["../lib/**/*.rb", "$(RUBYLIBDIR)", "../lib"]
 
 create_makefile(module_name, src_dir)

data/html/index.html

@@ -42,7 +42,7 @@
 
 	<h3>Ruby/groongaの最新リリース</h3>
 	<p>
-	  2009-07-31にリリースされた0.0.6が最新です。
+	  2009-10-02にリリースされた0.0.7が最新です。
         </p>
 
 	<h3 id="install-ruby-groonga">Ruby/groongaのインストール</h3>
@@ -79,7 +79,7 @@
 
 	<h3>ActiveGroongaの最新リリース</h3>
 	<p>
-	  2009-07-31にリリースされた0.0.6が最新です。
+	  2009-10-02にリリースされた0.0.7が最新です。
         </p>
 
 	<h3 id="install-active-groonga">ActiveGroongaのインストール</h3>

data/lib/groonga.rb

@@ -69,4 +69,5 @@ module Groonga
   end
 end
 
+require 'groonga/patricia-trie'
 require 'groonga/schema'

data/lib/groonga/expression-builder.rb

@@ -18,6 +18,8 @@
 module Groonga
   module ExpressionBuildable
     attr_reader :table
+    attr_accessor :query
+
     def initialize(*args)
       @table = nil
       @name = nil
@@ -26,14 +28,18 @@ module Groonga
     end
 
     def build
-      expression = Expression.new(:table => @table,
-                                  :name => @name,
-                                  :query => @query,
-                                  :default_column => @default_column)
+      expression = Expression.new(:name => @name)
       variable = expression.define_variable(:domain => @table)
 
       builder = nil
-      builder = yield(self) if block_given?
+      builder = match(@query) if @query
+      if block_given?
+        if builder
+          builder &= yield(self)
+        else
+          builder = yield(self)
+        end
+      end
       if builder.nil? or builder == self
         expression.append_constant(1)
         expression.append_constant(1)
@@ -99,7 +105,7 @@ module Groonga
       def build(expression, variable)
         expression.append_object(variable)
         expression.append_constant(@column_name)
-        expression.append_operation(Groonga::Operation::OBJECT_GET_VALUE, 2)
+        expression.append_operation(Groonga::Operation::GET_VALUE, 2)
         expression.append_constant(@value)
         expression.append_operation(@operation, 2)
       end
@@ -140,6 +146,18 @@ module Groonga
         super(Groonga::Operation::GREATER_EQUAL, column_name, value)
       end
     end
+
+    class SubExpressionBuilder < ExpressionBuilder
+      def initialize(query, options)
+        super()
+        @query = query
+        @options = options
+      end
+
+      def build(expression, variable)
+        expression.parse(@query, @options)
+      end
+    end
   end
 
   class RecordExpressionBuilder
@@ -160,6 +178,16 @@ module Groonga
       end
       ColumnExpressionBuilder.new(column, nil, nil)
     end
+
+    def match(query, options_or_default_column={})
+      if options_or_default_column.is_a?(String)
+        options = {:default_column => options_or_default_column}
+      else
+        options = options_or_default_column
+      end
+      default_options = {:parser => :table}
+      SubExpressionBuilder.new(query, default_options.merge(options))
+    end
   end
 
   class ColumnExpressionBuilder
@@ -176,27 +204,34 @@ module Groonga
     end
 
     def ==(other)
-      EqualExpressionBuilder.new(@column.local_name, normalize(other))
+      EqualExpressionBuilder.new(@default_column, normalize(other))
     end
 
     def =~(other)
-      MatchExpressionBuilder.new(@column.local_name, normalize(other))
+      MatchExpressionBuilder.new(@default_column, normalize(other))
     end
 
     def <(other)
-      LessExpressionBuilder.new(@column.local_name, normalize(other))
+      LessExpressionBuilder.new(@default_column, normalize(other))
     end
 
     def <=(other)
-      LessEqualExpressionBuilder.new(@column.local_name, normalize(other))
+      LessEqualExpressionBuilder.new(@default_column, normalize(other))
     end
 
     def >(other)
-      GreaterExpressionBuilder.new(@column.local_name, normalize(other))
+      GreaterExpressionBuilder.new(@default_column, normalize(other))
     end
 
     def >=(other)
-      GreaterEqualExpressionBuilder.new(@column.local_name, normalize(other))
+      GreaterEqualExpressionBuilder.new(@default_column, normalize(other))
+    end
+
+    def match(query, options={})
+      default_options = {:parser => :table}
+      ensure_options = {:default_column => @default_column}
+      options = default_options.merge(options).merge(ensure_options)
+      SubExpressionBuilder.new(query, options)
     end
 
     private