rroonga 2.0.8 → 2.1.0

data/ext/groonga/rb-grn-query-logger.c

@@ -0,0 +1,263 @@
+/* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+  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
+*/
+
+#include "rb-grn.h"
+
+/*
+ * Document-class: Groonga::QueryLogger
+ *
+ * A class for logging query log.
+ *
+ */
+
+#define GRNQUERYLOGFLAGS2RVAL(flags)  (rb_grn_query_log_flags_to_ruby_object(flags))
+
+VALUE cGrnQueryLogger;
+VALUE mGrnQueryLoggerFlags;
+VALUE cGrnCallbackQueryLogger;
+
+static ID id_new;
+static ID id_parse;
+static ID id_log;
+static ID id_reopen;
+static ID id_fin;
+
+static grn_query_logger rb_grn_query_logger;
+
+static VALUE
+rb_grn_query_log_flags_to_ruby_object (unsigned int flags)
+{
+    return UINT2NUM(flags);
+}
+
+static void
+rb_grn_query_logger_log (grn_ctx *ctx, unsigned int flag,
+                         const char *timestamp, const char *info,
+                         const char *message, void *user_data)
+{
+    VALUE handler = (VALUE)user_data;
+
+    if (NIL_P(handler))
+        return;
+
+    /* TODO: use rb_protect(). */
+    rb_funcall(handler, id_log, 4,
+               GRNQUERYLOGFLAGS2RVAL(flag),
+               rb_str_new2(timestamp),
+               rb_str_new2(info),
+               rb_str_new2(message));
+}
+
+static void
+rb_grn_query_logger_reopen (grn_ctx *ctx, void *user_data)
+{
+    VALUE handler = (VALUE)user_data;
+
+    if (NIL_P(handler))
+        return;
+
+    /* TODO: use rb_protect(). */
+    rb_funcall(handler, id_reopen, 0);
+}
+
+static void
+rb_grn_query_logger_fin (grn_ctx *ctx, void *user_data)
+{
+    VALUE handler = (VALUE)user_data;
+
+    if (NIL_P(handler))
+        return;
+
+    /* TODO: use rb_protect(). */
+    rb_funcall(handler, id_fin, 0);
+}
+
+/*
+ * Registers a query logger or a callback that is called when a
+ * query log event is emitted.
+ *
+ * @overload register(logger, options={})
+ *   @param logger [#log, #reopen, #fin] The query logger. It is easy to
+ *     inherit {QueryLogger}.
+ *
+ *   @!macro query-logger.register.options
+ *     @param options [::Hash] The options.
+ *     @option options [Symbol, String, Integer or nil] :flags (:default)
+ *       Flags describe what query log should be logged.
+ *
+ *       @see {QueryLogger::Flags.parse}
+ *
+ *   @return void
+ *
+ * @overload register(options={})
+ *   @yield [action, flag, timestamp, info, message]
+ *     ...
+ *
+ *   @!macro query-logger.register.options
+ */
+static VALUE
+rb_grn_query_logger_s_register (int argc, VALUE *argv, VALUE klass)
+{
+    VALUE rb_context = Qnil;
+    grn_ctx *context;
+    VALUE rb_logger, rb_callback;
+    VALUE rb_options, rb_command, rb_result_code, rb_destination;
+    VALUE rb_cache, rb_size, rb_score, rb_default, rb_all, rb_flags;
+    unsigned int flags = GRN_QUERY_LOG_NONE;
+
+    rb_scan_args(argc, argv, "02&", &rb_logger, &rb_options, &rb_callback);
+
+    if (rb_block_given_p()) {
+        rb_logger = rb_funcall(cGrnCallbackQueryLogger, id_new, 1, rb_callback);
+    }
+
+    rb_grn_scan_options(rb_options,
+                        "command",     &rb_command,
+                        "result_code", &rb_result_code,
+                        "destination", &rb_destination,
+                        "cache",       &rb_cache,
+                        "size",        &rb_size,
+                        "score",       &rb_score,
+                        "default",     &rb_default,
+                        "all",         &rb_all,
+                        "flags",       &rb_flags,
+                        NULL);
+
+    if (RVAL2CBOOL(rb_command)) {
+        flags |= GRN_QUERY_LOG_COMMAND;
+    }
+    if (RVAL2CBOOL(rb_result_code)) {
+        flags |= GRN_QUERY_LOG_RESULT_CODE;
+    }
+    if (RVAL2CBOOL(rb_destination)) {
+        flags |= GRN_QUERY_LOG_DESTINATION;
+    }
+    if (RVAL2CBOOL(rb_cache)) {
+        flags |= GRN_QUERY_LOG_CACHE;
+    }
+    if (RVAL2CBOOL(rb_size)) {
+        flags |= GRN_QUERY_LOG_SIZE;
+    }
+    if (RVAL2CBOOL(rb_score)) {
+        flags |= GRN_QUERY_LOG_SCORE;
+    }
+    if (RVAL2CBOOL(rb_default)) {
+        flags |= GRN_QUERY_LOG_DEFAULT;
+    }
+    if (RVAL2CBOOL(rb_all)) {
+        flags |= GRN_QUERY_LOG_ALL;
+    }
+    if (!NIL_P(rb_flags)) {
+        flags = rb_funcall(mGrnQueryLoggerFlags, id_parse, 2,
+                           UINT2NUM(flags), rb_flags);
+    }
+
+    rb_grn_query_logger.flags     = flags;
+    rb_grn_query_logger.user_data = (void *)rb_logger;
+
+    context = rb_grn_context_ensure(&rb_context);
+    grn_query_logger_set(context, &rb_grn_query_logger);
+    rb_grn_context_check(context, rb_logger);
+    rb_cv_set(klass, "@@current_logger", rb_logger);
+
+    return Qnil;
+}
+
+static VALUE
+rb_grn_query_logger_s_unregister (VALUE klass)
+{
+    VALUE current_logger;
+    VALUE rb_context = Qnil;
+    grn_ctx *context;
+
+    current_logger = rb_cv_get(klass, "@@current_logger");
+    if (NIL_P(current_logger))
+        return Qnil;
+
+    rb_cv_set(klass, "@@current_logger", Qnil);
+
+    context = rb_grn_context_ensure(&rb_context);
+    grn_query_logger_set(context, NULL);
+    rb_grn_context_check(context, klass);
+
+    return Qnil;
+}
+
+/*
+ * Sends reopen request to the current query logger. It is useful for
+ * rotating log file.
+ *
+ * @overload reopen
+ * @return void
+ */
+static VALUE
+rb_grn_query_logger_s_reopen (VALUE klass)
+{
+    VALUE rb_context = Qnil;
+    grn_ctx *context;
+
+    context = rb_grn_context_ensure(&rb_context);
+    grn_query_logger_reopen(context);
+    rb_grn_context_check(context, klass);
+
+    return Qnil;
+}
+
+void
+rb_grn_init_query_logger (VALUE mGrn)
+{
+    id_new    = rb_intern("new");
+    id_parse  = rb_intern("parse");
+    id_log    = rb_intern("log");
+    id_reopen = rb_intern("reopen");
+    id_fin    = rb_intern("fin");
+
+    rb_grn_query_logger.log    = rb_grn_query_logger_log;
+    rb_grn_query_logger.reopen = rb_grn_query_logger_reopen;
+    rb_grn_query_logger.fin    = rb_grn_query_logger_fin;
+
+    rb_grn_query_logger.user_data = (void *)Qnil;
+
+    cGrnQueryLogger = rb_define_class_under(mGrn, "QueryLogger", rb_cObject);
+
+    rb_cv_set(cGrnQueryLogger, "@@current_logger", Qnil);
+    rb_define_singleton_method(cGrnQueryLogger, "register",
+                               rb_grn_query_logger_s_register, -1);
+    rb_define_singleton_method(cGrnQueryLogger, "unregister",
+                               rb_grn_query_logger_s_unregister, 0);
+    rb_define_singleton_method(cGrnQueryLogger, "reopen",
+                               rb_grn_query_logger_s_reopen, 0);
+
+    mGrnQueryLoggerFlags = rb_define_module_under(cGrnQueryLogger, "Flags");
+#define DEFINE_FLAG(NAME)                                       \
+    rb_define_const(mGrnQueryLoggerFlags,                       \
+                    #NAME, UINT2NUM(GRN_QUERY_LOG_ ## NAME))
+    DEFINE_FLAG(NONE);
+    DEFINE_FLAG(COMMAND);
+    DEFINE_FLAG(RESULT_CODE);
+    DEFINE_FLAG(DESTINATION);
+    DEFINE_FLAG(CACHE);
+    DEFINE_FLAG(SIZE);
+    DEFINE_FLAG(SCORE);
+    DEFINE_FLAG(ALL);
+    DEFINE_FLAG(DEFAULT);
+#undef DEFINE_FLAG
+
+    cGrnCallbackQueryLogger =
+        rb_define_class_under(mGrn, "CallbackQueryLogger", cGrnQueryLogger);
+}

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

@@ -111,6 +111,12 @@ rb_grn_snippet_initialize (int argc, VALUE *argv, VALUE self)
                         NULL);
 
     context = rb_grn_context_ensure(&rb_context);
+    if (!grn_ctx_db(context)) {
+	rb_raise(rb_eArgError,
+		 "Groonga::Context should be associated with a database by "
+		 "Groonga::Database#open or #create: %s",
+		 rb_grn_inspect(rb_context));
+    }
 
     if (RVAL2CBOOL(rb_normalize))
         flags |= GRN_SNIP_NORMALIZE;

data/ext/groonga/rb-grn-table-key-support.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
@@ -87,6 +87,101 @@ rb_grn_table_key_support_bind (RbGrnTableKeySupport *rb_grn_table_key_support,
 	grn_obj_open(context, GRN_BULK, 0, rb_grn_object->domain_id);
 }
 
+static VALUE
+rb_grn_table_key_support_inspect_content (VALUE self, VALUE inspected)
+{
+    RbGrnTableKeySupport *rb_grn_table;
+    grn_ctx *context = NULL;
+    grn_obj *table;
+
+    rb_grn_table = SELF(self);
+    if (!rb_grn_table)
+	return inspected;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 NULL, NULL, NULL,
+					 NULL, NULL, NULL,
+					 NULL);
+    if (!table)
+	return inspected;
+    if (!context)
+	return inspected;
+
+    {
+	grn_obj value;
+	grn_encoding encoding;
+
+	rb_str_cat2(inspected, ", ");
+	rb_str_cat2(inspected, "encoding: <");
+	GRN_OBJ_INIT(&value, GRN_BULK, 0, GRN_ID_NIL);
+	grn_obj_get_info(context, table, GRN_INFO_ENCODING, &value);
+	encoding = *((grn_encoding *)GRN_BULK_HEAD(&value));
+	grn_obj_unlink(context, &value);
+
+	if (context->rc == GRN_SUCCESS) {
+	    rb_str_concat(inspected, rb_inspect(GRNENCODING2RVAL(encoding)));
+	} else {
+	    rb_str_cat2(inspected, "invalid");
+	}
+
+	rb_str_cat2(inspected, ">");
+    }
+
+    {
+	grn_obj *default_tokenizer;
+
+	rb_str_cat2(inspected, ", ");
+	rb_str_cat2(inspected, "default_tokenizer: ");
+	default_tokenizer = grn_obj_get_info(context, table,
+					     GRN_INFO_DEFAULT_TOKENIZER,
+					     NULL);
+	if (default_tokenizer) {
+	    rb_grn_object_inspect_object_content_name(inspected, context,
+						      default_tokenizer);
+	} else {
+	    rb_str_cat2(inspected, "(nil)");
+	}
+    }
+
+    {
+	grn_obj *normalizer;
+
+	rb_str_cat2(inspected, ", ");
+	rb_str_cat2(inspected, "normalizer: ");
+	normalizer = grn_obj_get_info(context, table, GRN_INFO_NORMALIZER,
+				      NULL);
+	if (normalizer) {
+	    rb_grn_object_inspect_object_content_name(inspected, context,
+						      normalizer);
+	} else {
+	    rb_str_cat2(inspected, "(nil)");
+	}
+    }
+
+    return inspected;
+}
+
+/*
+ * Inspects the table.
+ *
+ * @overload inspect
+ *   @return [String] the inspected string.
+ */
+static VALUE
+rb_grn_table_key_support_inspect (VALUE self)
+{
+    VALUE inspected;
+
+    inspected = rb_str_new2("");
+    rb_grn_object_inspect_header(self, inspected);
+    rb_grn_object_inspect_content(self, inspected);
+    rb_grn_table_inspect_content(self, inspected);
+    rb_grn_table_key_support_inspect_content(self, inspected);
+    rb_grn_object_inspect_footer(self, inspected);
+
+    return inspected;
+}
+
 static grn_id
 rb_grn_table_key_support_add_raw (VALUE self, VALUE rb_key, int *added)
 {
@@ -283,16 +378,42 @@ rb_grn_table_key_support_delete_by_key (VALUE self, VALUE rb_key)
 }
 
 /*
- * テーブルの _id_ または _key_ に対応するレコードを削除する。
- *
  * @overload delete(id)
+ *   Delete a record that has ID @id@.
+ *
+ *   @param id [Integer] The ID of delete target record.
+ *
+ *   @return void
+ *
  * @overload delete(key)
+ *   Delete a record that has key @key@.
+ *
+ *   @param key [Object] The key of delete target record.
+ *
+ *   @return void
+ *
+ * @overload delete
+ *   @yield [record]
+ *     TODO: See #select.
+ *   @yieldparam [Groonga::RecodExpressionBuilder] record
+ *     TODO: See #select.
+ *   @yieldreturn [Groonga::ExpressionBuilder]
+ *     TODO: See #select.
+ *
+ *   @return void
  */
 static VALUE
-rb_grn_table_key_support_delete (VALUE self, VALUE rb_id_or_key)
+rb_grn_table_key_support_delete (int argc, VALUE *argv, VALUE self)
 {
+    VALUE rb_id_or_key;
+
+    if (rb_block_given_p()) {
+	return rb_grn_table_delete_by_expression(self);
+    }
+
+    rb_scan_args(argc, argv, "1", &rb_id_or_key);
     if (FIXNUM_P(rb_id_or_key)) {
-	return rb_grn_table_delete(self, rb_id_or_key);
+	return rb_grn_table_delete_by_id(self, rb_id_or_key);
     } else {
 	return rb_grn_table_key_support_delete_by_key(self, rb_id_or_key);
     }
@@ -659,21 +780,83 @@ rb_grn_table_key_support_set_default_tokenizer (VALUE self, VALUE rb_tokenizer)
 }
 
 /*
- * キーを正規化する場合は +true+ 、正規化しない場合は +false+ を返
- * す。
+ * Returns the normalizer that is used by {Groonga::IndexColumn}.
  *
- * @overload normalize_key?
+ * @overload normalizer
+ *   @return [nil, Groonga::Procedure]
  */
 static VALUE
-rb_grn_table_key_normalize_key_p (VALUE self)
+rb_grn_table_key_support_get_normalizer (VALUE self)
 {
+    grn_ctx *context = NULL;
     grn_obj *table;
+    grn_obj *normalizer = NULL;
 
-    rb_grn_table_key_support_deconstruct(SELF(self), &table, NULL,
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
+					 NULL, NULL, NULL,
+					 NULL, NULL, NULL,
+					 NULL);
+
+    normalizer = grn_obj_get_info(context, table, GRN_INFO_NORMALIZER, NULL);
+    rb_grn_context_check(context, self);
+
+    return GRNOBJECT2RVAL(Qnil, context, normalizer, GRN_FALSE);
+}
+
+/*
+ * Specifies the normalizer used by {Groonga::IndexColumn}.
+ *
+ * @example
+ *   # Uses NFKC normalizer.
+ *   table.normalizer = "NormalizerNFKC51"
+ *   # Specifies normalizer object.
+ *   table.normalizer = Groonga::Context["NormalizerNFKC51"]
+ *   # Uses auto normalizer that is a normalizer for backward compatibility.
+ *   table.normalizer = "TNormalizerAuto"
+ *
+ * @overload normalizer=(name)
+ *    @param [String] name Set a nomalizer named @name@.
+ *
+ * @overload normalizer=(normalizer)
+ *    @param [Groonga::Procedure] normalizer Set the normalizer object.
+ *
+ * @overload normalizer=(normalizer)
+ *    @param [nil] normalizer Unset normalizer.
+ */
+static VALUE
+rb_grn_table_key_support_set_normalizer (VALUE self, VALUE rb_normalizer)
+{
+    grn_ctx *context;
+    grn_obj *table;
+    grn_obj *normalizer;
+    grn_rc rc;
+
+    rb_grn_table_key_support_deconstruct(SELF(self), &table, &context,
 					 NULL, NULL, NULL,
 					 NULL, NULL, NULL,
 					 NULL);
-    return CBOOL2RVAL(table->header.flags & GRN_OBJ_KEY_NORMALIZE);
+
+    normalizer = RVAL2GRNOBJECT(rb_normalizer, &context);
+    rc = grn_obj_set_info(context, table, GRN_INFO_NORMALIZER, normalizer);
+    rb_grn_context_check(context, self);
+    rb_grn_rc_check(rc, self);
+
+    return Qnil;
+}
+
+/*
+ * キーを正規化する場合は +true+ 、正規化しない場合は +false+ を返
+ * す。
+ *
+ * @overload normalize_key?
+ */
+static VALUE
+rb_grn_table_key_support_normalize_key_p (VALUE self)
+{
+    VALUE normalizer;
+
+    normalizer = rb_grn_table_key_support_get_normalizer(self);
+    return CBOOL2RVAL(!NIL_P(normalizer));
 }
 
 /*
@@ -700,6 +883,9 @@ rb_grn_init_table_key_support (VALUE mGrn)
     rb_mGrnTableKeySupport = rb_define_module_under(rb_cGrnTable, "KeySupport");
     rb_include_module(rb_mGrnTableKeySupport, rb_mGrnEncodingSupport);
 
+    rb_define_method(rb_mGrnTableKeySupport, "inspect",
+		     rb_grn_table_key_support_inspect, 0);
+
     rb_define_method(rb_mGrnTableKeySupport, "add",
 		     rb_grn_table_key_support_add, -1);
     rb_define_method(rb_mGrnTableKeySupport, "id",
@@ -710,7 +896,7 @@ rb_grn_init_table_key_support (VALUE mGrn)
 		     rb_grn_table_key_support_has_key, 1);
 
     rb_define_method(rb_mGrnTableKeySupport, "delete",
-		     rb_grn_table_key_support_delete, 1);
+		     rb_grn_table_key_support_delete, -1);
 
     rb_define_method(rb_mGrnTableKeySupport, "[]",
 		     rb_grn_table_key_support_array_reference, 1);
@@ -732,8 +918,13 @@ rb_grn_init_table_key_support (VALUE mGrn)
     rb_define_method(rb_mGrnTableKeySupport, "default_tokenizer=",
 		     rb_grn_table_key_support_set_default_tokenizer, 1);
 
+    rb_define_method(rb_mGrnTableKeySupport, "normalizer",
+		     rb_grn_table_key_support_get_normalizer, 0);
+    rb_define_method(rb_mGrnTableKeySupport, "normalizer=",
+		     rb_grn_table_key_support_set_normalizer, 1);
+
     rb_define_method(rb_mGrnTableKeySupport, "normalize_key?",
-		     rb_grn_table_key_normalize_key_p, 0);
+		     rb_grn_table_key_support_normalize_key_p, 0);
 
     rb_define_method(rb_mGrnTableKeySupport, "support_key?",
 		     rb_grn_table_key_support_support_key_p, 0);