groonga 0.0.2 → 0.0.3

data/ext/rb-grn-operation.c

@@ -0,0 +1,92 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  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
+*/
+
+#include "rb-grn.h"
+
+VALUE rb_mGrnOperation;
+
+void
+rb_grn_init_operation (VALUE mGrn)
+{
+    rb_mGrnOperation = rb_define_module_under(mGrn, "Operation");
+
+    rb_define_const(rb_mGrnOperation, "NO_OPERATION",
+                    UINT2NUM(GRN_OP_NOP));
+    rb_define_const(rb_mGrnOperation, "PUSH",
+                    UINT2NUM(GRN_OP_PUSH));
+    rb_define_const(rb_mGrnOperation, "POP",
+                    UINT2NUM(GRN_OP_POP));
+    rb_define_const(rb_mGrnOperation, "CALL",
+                    UINT2NUM(GRN_OP_CALL));
+    rb_define_const(rb_mGrnOperation, "INTERN",
+                    UINT2NUM(GRN_OP_INTERN));
+    rb_define_const(rb_mGrnOperation, "TABLE_CREATE",
+                    UINT2NUM(GRN_OP_TABLE_CREATE));
+    rb_define_const(rb_mGrnOperation, "EXPRESSION_GET_VARIABLE",
+                    UINT2NUM(GRN_OP_EXPR_GET_VAR));
+    rb_define_const(rb_mGrnOperation, "VARIABLE_SET_VALUE",
+                    UINT2NUM(GRN_OP_VAR_SET_VALUE));
+    rb_define_const(rb_mGrnOperation, "OBJECT_GET_VALUE",
+                    UINT2NUM(GRN_OP_OBJ_GET_VALUE));
+    rb_define_const(rb_mGrnOperation, "OBJECT_SET_VALUE",
+                    UINT2NUM(GRN_OP_OBJ_SET_VALUE));
+    rb_define_const(rb_mGrnOperation, "OBJECT_SEARCH",
+                    UINT2NUM(GRN_OP_OBJ_SEARCH));
+    rb_define_const(rb_mGrnOperation, "TABLE_SELECT",
+                    UINT2NUM(GRN_OP_TABLE_SELECT));
+    rb_define_const(rb_mGrnOperation, "TABLE_SORT",
+                    UINT2NUM(GRN_OP_TABLE_SORT));
+    rb_define_const(rb_mGrnOperation, "TABLE_GROUP",
+                    UINT2NUM(GRN_OP_TABLE_GROUP));
+    rb_define_const(rb_mGrnOperation, "JSON_PUT",
+                    UINT2NUM(GRN_OP_JSON_PUT));
+    rb_define_const(rb_mGrnOperation, "AND",
+                    UINT2NUM(GRN_OP_AND));
+    rb_define_const(rb_mGrnOperation, "OR",
+                    UINT2NUM(GRN_OP_OR));
+    rb_define_const(rb_mGrnOperation, "EQUAL",
+                    UINT2NUM(GRN_OP_EQUAL));
+    rb_define_const(rb_mGrnOperation, "NOT_EQUAL",
+                    UINT2NUM(GRN_OP_NOT_EQUAL));
+    rb_define_const(rb_mGrnOperation, "LESS",
+                    UINT2NUM(GRN_OP_LESS));
+    rb_define_const(rb_mGrnOperation, "GREATER",
+                    UINT2NUM(GRN_OP_GREATER));
+    rb_define_const(rb_mGrnOperation, "LESS_EQUAL",
+                    UINT2NUM(GRN_OP_LESS_EQUAL));
+    rb_define_const(rb_mGrnOperation, "GREATER_EQUAL",
+                    UINT2NUM(GRN_OP_GREATER_EQUAL));
+    rb_define_const(rb_mGrnOperation, "MATCH",
+                    UINT2NUM(GRN_OP_MATCH));
+/*
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE1",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE1));
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE2",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE2));
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE3",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE3));
+    rb_define_const(rb_mGrnOperation, "GEO_DISTANCE4",
+                    UINT2NUM(GRN_OP_GEO_DISTANCE4));
+    rb_define_const(rb_mGrnOperation, "GEO_WITHINP5",
+                    UINT2NUM(GRN_OP_GEO_WITHINP5));
+    rb_define_const(rb_mGrnOperation, "GEO_WITHINP6",
+                    UINT2NUM(GRN_OP_GEO_WITHINP6));
+    rb_define_const(rb_mGrnOperation, "GEO_WITHINP8",
+                    UINT2NUM(GRN_OP_GEO_WITHINP8));
+*/
+}

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

@@ -33,7 +33,7 @@ rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
     VALUE rb_table;
     VALUE options, rb_context, rb_name, rb_path, rb_persistent;
     VALUE rb_key_normalize, rb_key_with_sis, rb_key_type, rb_value_size;
-    VALUE rb_default_tokenizer;
+    VALUE rb_default_tokenizer, rb_sub_records;
 
     rb_scan_args(argc, argv, "01", &options);
 
@@ -47,6 +47,7 @@ rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
 			"key_type", &rb_key_type,
 			"value_size", &rb_value_size,
 			"default_tokenizer", &rb_default_tokenizer,
+			"sub_records", &rb_sub_records,
 			NULL);
 
     context = rb_grn_context_ensure(&rb_context);
@@ -54,6 +55,7 @@ rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
     if (!NIL_P(rb_name)) {
         name = StringValuePtr(rb_name);
 	name_size = RSTRING_LEN(rb_name);
+	flags |= GRN_OBJ_PERSISTENT;
     }
 
     if (!NIL_P(rb_path)) {
@@ -79,13 +81,15 @@ rb_grn_patricia_trie_s_create (int argc, VALUE *argv, VALUE self)
     if (!NIL_P(rb_value_size))
 	value_size = NUM2UINT(rb_value_size);
 
+    if (RVAL2CBOOL(rb_sub_records))
+	flags |= GRN_OBJ_WITH_SUBREC;
+
     table = grn_table_create(context, name, name_size, path,
 			     flags, key_type, value_size);
     if (!table)
 	rb_grn_context_check(context, rb_ary_new4(argc, argv));
-    rb_table = rb_grn_table_key_support_alloc(self);
-    rb_grn_table_key_support_assign(rb_table, rb_context, context, table,
-				    RB_GRN_TRUE);
+    rb_table = rb_grn_object_alloc(self);
+    rb_grn_object_assign(Qnil, rb_table, rb_context, context, table);
     rb_grn_context_check(context, rb_table);
 
     if (!NIL_P(rb_default_tokenizer))
@@ -106,7 +110,7 @@ rb_grn_patricia_trie_search (int argc, VALUE *argv, VALUE self)
     grn_obj *table;
     grn_id domain_id;
     grn_obj *key, *domain, *result;
-    grn_sel_operator operator;
+    grn_operator operator;
     grn_search_optarg search_options;
     rb_grn_boolean search_options_is_set = RB_GRN_TRUE;
     VALUE rb_key, options, rb_result, rb_operator, rb_type;
@@ -135,32 +139,7 @@ rb_grn_patricia_trie_search (int argc, VALUE *argv, VALUE self)
 	result = RVAL2GRNOBJECT(rb_result, &context);
     }
 
-    operator = RVAL2GRNSELECTOPERATOR(rb_operator);
-
-    search_options.flags = 0;
-    if (NIL_P(rb_type)) {
-	search_options_is_set = RB_GRN_FALSE;
-    } else if (rb_grn_equal_option(rb_type, "exact")) {
-	search_options.flags |= GRN_SEARCH_EXACT;
-    } else if (rb_grn_equal_option(rb_type, "longest_common_prefix") ||
-	       rb_grn_equal_option(rb_type, "longest-common-prefix")) {
-	search_options.flags |= GRN_SEARCH_LCP;
-    } else if (rb_grn_equal_option(rb_type, "suffix")) {
-	search_options.flags |= GRN_SEARCH_SUFFIX;
-    } else if (rb_grn_equal_option(rb_type, "prefix")) {
-	search_options.flags |= GRN_SEARCH_PREFIX;
-    } else if (rb_grn_equal_option(rb_type, "term_extract") ||
-	       rb_grn_equal_option(rb_type, "term-extract")) {
-	search_options.flags |= GRN_SEARCH_TERM_EXTRACT;
-    } else if (rb_grn_equal_option(rb_type, "suffix")) {
-	search_options.flags |= GRN_SEARCH_SUFFIX;
-    } else {
-	rb_raise(rb_eArgError,
-		 "search type should be one of "
-		 "[nil, :exact, :longest_common_prefix, :suffix, "
-		 ":prefix, :term_extract]: %s",
-		 rb_grn_inspect(rb_type));
-    }
+    operator = RVAL2GRNOPERATOR(rb_operator);
 
     rc = grn_obj_search(context, table, key,
 			result, operator,
@@ -175,7 +154,6 @@ rb_grn_init_patricia_trie (VALUE mGrn)
 {
     rb_cGrnPatriciaTrie =
 	rb_define_class_under(mGrn, "PatriciaTrie", rb_cGrnTable);
-    rb_define_alloc_func(rb_cGrnPatriciaTrie, rb_grn_table_key_support_alloc);
 
     rb_include_module(rb_cGrnPatriciaTrie, rb_mGrnTableKeySupport);
     rb_define_singleton_method(rb_cGrnPatriciaTrie, "create",

data/ext/rb-grn-query.c

@@ -89,26 +89,26 @@ rb_grn_query_alloc (VALUE klass)
     return Data_Wrap_Struct(klass, NULL, rb_rb_grn_query_free, NULL);
 }
 
-grn_sel_operator
-rb_grn_select_operator_from_ruby_object (VALUE rb_operator)
+grn_operator
+rb_grn_operator_from_ruby_object (VALUE rb_operator)
 {
-    grn_sel_operator operator = GRN_SEL_OR;
+    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_SEL_OR;
+        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_SEL_AND;
+        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_SEL_BUT;
+        operator = GRN_OP_BUT;
     } else if (rb_grn_equal_option(rb_operator, "adjust") ||
                rb_grn_equal_option(rb_operator, ">")) {
-        operator = GRN_SEL_ADJUST;
+        operator = GRN_OP_ADJUST;
     } else {
         rb_raise(rb_eArgError,
                  "operator should be one of "
@@ -127,7 +127,7 @@ rb_grn_query_initialize (int argc, VALUE *argv, VALUE self)
     grn_query *query;
     char *query_string;
     unsigned int query_string_length;
-    grn_sel_operator default_operator;
+    grn_operator default_operator;
     int max_expressions = RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS;
     VALUE rb_query_string, options, rb_context, rb_default_operator;
     VALUE rb_max_expressions;
@@ -145,7 +145,7 @@ rb_grn_query_initialize (int argc, VALUE *argv, VALUE self)
 
     context = rb_grn_context_ensure(&rb_context);
 
-    default_operator = RVAL2GRNSELECTOPERATOR(rb_default_operator);
+    default_operator = RVAL2GRNOPERATOR(rb_default_operator);
 
     if (!NIL_P(rb_max_expressions))
         max_expressions = NUM2INT(rb_max_expressions);

data/ext/rb-grn-table-cursor.c

@@ -32,91 +32,14 @@ rb_grn_table_cursor_from_ruby_object (VALUE object, grn_ctx **context)
     return RVAL2GRNOBJECT(object, context);
 }
 
-VALUE
-rb_grn_table_cursor_to_ruby_class (grn_obj *object)
-{
-    VALUE klass = Qnil;
-
-    switch (object->header.type) {
-      case GRN_CURSOR_TABLE_HASH_KEY:
-	klass = rb_cGrnHashCursor;
-	break;
-      case GRN_CURSOR_TABLE_PAT_KEY:
-	klass = rb_cGrnPatriciaTrieCursor;
-	break;
-      case GRN_CURSOR_TABLE_NO_KEY:
-	klass = rb_cGrnArrayCursor;
-	break;
-      default:
-	rb_raise(rb_eTypeError,
-		 "unsupported groonga object type: %d",
-		 object->header.type);
-	break;
-    }
-
-    return klass;
-}
-
 VALUE
 rb_grn_table_cursor_to_ruby_object (VALUE klass, grn_ctx *context,
 				    grn_table_cursor *cursor,
 				    rb_grn_boolean owner)
 {
-    if (NIL_P(klass))
-	klass = rb_grn_table_cursor_to_ruby_class(cursor);
     return GRNOBJECT2RVAL(klass, context, cursor, owner);
 }
 
-void
-rb_grn_table_cursor_unbind (RbGrnTableCursor *rb_grn_table_cursor)
-{
-    RbGrnObject *rb_grn_object;
-
-    rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
-    rb_grn_object_unbind(rb_grn_object);
-}
-
-static void
-rb_grn_table_cursor_free (void *object)
-{
-    RbGrnTableCursor *rb_grn_table_cursor = object;
-
-    rb_grn_table_cursor_unbind(rb_grn_table_cursor);
-    xfree(rb_grn_table_cursor);
-}
-
-VALUE
-rb_grn_table_cursor_alloc (VALUE klass)
-{
-    return Data_Wrap_Struct(klass, NULL, rb_grn_table_cursor_free, NULL);
-}
-
-void
-rb_grn_table_cursor_bind (RbGrnTableCursor *rb_grn_table_cursor,
-			  grn_ctx *context, grn_table_cursor *cursor,
-			  rb_grn_boolean owner)
-{
-    RbGrnObject *rb_grn_object;
-
-    rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
-    rb_grn_object_bind(rb_grn_object, context, cursor, owner);
-    rb_grn_object->unbind = RB_GRN_UNBIND_FUNCTION(rb_grn_table_cursor_unbind);
-}
-
-void
-rb_grn_table_cursor_assign (VALUE self, VALUE rb_context,
-			    grn_ctx *context, grn_table_cursor *cursor,
-			    rb_grn_boolean owner)
-{
-    RbGrnTableCursor *rb_grn_table_cursor;
-
-    rb_grn_table_cursor = ALLOC(RbGrnTableCursor);
-    DATA_PTR(self) = rb_grn_table_cursor;
-    rb_grn_table_cursor_bind(rb_grn_table_cursor, context, cursor, owner);
-
-    rb_iv_set(self, "context", rb_context);
-}
-
 void
 rb_grn_table_cursor_deconstruct (RbGrnTableCursor *rb_grn_table_cursor,
 				 grn_table_cursor **cursor,
@@ -137,7 +60,23 @@ rb_grn_table_cursor_deconstruct (RbGrnTableCursor *rb_grn_table_cursor,
 VALUE
 rb_grn_table_cursor_close (VALUE self)
 {
-    rb_grn_table_cursor_unbind(SELF(self));
+    RbGrnTableCursor *rb_grn_table_cursor;
+    grn_table_cursor *cursor;
+    grn_ctx *context;
+
+    rb_grn_table_cursor = SELF(self);
+    rb_grn_table_cursor_deconstruct(rb_grn_table_cursor, &cursor, &context,
+				    NULL, NULL, NULL, NULL);
+
+    if (context && cursor) {
+	RbGrnObject *rb_grn_object;
+
+	rb_grn_object = RB_GRN_OBJECT(rb_grn_table_cursor);
+        grn_obj_close(context, cursor);
+	rb_grn_object->context = NULL;
+	rb_grn_object->object = NULL;
+    }
+
     return Qnil;
 }
 
@@ -259,8 +198,8 @@ rb_grn_table_cursor_each (VALUE self)
 void
 rb_grn_init_table_cursor (VALUE mGrn)
 {
-    rb_cGrnTableCursor = rb_define_class_under(mGrn, "TableCurosr", rb_cObject);
-    rb_define_alloc_func(rb_cGrnTableCursor, rb_grn_table_cursor_alloc);
+    rb_cGrnTableCursor = rb_define_class_under(mGrn, "TableCursor", rb_cObject);
+    rb_define_alloc_func(rb_cGrnTableCursor, rb_grn_object_alloc);
 
     rb_include_module(rb_cGrnTableCursor, rb_mEnumerable);
 

data/ext/rb-grn-table-key-support.c

@@ -45,34 +45,26 @@ rb_grn_table_key_support_deconstruct (RbGrnTableKeySupport *rb_grn_table_key_sup
 	*key = rb_grn_table_key_support->key;
 }
 
-static void
-rb_grn_table_key_support_free (void *object)
+void
+rb_grn_table_key_support_finalizer (grn_ctx *context,
+				    grn_obj *grn_object,
+				    RbGrnTableKeySupport *rb_grn_table_key_support)
 {
-    RbGrnObject *rb_grn_object = object;
-    RbGrnTable *rb_grn_table = object;
-    RbGrnTableKeySupport *rb_grn_table_key_support = object;
-    grn_ctx *context;
+    if (!context)
+	return;
 
-    context = rb_grn_object->context;
-    if (context)
+    if (rb_grn_table_key_support->key)
 	grn_obj_close(context, rb_grn_table_key_support->key);
+    rb_grn_table_key_support->key = NULL;
 
-    rb_grn_table_unbind(rb_grn_table);
-
-    xfree(rb_grn_table_key_support);
-}
-
-VALUE
-rb_grn_table_key_support_alloc (VALUE klass)
-{
-    return Data_Wrap_Struct(klass, NULL, rb_grn_table_key_support_free, NULL);
+    rb_grn_table_finalizer(context, grn_object,
+			   RB_GRN_TABLE(rb_grn_table_key_support));
 }
 
 void
 rb_grn_table_key_support_bind (RbGrnTableKeySupport *rb_grn_table_key_support,
 			       grn_ctx *context,
-			       grn_obj *table_key_support,
-			       rb_grn_boolean owner)
+			       grn_obj *table_key_support)
 {
     RbGrnObject *rb_grn_object;
     RbGrnTable *rb_grn_table;
@@ -80,29 +72,12 @@ rb_grn_table_key_support_bind (RbGrnTableKeySupport *rb_grn_table_key_support,
     rb_grn_object = RB_GRN_OBJECT(rb_grn_table_key_support);
 
     rb_grn_table = RB_GRN_TABLE(rb_grn_table_key_support);
-    rb_grn_table_bind(rb_grn_table, context, table_key_support, owner);
+    rb_grn_table_bind(rb_grn_table, context, table_key_support);
 
     rb_grn_table_key_support->key =
 	grn_obj_open(context, GRN_BULK, 0, rb_grn_object->domain_id);
 }
 
-void
-rb_grn_table_key_support_assign (VALUE self, VALUE rb_context,
-				 grn_ctx *context,
-				 grn_obj *table_key_support,
-				 rb_grn_boolean owner)
-{
-    RbGrnTableKeySupport *rb_grn_table_key_support;
-
-    rb_grn_table_key_support = ALLOC(RbGrnTableKeySupport);
-    DATA_PTR(self) = rb_grn_table_key_support;
-
-    rb_grn_table_key_support_bind(rb_grn_table_key_support,
-				  context, table_key_support, owner);
-
-    rb_iv_set(self, "context", rb_context);
-}
-
 static VALUE
 rb_grn_table_key_support_initialize (int argc, VALUE *argv, VALUE self)
 {
@@ -112,8 +87,7 @@ rb_grn_table_key_support_initialize (int argc, VALUE *argv, VALUE self)
 
     table = rb_grn_table_open_raw(argc, argv, &context, &rb_context);
     rb_grn_context_check(context, self);
-    rb_grn_table_key_support_assign(self, rb_context, context,
-				    table, RB_GRN_TRUE);
+    rb_grn_object_assign(Qnil, self, rb_context, context, table);
 
     return Qnil;
 }
@@ -182,6 +156,24 @@ rb_grn_table_key_support_get_key (VALUE self, VALUE rb_id)
     return rb_key;
 }
 
+static VALUE
+rb_grn_table_key_support_has_key (VALUE self, VALUE rb_key)
+{
+    grn_ctx *context;
+    grn_obj *table, *key, *domain;
+    grn_id id, domain_id;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 &key, &domain_id, &domain,
+					 NULL, NULL, NULL);
+
+    GRN_BULK_REWIND(key);
+    RVAL2GRNKEY(rb_key, context, key, domain_id, domain, self);
+    id = grn_table_get(context, table, GRN_BULK_HEAD(key), GRN_BULK_VSIZE(key));
+
+    return id == GRN_ID_NIL ? Qfalse : Qtrue;
+}
+
 static VALUE
 rb_grn_table_key_support_delete_by_key (VALUE self, VALUE rb_key)
 {
@@ -383,6 +375,8 @@ rb_grn_init_table_key_support (VALUE mGrn)
 		     rb_grn_table_key_support_add, -1);
     rb_define_method(rb_mGrnTableKeySupport, "key",
 		     rb_grn_table_key_support_get_key, 1);
+    rb_define_method(rb_mGrnTableKeySupport, "has_key?",
+		     rb_grn_table_key_support_has_key, 1);
 
     rb_define_method(rb_mGrnTableKeySupport, "delete",
 		     rb_grn_table_key_support_delete, 1);