rroonga 2.0.7-x86-mingw32 → 2.0.8-x86-mingw32

data/ext/groonga/rb-grn.h

@@ -76,7 +76,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 2
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 7
+#define RB_GRN_MICRO_VERSION 8
 
 #define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
 

data/rroonga-build.rb

@@ -19,7 +19,7 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 2
     MINOR = 0
-    MICRO = 7
+    MICRO = 9
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

data/vendor/local/bin/mecab-config

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-prefix=/home/khayashi/work/groonga/groonga.clean/packages/windows/dist-x86
+prefix=/home/khayashi/work/groonga/groonga.clean-sub/packages/windows/dist-x86
 exec_prefix=${prefix}
 exec_prefix_set=no
 
@@ -107,7 +107,7 @@ while test $# -gt 0; do
 	;;
 
     --libexecdir)
-       	echo /home/khayashi/work/groonga/groonga.clean/packages/windows/dist-x86/libexec/mecab
+       	echo /home/khayashi/work/groonga/groonga.clean-sub/packages/windows/dist-x86/libexec/mecab
        	;;
 	
     --sysconfdir)

data/vendor/local/etc/groonga/httpd/groonga-httpd.conf

@@ -15,7 +15,7 @@ http {
   keepalive_timeout 65;
 
   # The default groonga database path.
-  groonga_database /home/khayashi/work/groonga/groonga.clean/packages/windows/dist-x86/var/lib/groonga/db/db;
+  groonga_database /home/khayashi/work/groonga/groonga.clean-sub/packages/windows/dist-x86/var/lib/groonga/db/db;
 
   # Create a groonga database automatically if the groonga database doesn't
   # exist.
@@ -37,7 +37,7 @@ http {
     }
 
     location / {
-      root /home/khayashi/work/groonga/groonga.clean/packages/windows/dist-x86/share/groonga/html/admin;
+      root /home/khayashi/work/groonga/groonga.clean-sub/packages/windows/dist-x86/share/groonga/html/admin;
       index index.html;
     }
 

data/vendor/local/etc/groonga/synonyms.tsv

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+#
+# key[TAB]synonym1[TAB]synonym2[TAB]...
+#
+#groonga	groonga	rroonga	mroonga

data/vendor/local/include/groonga/groonga.h

@@ -151,6 +151,23 @@ typedef enum {
   GRN_LOG_DUMP
 } grn_log_level;
 
+/* query log flags */
+#define GRN_QUERY_LOG_NONE        (0x00)
+#define GRN_QUERY_LOG_COMMAND     (0x01<<0)
+#define GRN_QUERY_LOG_RESULT_CODE (0x01<<1)
+#define GRN_QUERY_LOG_DESTINATION (0x01<<2)
+#define GRN_QUERY_LOG_CACHE       (0x01<<3)
+#define GRN_QUERY_LOG_SIZE        (0x01<<4)
+#define GRN_QUERY_LOG_SCORE       (0x01<<5)
+#define GRN_QUERY_LOG_ALL\
+  (GRN_QUERY_LOG_COMMAND |\
+   GRN_QUERY_LOG_RESULT_CODE |\
+   GRN_QUERY_LOG_DESTINATION |\
+   GRN_QUERY_LOG_CACHE |\
+   GRN_QUERY_LOG_SIZE |\
+   GRN_QUERY_LOG_SCORE)
+#define GRN_QUERY_LOG_DEFAULT     GRN_QUERY_LOG_ALL
+
 typedef enum {
   GRN_CONTENT_NONE = 0,
   GRN_CONTENT_TSV,
@@ -615,6 +632,8 @@ GRN_API const char *grn_plugin_get_suffix(void);
 /**
  * grn_proc_create:
  * @name: 作成するprocの名前。
+ * @name_size: The number of bytes of @name. If -1 is specified, @name
+ *             is handled as a NULL terminated string.
  * @type: procの種類。
  * @init: 初期化関数のポインタ
  * @next: 実処理関数のポインタ
@@ -641,7 +660,7 @@ typedef enum {
 } grn_proc_type;
 
 GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
-                                 const char *name, unsigned int name_size, grn_proc_type type,
+                                 const char *name, int name_size, grn_proc_type type,
                                  grn_proc_func *init, grn_proc_func *next, grn_proc_func *fin,
                                  unsigned int nvars, grn_expr_var *vars);
 /**
@@ -1985,6 +2004,8 @@ struct _grn_snip_mapping {
 #define GRN_SNIP_COPY_TAG              (0x01<<1)
 #define GRN_SNIP_SKIP_LEADING_SPACES   (0x01<<2)
 
+#define GRN_SNIP_MAPPING_HTML_ESCAPE   ((grn_snip_mapping *)-1)
+
 /* grn_snip_open() should return grn_obj * instead.
  * TODO: 3.0 */
 GRN_API grn_snip *grn_snip_open(grn_ctx *ctx, int flags, unsigned int width,
@@ -2048,6 +2069,35 @@ GRN_API grn_log_level grn_default_logger_get_max_level();
   }\
 } while (0)
 
+typedef struct _grn_query_logger_info grn_query_logger_info;
+
+struct _grn_query_logger_info {
+  unsigned int flags;
+  grn_user_data *user_data;
+  void (*log)(grn_ctx *ctx, unsigned int flag,
+              const char *timestamp, const char *info, const char *message,
+              grn_user_data *user_data);
+  void (*reopen)(grn_ctx *ctx, grn_user_data *user_data);
+  void (*fin)(grn_ctx *ctx, grn_user_data *user_data);
+};
+
+GRN_API grn_rc grn_query_logger_info_set(grn_ctx *ctx, const grn_query_logger_info *info);
+
+GRN_API void grn_query_logger_put(grn_ctx *ctx, unsigned int flag,
+                                  const char *mark,
+                                  const char *format, ...) GRN_ATTRIBUTE_PRINTF(4);
+
+GRN_API grn_bool grn_query_logger_pass(grn_ctx *ctx, unsigned int flag);
+
+GRN_API void grn_default_query_logger_set_flags(unsigned int flags);
+GRN_API unsigned int grn_default_query_logger_get_flags(void);
+
+#define GRN_QUERY_LOG(ctx, flag, mark, format, ...) do {\
+  if (grn_query_logger_pass(ctx, flag)) {\
+    grn_query_logger_put(ctx, (flag), (mark), format, __VA_ARGS__);\
+  }\
+} while (0)
+
 /* grn_bulk */
 
 #define GRN_BULK_BUFSIZE (sizeof(grn_obj) - sizeof(grn_obj_header))
@@ -2134,6 +2184,7 @@ struct _grn_obj_format {
   int limit;
   int hits_offset;
   int flags;
+  grn_obj *expression;
 };
 
 #define GRN_OBJ_FORMAT_INIT(format,format_nhits,format_offset,format_limit,format_hits_offset) do { \
@@ -2142,6 +2193,7 @@ struct _grn_obj_format {
   (format)->offset = (format_offset);\
   (format)->limit = (format_limit);\
   (format)->hits_offset = (format_hits_offset);\
+  (format)->expression = NULL;\
 } while (0)
 
 #define GRN_OBJ_FORMAT_FIN(ctx,format) do {\
@@ -2149,6 +2201,7 @@ struct _grn_obj_format {
   grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&(format)->columns);\
   while (ncolumns--) { grn_obj_unlink((ctx), *columns++); }\
   GRN_OBJ_FIN((ctx), &(format)->columns);\
+  if ((format)->expression) { GRN_OBJ_FIN((ctx), (format)->expression); } \
 } while (0)
 
 GRN_API void grn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
@@ -2156,6 +2209,24 @@ GRN_API void grn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type outp
 GRN_API void grn_output_envelope(grn_ctx *ctx, grn_rc rc,
                                  grn_obj *head, grn_obj *body, grn_obj *foot,
                                  const char *file, int line);
+
+GRN_API void grn_ctx_output_array_open(grn_ctx *ctx,
+                                       const char *name, int nelements);
+GRN_API void grn_ctx_output_array_close(grn_ctx *ctx);
+GRN_API void grn_ctx_output_map_open(grn_ctx *ctx,
+                                     const char *name, int nelements);
+GRN_API void grn_ctx_output_map_close(grn_ctx *ctx);
+GRN_API void grn_ctx_output_int32(grn_ctx *ctx, int value);
+GRN_API void grn_ctx_output_int64(grn_ctx *ctx, long long int value);
+GRN_API void grn_ctx_output_float(grn_ctx *ctx, double value);
+GRN_API void grn_ctx_output_cstr(grn_ctx *ctx, const char *value);
+GRN_API void grn_ctx_output_str(grn_ctx *ctx,
+                                const char *value, unsigned int value_len);
+GRN_API void grn_ctx_output_bool(grn_ctx *ctx, grn_bool value);
+GRN_API void grn_ctx_output_obj(grn_ctx *ctx,
+                                grn_obj *value, grn_obj_format *format);
+
+
 GRN_API const char *grn_ctx_get_mime_type(grn_ctx *ctx);
 GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
                                       void (*func)(grn_ctx *, int, void *),
@@ -2478,9 +2549,10 @@ GRN_API grn_rc grn_str_close(grn_ctx *ctx, grn_str *nstr);
 
 /* grn_string */
 
-#define GRN_STRING_REMOVE_BLANK (0x01<<0)
-#define GRN_STRING_WITH_TYPES   (0x01<<1)
-#define GRN_STRING_WITH_CHECKS  (0x01<<2)
+#define GRN_STRING_REMOVE_BLANK               (0x01<<0)
+#define GRN_STRING_WITH_TYPES                 (0x01<<1)
+#define GRN_STRING_WITH_CHECKS                (0x01<<2)
+#define GRN_STRING_REMOVE_TOKENIZED_DELIMITER (0x01<<3)
 
 #define GRN_NORMALIZER_AUTO ((grn_obj *)1)
 
@@ -2576,6 +2648,7 @@ typedef unsigned int grn_expr_flags;
 
 #define GRN_EXPR_SYNTAX_QUERY          (0x00)
 #define GRN_EXPR_SYNTAX_SCRIPT         (0x01)
+#define GRN_EXPR_SYNTAX_OUTPUT_COLUMNS (0x20)
 #define GRN_EXPR_ALLOW_PRAGMA          (0x02)
 #define GRN_EXPR_ALLOW_COLUMN          (0x04)
 #define GRN_EXPR_ALLOW_UPDATE          (0x08)

data/vendor/local/include/groonga/groonga/plugin.h

@@ -44,12 +44,12 @@ GRN_PLUGIN_EXPORT grn_rc GRN_PLUGIN_FIN(grn_ctx *ctx);
   Don't call these functions directly. Use GRN_PLUGIN_MALLOC(),
   GRN_PLUGIN_REALLOC() and GRN_PLUGIN_FREE() instead.
  */
-void *grn_plugin_malloc(grn_ctx *ctx, size_t size, const char *file,
-                        int line, const char *func);
+GRN_PLUGIN_EXPORT void *grn_plugin_malloc(grn_ctx *ctx, size_t size, const char *file,
+                                          int line, const char *func);
 void *grn_plugin_realloc(grn_ctx *ctx, void *ptr, size_t size,
                          const char *file, int line, const char *func);
-void grn_plugin_free(grn_ctx *ctx, void *ptr, const char *file,
-                     int line, const char *func);
+GRN_PLUGIN_EXPORT void grn_plugin_free(grn_ctx *ctx, void *ptr, const char *file,
+                                       int line, const char *func);
 
 /*
   GRN_PLUGIN_MALLOC() allocates `size' bytes and returns a pointer to the
@@ -86,17 +86,17 @@ void grn_plugin_free(grn_ctx *ctx, void *ptr, const char *file,
   Don't call grn_plugin_set_error() directly. This function is used in
   GRN_PLUGIN_SET_ERROR().
  */
-void grn_plugin_set_error(grn_ctx *ctx, grn_log_level level,
-                          grn_rc error_code,
-                          const char *file, int line, const char *func,
-                          const char *format, ...) GRN_ATTRIBUTE_PRINTF(7);
+GRN_PLUGIN_EXPORT void grn_plugin_set_error(grn_ctx *ctx, grn_log_level level,
+                                            grn_rc error_code,
+                                            const char *file, int line, const char *func,
+                                            const char *format, ...) GRN_ATTRIBUTE_PRINTF(7);
 
 /*
   Don't call these functions directly. grn_plugin_backtrace() and
   grn_plugin_logtrace() are used in GRN_PLUGIN_SET_ERROR().
  */
-void grn_plugin_backtrace(grn_ctx *ctx);
-void grn_plugin_logtrace(grn_ctx *ctx, grn_log_level level);
+GRN_PLUGIN_EXPORT void grn_plugin_backtrace(grn_ctx *ctx);
+GRN_PLUGIN_EXPORT void grn_plugin_logtrace(grn_ctx *ctx, grn_log_level level);
 
 /*
   Don't use GRN_PLUGIN_SET_ERROR() directly. This macro is used in
@@ -126,30 +126,60 @@ void grn_plugin_logtrace(grn_ctx *ctx, grn_log_level level);
 typedef struct _grn_plugin_mutex grn_plugin_mutex;
 
 /*
-  grn_plugin_mutex_create() returns a pointer to a new object of
+  grn_plugin_mutex_open() returns a pointer to a new object of
   grn_plugin_mutex. Memory for the new object is obtained with
-  GRN_PLUGIN_MALLOC(). grn_plugin_mutex_create() returns NULL if sufficient
+  GRN_PLUGIN_MALLOC(). grn_plugin_mutex_open() returns NULL if sufficient
   memory is not available.
  */
+GRN_PLUGIN_EXPORT grn_plugin_mutex *grn_plugin_mutex_open(grn_ctx *ctx);
+
+/*
+  grn_plugin_mutex_create() is deprecated. Use grn_plugin_mutex_open()
+  instead.
+*/
 grn_plugin_mutex *grn_plugin_mutex_create(grn_ctx *ctx);
 
 /*
-  grn_plugin_mutex_destroy() finalizes an object of grn_plugin_mutex and then
+  grn_plugin_mutex_close() finalizes an object of grn_plugin_mutex and then
   frees memory allocated for that object.
  */
+GRN_PLUGIN_EXPORT void grn_plugin_mutex_close(grn_ctx *ctx, grn_plugin_mutex *mutex);
+
+/*
+  grn_plugin_mutex_destroy() is deprecated. Use grn_plugin_mutex_close()
+  instead.
+*/
 void grn_plugin_mutex_destroy(grn_ctx *ctx, grn_plugin_mutex *mutex);
 
 /*
   grn_plugin_mutex_lock() locks a mutex object. If the object is already
   locked, the calling thread waits until the object will be unlocked.
  */
-void grn_plugin_mutex_lock(grn_ctx *ctx, grn_plugin_mutex *mutex);
+GRN_PLUGIN_EXPORT void grn_plugin_mutex_lock(grn_ctx *ctx, grn_plugin_mutex *mutex);
 
 /*
   grn_plugin_mutex_unlock() unlocks a mutex object. grn_plugin_mutex_unlock()
   should not be called for an unlocked object.
  */
-void grn_plugin_mutex_unlock(grn_ctx *ctx, grn_plugin_mutex *mutex);
+GRN_PLUGIN_EXPORT void grn_plugin_mutex_unlock(grn_ctx *ctx, grn_plugin_mutex *mutex);
+
+/*
+  grn_plugin_proc_alloc() allocates a `grn_obj` object.
+  You can use it in function that is registered as GRN_PROC_FUNCTION.
+ */
+GRN_PLUGIN_EXPORT grn_obj *grn_plugin_proc_alloc(grn_ctx *ctx, grn_user_data *user_data,
+                                                 grn_id domain, grn_obj_flags flags);
+
+/*
+  grn_plugin_win32_base_dir() returns the groonga install directory.
+  The install directory is computed from the directory that has
+  `groonga.dll`. You can use the directory to generate install
+  directory aware path.
+
+  It only works on Windows. It returns `NULL` on other platforms.
+ */
+GRN_PLUGIN_EXPORT const char *grn_plugin_win32_base_dir(void);
+
 
 #ifdef __cplusplus
 }

data/vendor/local/include/groonga/groonga/tokenizer.h

@@ -26,6 +26,9 @@
 extern "C" {
 #endif  /* __cplusplus */
 
+#define GRN_TOKENIZER_TOKENIZED_DELIMITER_UTF8     "\xEF\xBF\xBE"
+#define GRN_TOKENIZER_TOKENIZED_DELIMITER_UTF8_LEN 3
+
 /*
   grn_tokenizer_charlen() returns the length (#bytes) of the first character
   in the string specified by `str_ptr' and `str_length'. If the starting bytes
@@ -43,6 +46,26 @@ int grn_tokenizer_charlen(grn_ctx *ctx, const char *str_ptr,
 int grn_tokenizer_isspace(grn_ctx *ctx, const char *str_ptr,
                           unsigned int str_length, grn_encoding encoding);
 
+/*
+  grn_tokenizer_is_tokenized_delimiter() returns whether is the first
+  character in the string specified by `str_ptr' and `str_length' the
+  special tokenized delimiter character or not.
+ */
+grn_bool grn_tokenizer_is_tokenized_delimiter(grn_ctx *ctx,
+                                              const char *str_ptr,
+                                              unsigned int str_length,
+                                              grn_encoding encoding);
+
+/*
+  grn_tokenizer_have_tokenized_delimiter() returns whether is there
+  the special delimiter character in the string specified by `str_ptr'
+  and `str_length' the special tokenized delimiter character or not.
+ */
+GRN_PLUGIN_EXPORT grn_bool grn_tokenizer_have_tokenized_delimiter(grn_ctx *ctx,
+                                                                  const char *str_ptr,
+                                                                  unsigned int str_length,
+                                                                  grn_encoding encoding);
+
 /*
   grn_tokenizer_query is a structure for storing a query. See the following
   functions.
@@ -58,20 +81,34 @@ struct _grn_tokenizer_query {
 };
 
 /*
-  grn_tokenizer_query_create() parses `args' and returns a new object of
+  grn_tokenizer_query_open() parses `args' and returns a new object of
   grn_tokenizer_query. The new object stores information of the query.
   grn_tokenizer_query_create() normalizes the query if the target table
   requires normalization. grn_tokenizer_query_create() returns NULL if
   something goes wrong. Note that grn_tokenizer_query_create() must be called
   just once in the function that initializes a tokenizer.
  */
+GRN_PLUGIN_EXPORT grn_tokenizer_query *grn_tokenizer_query_open(grn_ctx *ctx,
+                                                                int num_args, grn_obj **args);
+
+/*
+  grn_tokenizer_query_create() is deprecated. Use grn_tokenizer_query_open()
+  instead.
+*/
+
 grn_tokenizer_query *grn_tokenizer_query_create(grn_ctx *ctx,
                                                 int num_args, grn_obj **args);
 
 /*
-  grn_tokenizer_mutex_destroy() finalizes an object of grn_tokenizer_mutex
+  grn_tokenizer_query_close() finalizes an object of grn_tokenizer_query
   and then frees memory allocated for that object.
  */
+GRN_PLUGIN_EXPORT void grn_tokenizer_query_close(grn_ctx *ctx, grn_tokenizer_query *query);
+
+/*
+  grn_tokenizer_query_destroy() is deprecated. Use grn_tokenizer_query_close()
+  instead.
+ */
 void grn_tokenizer_query_destroy(grn_ctx *ctx, grn_tokenizer_query *query);
 
 /*
@@ -90,13 +127,13 @@ struct _grn_tokenizer_token {
   grn_tokenizer_token_init() initializes `token'. Note that an initialized
   object must be finalized by grn_tokenizer_token_fin().
  */
-void grn_tokenizer_token_init(grn_ctx *ctx, grn_tokenizer_token *token);
+GRN_PLUGIN_EXPORT void grn_tokenizer_token_init(grn_ctx *ctx, grn_tokenizer_token *token);
 
 /*
   grn_tokenizer_token_fin() finalizes `token' that has been initialized by
   grn_tokenizer_token_init().
  */
-void grn_tokenizer_token_fin(grn_ctx *ctx, grn_tokenizer_token *token);
+GRN_PLUGIN_EXPORT void grn_tokenizer_token_fin(grn_ctx *ctx, grn_tokenizer_token *token);
 
 /*
   grn_tokenizer_status provides a list of tokenizer status codes.
@@ -111,16 +148,29 @@ typedef enum {
 } grn_tokenizer_status;
 
 /*
-  grn_tokenizer_token_push() pushes the next token in `*token'. Note that
+  grn_tokenizer_token_push() pushes the next token into `token'. Note that
   grn_tokenizer_token_push() does not make a copy of the given string. This
   means that you have to maintain a memory space allocated to the string.
   Also note that the grn_tokenizer_token object must be maintained until the
   request for the next token or finalization comes. See grn_tokenizer_status in
   this header for more details of `status'.
  */
-void grn_tokenizer_token_push(grn_ctx *ctx, grn_tokenizer_token *token,
-                              const char *str_ptr, unsigned int str_length,
-                              grn_tokenizer_status status);
+GRN_PLUGIN_EXPORT void grn_tokenizer_token_push(grn_ctx *ctx, grn_tokenizer_token *token,
+                                                const char *str_ptr, unsigned int str_length,
+                                                grn_tokenizer_status status);
+
+/*
+  grn_tokenizer_tokenized_delimiter_next() extracts the next token
+  from the string specified by `str_ptr' and `str_length' and pushes
+  the next token into `token'. It returns the string after the next
+  token. The returned string may be `NULL' when all tokens are
+  extracted.
+ */
+GRN_PLUGIN_EXPORT const char *grn_tokenizer_tokenized_delimiter_next(grn_ctx *ctx,
+                                                                     grn_tokenizer_token *token,
+                                                                     const char *str_ptr,
+                                                                     unsigned int str_length,
+                                                                     grn_encoding encoding);
 
 /*
   grn_tokenizer_register() registers a plugin to the database which is
@@ -134,10 +184,10 @@ void grn_tokenizer_token_push(grn_ctx *ctx, grn_tokenizer_token *token,
   details of grn_proc_func and grn_user_data, that is used as an argument of
   grn_proc_func.
  */
-grn_rc grn_tokenizer_register(grn_ctx *ctx, const char *plugin_name_ptr,
-                              unsigned int plugin_name_length,
-                              grn_proc_func *init, grn_proc_func *next,
-                              grn_proc_func *fin);
+GRN_PLUGIN_EXPORT grn_rc grn_tokenizer_register(grn_ctx *ctx, const char *plugin_name_ptr,
+                                                unsigned int plugin_name_length,
+                                                grn_proc_func *init, grn_proc_func *next,
+                                                grn_proc_func *fin);
 
 #ifdef __cplusplus
 }  /* extern "C" */