rroonga 6.0.2-x86-mingw32 → 6.0.4-x86-mingw32

data/test/test-procedure.rb

@@ -52,6 +52,12 @@ class ProcedureTest < Test::Unit::TestCase
     end
   end
 
+  def test_window_function_procedure?
+    assert do
+      Groonga["record_number"].window_function_procedure?
+    end
+  end
+
   private
   def assert_equal_procedure(expected_name, id, options={})
     procedure = Groonga::Context.default[id]
@@ -70,6 +76,12 @@ class ProcedureTest < Test::Unit::TestCase
       scorer = Groonga["scorer_tf_idf"]
       assert_equal(Groonga::ProcedureType::SCORER, scorer.type)
     end
+
+    def test_window_function
+      record_number = Groonga["record_number"]
+      assert_equal(Groonga::ProcedureType::WINDOW_FUNCTION,
+                   record_number.type)
+    end
   end
 
   class SelectorOnlyProcedureTest < self

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

@@ -1,5 +1,5 @@
 worker_processes 1;
-pid ${prefix}/var/run/groonga-httpd.pid;
+pid /vagrant/dist-x86/var/run/groonga-httpd.pid;
 
 # Match this to the file owner of Groonga database files if groonga-httpd is
 # run as root.

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

@@ -71,6 +71,19 @@ GRN_API void *_grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id);
   }\
 } while (0)
 
+#define GRN_ARRAY_EACH_BEGIN(ctx, array, cursor, head, tail, id) do {\
+  grn_array_cursor *cursor;\
+  cursor = grn_array_cursor_open((ctx), (array), (head), (tail), 0, -1, 0);\
+  if (cursor) {\
+    grn_id id;\
+    while ((id = grn_array_cursor_next(ctx, cursor))) {
+
+#define GRN_ARRAY_EACH_END(ctx, cursor)\
+    }\
+    grn_array_cursor_close(ctx, cursor);\
+  }\
+} while (0)
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -0,0 +1,46 @@
+/*
+  Copyright(C) 2009-2016 Brazil
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef struct _grn_db_create_optarg grn_db_create_optarg;
+
+struct _grn_db_create_optarg {
+  char **builtin_type_names;
+  int n_builtin_type_names;
+};
+
+GRN_API grn_obj *grn_db_create(grn_ctx *ctx, const char *path, grn_db_create_optarg *optarg);
+
+#define GRN_DB_OPEN_OR_CREATE(ctx,path,optarg,db) \
+  (((db) = grn_db_open((ctx), (path))) || (db = grn_db_create((ctx), (path), (optarg))))
+
+GRN_API grn_obj *grn_db_open(grn_ctx *ctx, const char *path);
+GRN_API void grn_db_touch(grn_ctx *ctx, grn_obj *db);
+GRN_API grn_rc grn_db_recover(grn_ctx *ctx, grn_obj *db);
+GRN_API grn_rc grn_db_unmap(grn_ctx *ctx, grn_obj *db);
+GRN_API uint32_t grn_db_get_last_modified(grn_ctx *ctx, grn_obj *db);
+GRN_API grn_bool grn_db_is_dirty(grn_ctx *ctx, grn_obj *db);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -77,7 +77,7 @@ GRN_API grn_rc grn_expr_dump_plan(grn_ctx *ctx, grn_obj *expr, grn_obj *buffer);
 GRN_API grn_obj *grn_expr_exec(grn_ctx *ctx, grn_obj *expr, int nargs);
 
 GRN_API grn_obj *grn_expr_alloc(grn_ctx *ctx, grn_obj *expr,
-                                grn_id domain, grn_obj_flags flags);
+                                grn_id domain, unsigned char flags);
 
 #define GRN_EXPR_CREATE_FOR_QUERY(ctx,table,expr,var) do {\
   if (((expr) = grn_expr_create((ctx), NULL, 0)) &&\

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

@@ -125,7 +125,8 @@ typedef enum {
   GRN_COMMAND_ERROR = -74,
   GRN_PLUGIN_ERROR = -75,
   GRN_SCORER_ERROR = -76,
-  GRN_CANCEL = -77
+  GRN_CANCEL = -77,
+  GRN_WINDOW_FUNCTION_ERROR = -78
 } grn_rc;
 
 GRN_API grn_rc grn_init(void);
@@ -146,12 +147,13 @@ typedef enum {
 typedef enum {
   GRN_COMMAND_VERSION_DEFAULT = 0,
   GRN_COMMAND_VERSION_1,
-  GRN_COMMAND_VERSION_2
+  GRN_COMMAND_VERSION_2,
+  GRN_COMMAND_VERSION_3
 } grn_command_version;
 
 #define GRN_COMMAND_VERSION_MIN GRN_COMMAND_VERSION_1
 #define GRN_COMMAND_VERSION_STABLE GRN_COMMAND_VERSION_1
-#define GRN_COMMAND_VERSION_MAX GRN_COMMAND_VERSION_2
+#define GRN_COMMAND_VERSION_MAX GRN_COMMAND_VERSION_3
 
 typedef enum {
   GRN_LOG_NONE = 0,
@@ -437,23 +439,6 @@ struct _grn_obj {
 
 #define GRN_OBJ_FIN(ctx,obj) (grn_obj_close((ctx), (obj)))
 
-typedef struct _grn_db_create_optarg grn_db_create_optarg;
-
-struct _grn_db_create_optarg {
-  char **builtin_type_names;
-  int n_builtin_type_names;
-};
-
-GRN_API grn_obj *grn_db_create(grn_ctx *ctx, const char *path, grn_db_create_optarg *optarg);
-
-#define GRN_DB_OPEN_OR_CREATE(ctx,path,optarg,db) \
-  (((db) = grn_db_open((ctx), (path))) || (db = grn_db_create((ctx), (path), (optarg))))
-
-GRN_API grn_obj *grn_db_open(grn_ctx *ctx, const char *path);
-GRN_API void grn_db_touch(grn_ctx *ctx, grn_obj *db);
-GRN_API grn_rc grn_db_recover(grn_ctx *ctx, grn_obj *db);
-GRN_API grn_rc grn_db_unmap(grn_ctx *ctx, grn_obj *db);
-
 GRN_API grn_rc grn_ctx_use(grn_ctx *ctx, grn_obj *db);
 GRN_API grn_obj *grn_ctx_db(grn_ctx *ctx);
 GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, int name_size);
@@ -524,7 +509,8 @@ typedef enum {
   GRN_PROC_HOOK,
   GRN_PROC_NORMALIZER,
   GRN_PROC_TOKEN_FILTER,
-  GRN_PROC_SCORER
+  GRN_PROC_SCORER,
+  GRN_PROC_WINDOW_FUNCTION
 } grn_proc_type;
 
 GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
@@ -535,68 +521,8 @@ GRN_API grn_obj *grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
                                    grn_expr_var **vars, unsigned int *nvars, grn_obj **caller);
 GRN_API grn_proc_type grn_proc_get_type(grn_ctx *ctx, grn_obj *proc);
 
-/*-------------------------------------------------------------
- * API for table
- */
-
-#define GRN_TABLE_MAX_KEY_SIZE         (0x1000)
-
-GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
-                                  const char *name, unsigned int name_size,
-                                  const char *path, grn_table_flags flags,
-                                  grn_obj *key_type, grn_obj *value_type);
-
-#define GRN_TABLE_OPEN_OR_CREATE(ctx,name,name_size,path,flags,key_type,value_type,table) \
-  (((table) = grn_ctx_get((ctx), (name), (name_size))) ||\
-   ((table) = grn_table_create((ctx), (name), (name_size), (path), (flags), (key_type), (value_type))))
-
-/* TODO: int *added -> grn_bool *added */
-GRN_API grn_id grn_table_add(grn_ctx *ctx, grn_obj *table,
-                             const void *key, unsigned int key_size, int *added);
-GRN_API grn_id grn_table_get(grn_ctx *ctx, grn_obj *table,
-                             const void *key, unsigned int key_size);
-GRN_API grn_id grn_table_at(grn_ctx *ctx, grn_obj *table, grn_id id);
-GRN_API grn_id grn_table_lcp_search(grn_ctx *ctx, grn_obj *table,
-                                    const void *key, unsigned int key_size);
-GRN_API int grn_table_get_key(grn_ctx *ctx, grn_obj *table,
-                              grn_id id, void *keybuf, int buf_size);
-GRN_API grn_rc grn_table_delete(grn_ctx *ctx, grn_obj *table,
-                                const void *key, unsigned int key_size);
-GRN_API grn_rc grn_table_delete_by_id(grn_ctx *ctx, grn_obj *table, grn_id id);
-GRN_API grn_rc grn_table_update_by_id(grn_ctx *ctx, grn_obj *table, grn_id id,
-                                      const void *dest_key, unsigned int dest_key_size);
-GRN_API grn_rc grn_table_update(grn_ctx *ctx, grn_obj *table,
-                                const void *src_key, unsigned int src_key_size,
-                                const void *dest_key, unsigned int dest_key_size);
-GRN_API grn_rc grn_table_truncate(grn_ctx *ctx, grn_obj *table);
-
 typedef grn_obj grn_table_cursor;
 
-#define GRN_CURSOR_ASCENDING           (0x00<<0)
-#define GRN_CURSOR_DESCENDING          (0x01<<0)
-#define GRN_CURSOR_GE                  (0x00<<1)
-#define GRN_CURSOR_GT                  (0x01<<1)
-#define GRN_CURSOR_LE                  (0x00<<2)
-#define GRN_CURSOR_LT                  (0x01<<2)
-#define GRN_CURSOR_BY_KEY              (0x00<<3)
-#define GRN_CURSOR_BY_ID               (0x01<<3)
-#define GRN_CURSOR_PREFIX              (0x01<<4)
-#define GRN_CURSOR_SIZE_BY_BIT         (0x01<<5)
-#define GRN_CURSOR_RK                  (0x01<<6)
-
-GRN_API grn_table_cursor *grn_table_cursor_open(grn_ctx *ctx, grn_obj *table,
-                                                const void *min, unsigned int min_size,
-                                                const void *max, unsigned int max_size,
-                                                int offset, int limit, int flags);
-GRN_API grn_rc grn_table_cursor_close(grn_ctx *ctx, grn_table_cursor *tc);
-GRN_API grn_id grn_table_cursor_next(grn_ctx *ctx, grn_table_cursor *tc);
-GRN_API int grn_table_cursor_get_key(grn_ctx *ctx, grn_table_cursor *tc, void **key);
-GRN_API int grn_table_cursor_get_value(grn_ctx *ctx, grn_table_cursor *tc, void **value);
-GRN_API grn_rc grn_table_cursor_set_value(grn_ctx *ctx, grn_table_cursor *tc,
-                                          const void *value, int flags);
-GRN_API grn_rc grn_table_cursor_delete(grn_ctx *ctx, grn_table_cursor *tc);
-GRN_API grn_obj *grn_table_cursor_table(grn_ctx *ctx, grn_table_cursor *tc);
-
 typedef struct {
   grn_id rid;
   uint32_t sid;
@@ -606,65 +532,6 @@ typedef struct {
   uint32_t rest;
 } grn_posting;
 
-GRN_API grn_obj *grn_index_cursor_open(grn_ctx *ctx, grn_table_cursor *tc, grn_obj *index,
-                                       grn_id rid_min, grn_id rid_max, int flags);
-GRN_API grn_posting *grn_index_cursor_next(grn_ctx *ctx, grn_obj *ic, grn_id *tid);
-
-#define GRN_TABLE_EACH(ctx,table,head,tail,id,key,key_size,value,block) do {\
-  (ctx)->errlvl = GRN_LOG_NOTICE;\
-  (ctx)->rc = GRN_SUCCESS;\
-  if ((ctx)->seqno & 1) {\
-    (ctx)->subno++;\
-  } else {\
-    (ctx)->seqno++;\
-  }\
-  if (table) {\
-    switch ((table)->header.type) {\
-    case GRN_TABLE_PAT_KEY :\
-      GRN_PAT_EACH((ctx), (grn_pat *)(table), (id), (key), (key_size), (value), block);\
-      break;\
-    case GRN_TABLE_DAT_KEY :\
-      GRN_DAT_EACH((ctx), (grn_dat *)(table), (id), (key), (key_size), block);\
-      break;\
-    case GRN_TABLE_HASH_KEY :\
-      GRN_HASH_EACH((ctx), (grn_hash *)(table), (id), (key), (key_size), (value), block);\
-      break;\
-    case GRN_TABLE_NO_KEY :\
-      GRN_ARRAY_EACH((ctx), (grn_array *)(table), (head), (tail), (id), (value), block);\
-      break;\
-    }\
-  }\
-  if ((ctx)->subno) {\
-    (ctx)->subno--;\
-  } else {\
-    (ctx)->seqno++;\
-  }\
-} while (0)
-
-typedef struct _grn_table_sort_key grn_table_sort_key;
-typedef unsigned char grn_table_sort_flags;
-
-#define GRN_TABLE_SORT_ASC             (0x00<<0)
-#define GRN_TABLE_SORT_DESC            (0x01<<0)
-
-struct _grn_table_sort_key {
-  grn_obj *key;
-  grn_table_sort_flags flags;
-  int offset;
-};
-
-GRN_API int grn_table_sort(grn_ctx *ctx, grn_obj *table, int offset, int limit,
-                           grn_obj *result, grn_table_sort_key *keys, int n_keys);
-
-typedef struct _grn_table_group_result grn_table_group_result;
-typedef uint32_t grn_table_group_flags;
-
-#define GRN_TABLE_GROUP_CALC_COUNT     (0x01<<3)
-#define GRN_TABLE_GROUP_CALC_MAX       (0x01<<4)
-#define GRN_TABLE_GROUP_CALC_MIN       (0x01<<5)
-#define GRN_TABLE_GROUP_CALC_SUM       (0x01<<6)
-#define GRN_TABLE_GROUP_CALC_AVG       (0x01<<7)
-
 typedef enum {
   GRN_OP_PUSH = 0,
   GRN_OP_POP,
@@ -749,50 +616,9 @@ typedef enum {
   GRN_OP_FUZZY
 } grn_operator;
 
-GRN_API const char *grn_operator_to_string(grn_operator op);
-GRN_API grn_bool grn_operator_exec_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y);
-GRN_API grn_bool grn_operator_exec_not_equal(grn_ctx *ctx,
-                                             grn_obj *x, grn_obj *y);
-GRN_API grn_bool grn_operator_exec_less(grn_ctx *ctx, grn_obj *x, grn_obj *y);
-GRN_API grn_bool grn_operator_exec_greater(grn_ctx *ctx, grn_obj *x, grn_obj *y);
-GRN_API grn_bool grn_operator_exec_less_equal(grn_ctx *ctx,
-                                              grn_obj *x, grn_obj *y);
-GRN_API grn_bool grn_operator_exec_greater_equal(grn_ctx *ctx,
-                                                 grn_obj *x, grn_obj *y);
-GRN_API grn_bool grn_operator_exec_match(grn_ctx *ctx,
-                                         grn_obj *target, grn_obj *sub_text);
-GRN_API grn_bool grn_operator_exec_prefix(grn_ctx *ctx,
-                                          grn_obj *target, grn_obj *prefix);
-GRN_API grn_bool grn_operator_exec_regexp(grn_ctx *ctx,
-                                          grn_obj *target, grn_obj *pattern);
-
-struct _grn_table_group_result {
-  grn_obj *table;
-  unsigned char key_begin;
-  unsigned char key_end;
-  int limit;
-  grn_table_group_flags flags;
-  grn_operator op;
-  unsigned int max_n_subrecs;
-  grn_obj *calc_target;
-};
-
-GRN_API grn_rc grn_table_group(grn_ctx *ctx, grn_obj *table,
-                               grn_table_sort_key *keys, int n_keys,
-                               grn_table_group_result *results, int n_results);
-GRN_API grn_rc grn_table_setoperation(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
-                                      grn_obj *res, grn_operator op);
-GRN_API grn_rc grn_table_difference(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
-                                    grn_obj *res1, grn_obj *res2);
-GRN_API int grn_table_columns(grn_ctx *ctx, grn_obj *table,
-                              const char *name, unsigned int name_size,
-                              grn_obj *res);
-
 GRN_API grn_obj *grn_obj_column(grn_ctx *ctx, grn_obj *table,
                                 const char *name, unsigned int name_size);
 
-GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
-
 /*-------------------------------------------------------------
  * API for column
  */
@@ -1218,6 +1044,13 @@ GRN_API grn_log_level grn_logger_get_max_level(grn_ctx *ctx);
 
 GRN_API void grn_logger_put(grn_ctx *ctx, grn_log_level level,
                             const char *file, int line, const char *func, const char *fmt, ...) GRN_ATTRIBUTE_PRINTF(6);
+GRN_API void grn_logger_putv(grn_ctx *ctx,
+                             grn_log_level level,
+                             const char *file,
+                             int line,
+                             const char *func,
+                             const char *fmt,
+                             va_list ap);
 GRN_API void grn_logger_reopen(grn_ctx *ctx);
 
 GRN_API grn_bool grn_logger_pass(grn_ctx *ctx, grn_log_level level);
@@ -1566,17 +1399,6 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
                       (offset) * sizeof(grn_obj *), sizeof(grn_obj *));\
 } while (0)
 
-#define GRN_TIME_USEC_PER_SEC 1000000
-#define GRN_TIME_PACK(sec, usec) ((long long int)(sec) * GRN_TIME_USEC_PER_SEC + (usec))
-#define GRN_TIME_UNPACK(time_value, sec, usec) do {\
-  sec = (time_value) / GRN_TIME_USEC_PER_SEC;\
-  usec = (time_value) % GRN_TIME_USEC_PER_SEC;\
-} while (0)
-
-GRN_API void grn_time_now(grn_ctx *ctx, grn_obj *obj);
-
-#define GRN_TIME_NOW(ctx,obj) (grn_time_now((ctx), (obj)))
-
 #define GRN_BOOL_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
 #define GRN_INT8_VALUE(obj) (*((signed char *)GRN_BULK_HEAD(obj)))
 #define GRN_UINT8_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
@@ -1734,38 +1556,9 @@ GRN_API int grn_charlen(grn_ctx *ctx, const char *str, const char *end);
 GRN_API grn_rc grn_ctx_push(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_obj *grn_ctx_pop(grn_ctx *ctx);
 
-GRN_API grn_obj *grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
-                                  grn_obj *res, grn_operator op);
-
 GRN_API int grn_obj_columns(grn_ctx *ctx, grn_obj *table,
                             const char *str, unsigned int str_size, grn_obj *res);
 
-GRN_API grn_table_sort_key *grn_table_sort_key_from_str(grn_ctx *ctx,
-                                                        const char *str, unsigned int str_size,
-                                                        grn_obj *table, unsigned int *nkeys);
-GRN_API grn_rc grn_table_sort_key_close(grn_ctx *ctx,
-                                        grn_table_sort_key *keys, unsigned int nkeys);
-
-GRN_API grn_bool grn_table_is_grouped(grn_ctx *ctx, grn_obj *table);
-
-GRN_API unsigned int grn_table_max_n_subrecs(grn_ctx *ctx, grn_obj *table);
-
-GRN_API grn_obj *grn_table_create_for_group(grn_ctx *ctx,
-                                            const char *name,
-                                            unsigned int name_size,
-                                            const char *path,
-                                            grn_obj *group_key,
-                                            grn_obj *value_type,
-                                            unsigned int max_n_subrecs);
-
-GRN_API unsigned int grn_table_get_subrecs(grn_ctx *ctx, grn_obj *table,
-                                           grn_id id, grn_id *subrecbuf,
-                                           int *scorebuf, int buf_size);
-
-GRN_API grn_obj *grn_table_tokenize(grn_ctx *ctx, grn_obj *table,
-                                    const char *str, unsigned int str_len,
-                                    grn_obj *buf, grn_bool addp);
-
 GRN_API grn_rc grn_load(grn_ctx *ctx, grn_content_type input_type,
                         const char *table, unsigned int table_len,
                         const char *columns, unsigned int columns_len,

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

@@ -84,6 +84,21 @@ GRN_API grn_rc grn_hash_cursor_delete(grn_ctx *ctx, grn_hash_cursor *c,
   }\
 } while (0)
 
+#define GRN_HASH_EACH_BEGIN(ctx, hash, cursor, id) do {\
+  grn_hash_cursor *cursor;\
+  cursor = grn_hash_cursor_open((ctx), (hash),\
+                                NULL, 0, NULL, 0,\
+                                0, -1, GRN_CURSOR_BY_ID);\
+  if (cursor) {\
+    grn_id id;\
+    while ((id = grn_hash_cursor_next((ctx), cursor)) != GRN_ID_NIL) {
+
+#define GRN_HASH_EACH_END(ctx, cursor)\
+    }\
+    grn_hash_cursor_close((ctx), cursor);\
+  }\
+} while(0)
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -46,6 +46,7 @@ GRN_API grn_bool grn_obj_is_selector_only_proc(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_normalizer_proc(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_token_filter_proc(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_bool grn_obj_is_scorer_proc(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_bool grn_obj_is_window_function_proc(grn_ctx *ctx, grn_obj *obj);
 
 GRN_API grn_rc grn_obj_cast(grn_ctx *ctx,
                             grn_obj *src,

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

@@ -0,0 +1,48 @@
+/*
+  Copyright(C) 2009-2016 Brazil
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#pragma once
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+typedef grn_bool grn_operator_exec_func(grn_ctx *ctx,
+                                        grn_obj *x,
+                                        grn_obj *y);
+
+GRN_API const char *grn_operator_to_string(grn_operator op);
+GRN_API grn_bool grn_operator_exec_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_not_equal(grn_ctx *ctx,
+                                             grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_less(grn_ctx *ctx, grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_greater(grn_ctx *ctx, grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_less_equal(grn_ctx *ctx,
+                                              grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_greater_equal(grn_ctx *ctx,
+                                                 grn_obj *x, grn_obj *y);
+GRN_API grn_bool grn_operator_exec_match(grn_ctx *ctx,
+                                         grn_obj *target, grn_obj *sub_text);
+GRN_API grn_bool grn_operator_exec_prefix(grn_ctx *ctx,
+                                          grn_obj *target, grn_obj *prefix);
+GRN_API grn_bool grn_operator_exec_regexp(grn_ctx *ctx,
+                                          grn_obj *target, grn_obj *pattern);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -58,7 +58,13 @@ struct _grn_obj_format {
 #define GRN_OBJ_FORMAT_FIN(ctx,format) do {\
   int ncolumns = GRN_BULK_VSIZE(&(format)->columns) / sizeof(grn_obj *);\
   grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&(format)->columns);\
-  while (ncolumns--) { grn_obj_unlink((ctx), *columns++); }\
+  while (ncolumns--) {\
+    grn_obj *column = *columns;\
+    columns++;\
+    if (grn_obj_is_accessor((ctx), column)) {\
+      grn_obj_close((ctx), column);\
+    }\
+  }\
   GRN_OBJ_FIN((ctx), &(format)->columns);\
   if ((format)->expression) { GRN_OBJ_FIN((ctx), (format)->expression); } \
 } while (0)
@@ -87,6 +93,16 @@ GRN_API void grn_ctx_output_str(grn_ctx *ctx,
 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 void grn_ctx_output_result_set_open(grn_ctx *ctx,
+                                            grn_obj *result_set,
+                                            grn_obj_format *format,
+                                            uint32_t n_additional_elements);
+GRN_API void grn_ctx_output_result_set_close(grn_ctx *ctx,
+                                             grn_obj *result_set,
+                                             grn_obj_format *format);
+GRN_API void grn_ctx_output_result_set(grn_ctx *ctx,
+                                       grn_obj *result_set,
+                                       grn_obj_format *format);
 GRN_API void grn_ctx_output_table_columns(grn_ctx *ctx,
                                           grn_obj *table,
                                           grn_obj_format *format);

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

@@ -113,9 +113,6 @@ GRN_API void grn_plugin_logtrace(grn_ctx *ctx, grn_log_level level);
 #define GRN_PLUGIN_SET_ERROR(ctx, level, error_code, ...) do { \
   grn_plugin_set_error(ctx, level, error_code, \
                        __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__); \
-  GRN_LOG(ctx, level, __VA_ARGS__); \
-  grn_plugin_backtrace(ctx); \
-  grn_plugin_logtrace(ctx, level); \
 } while (0)
 
 #define GRN_PLUGIN_ERROR(ctx, error_code, ...) \
@@ -148,7 +145,7 @@ GRN_API void grn_plugin_mutex_lock(grn_ctx *ctx, grn_plugin_mutex *mutex);
 GRN_API void grn_plugin_mutex_unlock(grn_ctx *ctx, grn_plugin_mutex *mutex);
 
 GRN_API grn_obj *grn_plugin_proc_alloc(grn_ctx *ctx, grn_user_data *user_data,
-                                       grn_id domain, grn_obj_flags flags);
+                                       grn_id domain, unsigned char flags);
 
 GRN_API grn_obj *grn_plugin_proc_get_vars(grn_ctx *ctx, grn_user_data *user_data);
 

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

@@ -134,16 +134,19 @@
 #endif /* WIN32 */
 
 #ifdef WIN32
-# define grn_snprintf(dest, dest_size, n, ...)                  \
-  _snprintf_s((dest), (dest_size), (n) - 1, __VA_ARGS__)
+# define grn_snprintf(dest, dest_size, n, ...) do {             \
+    _snprintf_s((dest), (dest_size), (n) - 1, __VA_ARGS__);     \
+  } while (GRN_FALSE)
 #else /* WIN32 */
 # define grn_snprintf(dest, dest_size, n, ...)  \
   snprintf((dest), (n), __VA_ARGS__)
 #endif /* WIN32 */
 
 #ifdef WIN32
-# define grn_vsnprintf(dest, dest_size, format, args)           \
-  vsnprintf((dest), (dest_size) - 1, (format), (args))
+# define grn_vsnprintf(dest, dest_size, format, args) do {      \
+    vsnprintf((dest), (dest_size), (format), (args));           \
+    (dest)[(dest_size) - 1] = '\0';                             \
+  } while (GRN_FALSE)
 #else /* WIN32 */
 # define grn_vsnprintf(dest, dest_size, format, args)           \
   vsnprintf((dest), (dest_size), (format), (args))

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

@@ -74,7 +74,7 @@ typedef double grn_scorer_score_func(grn_ctx *ctx,
 
 /*
   grn_scorer_register() registers a plugin to the database which is
-  associated with `ctx'. `plugin_name_ptr' and `plugin_name_length' specify the
+  associated with `ctx'. `scorer_name_ptr' and `scorer_name_length' specify the
   plugin name. Alphabetic letters ('A'-'Z' and 'a'-'z'), digits ('0'-'9') and
   an underscore ('_') are capable characters.
 
@@ -84,8 +84,8 @@ typedef double grn_scorer_score_func(grn_ctx *ctx,
   code on failure.
  */
 GRN_PLUGIN_EXPORT grn_rc grn_scorer_register(grn_ctx *ctx,
-                                             const char *plugin_name_ptr,
-                                             int plugin_name_length,
+                                             const char *scorer_name_ptr,
+                                             int scorer_name_length,
                                              grn_scorer_score_func *score);
 
 #ifdef __cplusplus