rroonga 6.0.2-x64-mingw32 → 6.0.4-x64-mingw32

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

@@ -1,6 +1,6 @@
 /* -*- coding: utf-8; mode: C; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /*
-  Copyright (C) 2009-2014  Kouhei Sutou <kou@clear-code.com>
+  Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
   Copyright (C) 2014-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 
   This library is free software; you can redistribute it and/or
@@ -648,7 +648,7 @@ void
 rb_grn_init_variable_size_column (VALUE mGrn)
 {
     rb_cGrnVariableSizeColumn =
-        rb_define_class_under(mGrn, "VariableSizeColumn", rb_cGrnColumn);
+        rb_define_class_under(mGrn, "VariableSizeColumn", rb_cGrnDataColumn);
 
     rb_define_method(rb_cGrnVariableSizeColumn, "[]",
                      rb_grn_variable_size_column_array_reference, 1);

data/ext/groonga/rb-grn.h

@@ -99,7 +99,7 @@ RB_GRN_BEGIN_DECLS
 
 #define RB_GRN_MAJOR_VERSION 6
 #define RB_GRN_MINOR_VERSION 0
-#define RB_GRN_MICRO_VERSION 2
+#define RB_GRN_MICRO_VERSION 4
 
 #define RB_GRN_OBJECT(object) ((RbGrnObject *)(object))
 #define RB_GRN_NAMED_OBJECT(object) ((RbGrnNamedObject *)(object))
@@ -179,17 +179,23 @@ struct _RbGrnColumn
     grn_obj *value;
 };
 
+typedef struct _RbGrnDataColumn RbGrnDataColumn;
+struct _RbGrnDataColumn
+{
+    RbGrnColumn parent;
+};
+
 typedef struct _RbGrnVariableSizeColumn RbGrnVariableSizeColumn;
 struct _RbGrnVariableSizeColumn
 {
-    RbGrnColumn parent;
+    RbGrnDataColumn parent;
     grn_obj *element_value;
 };
 
 typedef struct _RbGrnIndexColumn RbGrnIndexColumn;
 struct _RbGrnIndexColumn
 {
-    RbGrnColumn parent;
+    RbGrnDataColumn parent;
     grn_obj *old_value;
     grn_obj *set_value;
     grn_obj *id_query;
@@ -268,6 +274,7 @@ RB_GRN_VAR VALUE rb_cGrnArrayCursor;
 RB_GRN_VAR VALUE rb_cGrnType;
 RB_GRN_VAR VALUE rb_cGrnProcedure;
 RB_GRN_VAR VALUE rb_cGrnColumn;
+RB_GRN_VAR VALUE rb_cGrnDataColumn;
 RB_GRN_VAR VALUE rb_cGrnFixSizeColumn;
 RB_GRN_VAR VALUE rb_cGrnVariableSizeColumn;
 RB_GRN_VAR VALUE rb_cGrnIndexColumn;
@@ -324,6 +331,7 @@ void           rb_grn_init_type                     (VALUE mGrn);
 void           rb_grn_init_procedure                (VALUE mGrn);
 void           rb_grn_init_procedure_type           (VALUE mGrn);
 void           rb_grn_init_column                   (VALUE mGrn);
+void           rb_grn_init_data_column              (VALUE mGrn);
 void           rb_grn_init_fix_size_column          (VALUE mGrn);
 void           rb_grn_init_variable_size_column     (VALUE mGrn);
 void           rb_grn_init_index_column             (VALUE mGrn);
@@ -510,6 +518,12 @@ VALUE          rb_grn_table_set_column_value        (VALUE self,
 VALUE          rb_grn_table_inspect_content         (VALUE object,
                                                      VALUE inspected);
 
+void           rb_grn_table_sort_keys_fill          (grn_ctx *context,
+                                                     grn_table_sort_key *sort_keys,
+                                                     size_t n_sort_keys,
+                                                     VALUE rb_sort_keys,
+                                                     VALUE rb_table);
+
 grn_ctx       *rb_grn_table_cursor_ensure_context   (VALUE cursor,
                                                      VALUE *rb_context);
 int            rb_grn_table_cursor_order_to_flag    (VALUE rb_order);

data/rroonga-build.rb

@@ -1,6 +1,4 @@
-#!/usr/bin/env ruby
-#
-# Copyright (C) 2009-2015  Kouhei Sutou <kou@clear-code.com>
+# Copyright (C) 2009-2016  Kouhei Sutou <kou@clear-code.com>
 # Copyright (C) 2015-2016  Masafumi Yokoyama <yokoyama@clear-code.com>
 #
 # This library is free software; you can redistribute it and/or
@@ -20,15 +18,15 @@ module RroongaBuild
   module RequiredGroongaVersion
     MAJOR = 6
     MINOR = 0
-    MICRO = 2
+    MICRO = 4
     VERSION = [MAJOR, MINOR, MICRO]
-    RELEASED_DATE = Time.utc(2016, 4, 29)
+    RELEASED_DATE = Time.utc(2016, 6, 6)
   end
 
   module LatestGroongaVersion
     MAJOR = 6
     MINOR = 0
-    MICRO = 2
+    MICRO = 4
     VERSION = [MAJOR, MINOR, MICRO]
   end
 

data/test/test-data-column.rb

@@ -0,0 +1,53 @@
+# Copyright (C) 2016  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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+class DataColumnTest < Test::Unit::TestCase
+  include GroongaTestUtils
+
+  def setup
+    setup_database
+  end
+
+  sub_test_case "#apply_window_function" do
+    def test_no_argument
+      Groonga::Schema.define do |schema|
+        schema.create_table("Comments") do |table|
+          table.uint32("nth")
+        end
+      end
+      comments = Groonga["Comments"]
+      nth = Groonga["Comments.nth"]
+
+      5.times do
+        comments.add
+      end
+
+      options = {
+        :sort_keys => [["_id", "desc"]],
+      }
+      nth.apply_window_function(options) do |record|
+        record.call("record_number")
+      end
+      assert_equal([
+                     [1, 5],
+                     [2, 4],
+                     [3, 3],
+                     [4, 2],
+                     [5, 1],
+                   ],
+                   comments.collect {|comment| [comment.id, comment.nth]})
+    end
+  end
+end

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-x64/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.h

@@ -24,6 +24,7 @@
 #include "groonga/array.h"
 #include "groonga/config.h"
 #include "groonga/dat.h"
+#include "groonga/db.h"
 #include "groonga/dump.h"
 #include "groonga/expr.h"
 #include "groonga/file_reader.h"
@@ -31,12 +32,16 @@
 #include "groonga/hash.h"
 #include "groonga/ii.h"
 #include "groonga/obj.h"
+#include "groonga/operator.h"
 #include "groonga/output.h"
 #include "groonga/pat.h"
 #include "groonga/request_canceler.h"
 #include "groonga/request_timer.h"
+#include "groonga/table.h"
 #include "groonga/thread.h"
+#include "groonga/time.h"
 #include "groonga/type.h"
 #include "groonga/util.h"
+#include "groonga/window_function.h"
 #include "groonga/windows.h"
 #include "groonga/windows_event_logger.h"

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,