rroonga 7.1.1-x64-mingw32 → 9.0.2-x64-mingw32

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

@@ -1,5 +1,5 @@
 /*
-  Copyright(C) 2012-2016 Brazil
+  Copyright(C) 2012-2018 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -29,6 +29,10 @@ GRN_API grn_rc grn_accessor_resolve(grn_ctx *ctx,
                                     grn_obj *res,
                                     grn_operator op);
 
+GRN_API grn_rc grn_accessor_name(grn_ctx *ctx,
+                                 grn_obj *accessor,
+                                 grn_obj *name);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -1,5 +1,6 @@
 /*
   Copyright(C) 2009-2017 Brazil
+  Copyright(C) 2018 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
@@ -33,6 +34,9 @@ GRN_API void *grn_column_cache_ref(grn_ctx *ctx,
                                    grn_id id,
                                    size_t *value_size);
 
+GRN_API grn_rc
+grn_column_copy(grn_ctx *ctx, grn_obj *from, grn_obj *to);
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -1,5 +1,5 @@
 /*
-  Copyright(C) 2009-2016 Brazil
+  Copyright(C) 2009-2018 Brazil
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -40,6 +40,8 @@ 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);
+GRN_API grn_rc grn_db_set_cache(grn_ctx *ctx, grn_obj *db, grn_cache *cache);
+GRN_API grn_cache *grn_db_get_cache(grn_ctx *ctx, grn_obj *db);
 
 #define GRN_DB_EACH_BEGIN_FLAGS(ctx, cursor, id, flags)                 \
   GRN_TABLE_EACH_BEGIN_FLAGS(ctx,                                       \

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

@@ -54,6 +54,11 @@ GRN_API grn_obj *grn_expr_append_const_str(grn_ctx *ctx, grn_obj *expr,
                                            grn_operator op, int nargs);
 GRN_API grn_obj *grn_expr_append_const_int(grn_ctx *ctx, grn_obj *expr, int i,
                                            grn_operator op, int nargs);
+GRN_API grn_obj *grn_expr_append_const_bool(grn_ctx *ctx,
+                                            grn_obj *expr,
+                                            grn_bool value,
+                                            grn_operator op,
+                                            int nargs);
 GRN_API grn_rc grn_expr_append_op(grn_ctx *ctx, grn_obj *expr, grn_operator op, int nargs);
 
 GRN_API grn_rc grn_expr_get_keywords(grn_ctx *ctx, grn_obj *expr, grn_obj *keywords);

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

@@ -1,5 +1,6 @@
 /*
   Copyright(C) 2009-2018 Brazil
+  Copyright(C) 2018-2019 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
@@ -19,9 +20,10 @@
 #pragma once
 
 #include <stdarg.h>
-#include <sys/types.h>
+#include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
+#include <sys/types.h>
 
 #ifdef  __cplusplus
 extern "C" {
@@ -35,14 +37,15 @@ extern "C" {
 # endif /* defined(_WIN32) || defined(_WIN64) */
 #endif /* GRN_API */
 
-typedef unsigned int grn_id;
-typedef uint8_t grn_bool;
+typedef uint32_t grn_id;
+/* Deprecated since 9.0.2. Use bool directly. */
+typedef bool grn_bool;
 
 #define GRN_ID_NIL                     (0x00)
 #define GRN_ID_MAX                     (0x3fffffff)
 
-#define GRN_TRUE                       (1)
-#define GRN_FALSE                      (0)
+#define GRN_TRUE                       true
+#define GRN_FALSE                      false
 
 typedef enum {
   GRN_SUCCESS = 0,
@@ -204,6 +207,8 @@ typedef struct _grn_ctx grn_ctx;
 #define GRN_CTX_MSGSIZE                (0x80)
 #define GRN_CTX_FIN                    (0xff)
 
+typedef void (*grn_close_func)(grn_ctx *ctx, void *data);
+
 typedef union {
   int int_value;
   grn_id id;
@@ -269,6 +274,8 @@ GRN_API grn_command_version grn_ctx_get_command_version(grn_ctx *ctx);
 GRN_API grn_rc grn_ctx_set_command_version(grn_ctx *ctx, grn_command_version version);
 GRN_API long long int grn_ctx_get_match_escalation_threshold(grn_ctx *ctx);
 GRN_API grn_rc grn_ctx_set_match_escalation_threshold(grn_ctx *ctx, long long int threshold);
+GRN_API grn_bool grn_ctx_get_force_match_escalation(grn_ctx *ctx);
+GRN_API grn_rc grn_ctx_set_force_match_escalation(grn_ctx *ctx, grn_bool force);
 GRN_API long long int grn_get_default_match_escalation_threshold(void);
 GRN_API grn_rc grn_set_default_match_escalation_threshold(long long int threshold);
 
@@ -305,6 +312,8 @@ typedef uint32_t grn_column_flags;
 #define GRN_OBJ_KEY_WITH_SIS           (0x01<<6)
 #define GRN_OBJ_KEY_NORMALIZE          (0x01<<7)
 
+/* flags for grn_obj_flags and grn_column_flags */
+
 #define GRN_OBJ_COLUMN_TYPE_MASK       (0x07)
 #define GRN_OBJ_COLUMN_SCALAR          (0x00)
 #define GRN_OBJ_COLUMN_VECTOR          (0x01)
@@ -352,6 +361,7 @@ typedef uint32_t grn_column_flags;
 
 #define GRN_OBJ_INDEX_SMALL            (0x01<<16)
 #define GRN_OBJ_INDEX_MEDIUM           (0x01<<17)
+#define GRN_OBJ_INDEX_LARGE            (0x01<<18)
 
 /* obj types */
 
@@ -367,6 +377,7 @@ typedef uint32_t grn_column_flags;
 #define GRN_SNIP                       (0x0b)
 #define GRN_PATSNIP                    (0x0c)
 #define GRN_STRING                     (0x0d)
+#define GRN_HIGHLIGHTER                (0x0e)
 #define GRN_CURSOR_TABLE_HASH_KEY      (0x10)
 #define GRN_CURSOR_TABLE_PAT_KEY       (0x11)
 #define GRN_CURSOR_TABLE_DAT_KEY       (0x12)
@@ -768,6 +779,7 @@ GRN_API grn_rc grn_obj_clear_lock(grn_ctx *ctx, grn_obj *obj);
 GRN_API unsigned int grn_obj_is_locked(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_rc grn_obj_flush(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_rc grn_obj_flush_recursive(grn_ctx *ctx, grn_obj *obj);
+GRN_API grn_rc grn_obj_flush_recursive_dependent(grn_ctx *ctx, grn_obj *obj);
 GRN_API int grn_obj_defrag(grn_ctx *ctx, grn_obj *obj, int threshold);
 
 GRN_API grn_obj *grn_obj_db(grn_ctx *ctx, grn_obj *obj);
@@ -787,6 +799,7 @@ struct _grn_fuzzy_search_optarg {
 };
 
 #define GRN_MATCH_INFO_GET_MIN_RECORD_ID                           (0x01)
+#define GRN_MATCH_INFO_ONLY_SKIP_TOKEN                             (0x02)
 
 typedef struct _grn_match_info grn_match_info;
 
@@ -833,24 +846,6 @@ GRN_API grn_rc grn_proc_set_is_stable(grn_ctx *ctx,
                                       grn_bool is_stable);
 GRN_API grn_bool grn_proc_is_stable(grn_ctx *ctx, grn_obj *proc);
 
-/*-------------------------------------------------------------
- * grn_vector
-*/
-
-GRN_API unsigned int grn_vector_size(grn_ctx *ctx, grn_obj *vector);
-
-GRN_API grn_rc grn_vector_add_element(grn_ctx *ctx, grn_obj *vector,
-                                      const char *str, unsigned int str_len,
-                                      unsigned int weight, grn_id domain);
-
-GRN_API unsigned int grn_vector_get_element(grn_ctx *ctx, grn_obj *vector,
-                                            unsigned int offset, const char **str,
-                                            unsigned int *weight, grn_id *domain);
-GRN_API unsigned int grn_vector_pop_element(grn_ctx *ctx, grn_obj *vector,
-                                            const char **str,
-                                            unsigned int *weight,
-                                            grn_id *domain);
-
 /*-------------------------------------------------------------
  * grn_uvector
 */
@@ -1021,11 +1016,24 @@ GRN_API grn_rc grn_snip_get_result(grn_ctx *ctx, grn_obj *snip, const unsigned i
 
 /* log */
 
+#define GRN_LOG_NONE                   (0x00<<0)
 #define GRN_LOG_TIME                   (0x01<<0)
 #define GRN_LOG_TITLE                  (0x01<<1)
 #define GRN_LOG_MESSAGE                (0x01<<2)
 #define GRN_LOG_LOCATION               (0x01<<3)
 #define GRN_LOG_PID                    (0x01<<4)
+#define GRN_LOG_PROCESS_ID             GRN_LOG_PID
+#define GRN_LOG_THREAD_ID              (0x01<<5)
+#define GRN_LOG_ALL                             \
+  (GRN_LOG_TIME |                               \
+   GRN_LOG_TITLE |                              \
+   GRN_LOG_MESSAGE |                            \
+   GRN_LOG_LOCATION |                           \
+   GRN_LOG_PROCESS_ID |                         \
+   GRN_LOG_THREAD_ID)
+#define GRN_LOG_DEFAULT                         \
+  (GRN_LOG_TIME |                               \
+   GRN_LOG_MESSAGE)
 
 /* Deprecated since 2.1.2. Use grn_logger instead. */
 typedef struct _grn_logger_info grn_logger_info;
@@ -1054,6 +1062,10 @@ struct _grn_logger {
   void (*fin)(grn_ctx *ctx, void *user_data);
 };
 
+GRN_API grn_bool grn_log_flags_parse(const char *string,
+                                     int string_size,
+                                     int *flags);
+
 GRN_API grn_rc grn_logger_set(grn_ctx *ctx, const grn_logger *logger);
 
 GRN_API void grn_logger_set_max_level(grn_ctx *ctx, grn_log_level max_level);
@@ -1098,6 +1110,8 @@ GRN_API void grn_logger_reopen(grn_ctx *ctx);
 
 GRN_API grn_bool grn_logger_pass(grn_ctx *ctx, grn_log_level level);
 
+GRN_API grn_bool grn_logger_is_default_logger(grn_ctx *ctx);
+
 #ifndef GRN_LOG_DEFAULT_LEVEL
 # define GRN_LOG_DEFAULT_LEVEL GRN_LOG_NOTICE
 #endif /* GRN_LOG_DEFAULT_LEVEL */
@@ -1238,7 +1252,7 @@ GRN_API grn_rc grn_text_itoa(grn_ctx *ctx, grn_obj *bulk, int i);
 GRN_API grn_rc grn_text_itoa_padded(grn_ctx *ctx, grn_obj *bulk, int i, char ch, unsigned int len);
 GRN_API grn_rc grn_text_lltoa(grn_ctx *ctx, grn_obj *bulk, long long int i);
 GRN_API grn_rc grn_text_ftoa(grn_ctx *ctx, grn_obj *bulk, double d);
-GRN_API grn_rc grn_text_itoh(grn_ctx *ctx, grn_obj *bulk, int i, unsigned int len);
+GRN_API grn_rc grn_text_itoh(grn_ctx *ctx, grn_obj *bulk, unsigned int i, unsigned int len);
 GRN_API grn_rc grn_text_itob(grn_ctx *ctx, grn_obj *bulk, grn_id id);
 GRN_API grn_rc grn_text_lltob32h(grn_ctx *ctx, grn_obj *bulk, long long int i);
 GRN_API grn_rc grn_text_benc(grn_ctx *ctx, grn_obj *bulk, unsigned int v);
@@ -1339,40 +1353,40 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
   GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_WGS84_GEO_POINT)
 
 #define GRN_BOOL_SET(ctx,obj,val) do {\
-  unsigned char _val = (unsigned char)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned char));\
+  bool _val = (bool)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(bool));\
 } while (0)
 #define GRN_INT8_SET(ctx,obj,val) do {\
-  signed char _val = (signed char)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(signed char));\
+  int8_t _val = (int8_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int8_t));\
 } while (0)
 #define GRN_UINT8_SET(ctx,obj,val) do {\
-  unsigned char _val = (unsigned char)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned char));\
+  uint8_t _val = (uint8_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint8_t));\
 } while (0)
 #define GRN_INT16_SET(ctx,obj,val) do {\
-  signed short _val = (signed short)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(signed short));\
+  int16_t _val = (int16_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int16_t));\
 } while (0)
 #define GRN_UINT16_SET(ctx,obj,val) do {\
-  unsigned short _val = (unsigned short)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned short));\
+  uint16_t _val = (uint16_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint16_t));\
 } while (0)
 #define GRN_INT32_SET(ctx,obj,val) do {\
-  int _val = (int)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int));\
+  int32_t _val = (int32_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int32_t));\
 } while (0)
 #define GRN_UINT32_SET(ctx,obj,val) do {\
-  unsigned int _val = (unsigned int)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned int));\
+  uint32_t _val = (uint32_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint32_t));\
 } while (0)
 #define GRN_INT64_SET(ctx,obj,val) do {\
-  long long int _val = (long long int)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(long long int));\
+  int64_t _val = (int64_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int64_t));\
 } while (0)
 #define GRN_UINT64_SET(ctx,obj,val) do {\
-  long long unsigned int _val = (long long unsigned int)(val);\
-  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(long long unsigned int));\
+  uint64_t _val = (uint64_t)(val);\
+  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint64_t));\
 } while (0)
 #define GRN_FLOAT_SET(ctx,obj,val) do {\
   double _val = (double)(val);\
@@ -1389,9 +1403,9 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
 } while (0)
 
 #define GRN_GEO_DEGREE2MSEC(degree)\
-  ((int)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))
+  ((int32_t)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))
 #define GRN_GEO_MSEC2DEGREE(msec)\
-  ((((int)(msec)) / 3600.0) * 0.001)
+  ((((int32_t)(msec)) / 3600.0) * 0.001)
 
 #define GRN_GEO_POINT_SET(ctx,obj,_latitude,_longitude) do {\
   grn_geo_point _val;\
@@ -1401,50 +1415,50 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
 } while (0)
 
 #define GRN_BOOL_SET_AT(ctx,obj,offset,val) do {\
-  unsigned char _val = (unsigned char)(val);\
+  bool _val = (bool)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset), sizeof(unsigned char));\
+                      (offset), sizeof(bool));\
 } while (0)
 #define GRN_INT8_SET_AT(ctx,obj,offset,val) do {\
-  signed char _val = (signed char)(val);\
+  int8_t _val = (int8_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(signed char), sizeof(signed char));\
+                      (offset) * sizeof(int8_t), sizeof(int8_t));\
 } while (0)
 #define GRN_UINT8_SET_AT(ctx,obj,offset,val) do { \
-  unsigned char _val = (unsigned char)(val);\
+  uint8_t _val = (uint8_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(unsigned char), sizeof(unsigned char));\
+                      (offset) * sizeof(uint8_t), sizeof(uint8_t));\
 } while (0)
 #define GRN_INT16_SET_AT(ctx,obj,offset,val) do {\
-  signed short _val = (signed short)(val);\
+  int16_t _val = (int16_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(signed short), sizeof(signed short));\
+                      (offset) * sizeof(int16_t), sizeof(int16_t));\
 } while (0)
 #define GRN_UINT16_SET_AT(ctx,obj,offset,val) do { \
-  unsigned short _val = (unsigned short)(val);\
+  uint16_t _val = (uint16_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(unsigned short), sizeof(unsigned short));\
+                      (offset) * sizeof(uint16_t), sizeof(uint16_t));\
 } while (0)
 #define GRN_INT32_SET_AT(ctx,obj,offset,val) do {\
-  int _val = (int)(val);\
+  int32_t _val = (int32_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(int), sizeof(int));\
+                      (offset) * sizeof(int32_t), sizeof(int32_t));\
 } while (0)
 #define GRN_UINT32_SET_AT(ctx,obj,offset,val) do { \
-  unsigned int _val = (unsigned int)(val);\
+  uint32_t _val = (uint32_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(unsigned int), sizeof(unsigned int));\
+                      (offset) * sizeof(uint32_t), sizeof(uint32_t));\
 } while (0)
 #define GRN_INT64_SET_AT(ctx,obj,offset,val) do {\
-  long long int _val = (long long int)(val);\
+  int64_t _val = (int64_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(long long int), sizeof(long long int));\
+                      (offset) * sizeof(int64_t), sizeof(int64_t));\
 } while (0)
 #define GRN_UINT64_SET_AT(ctx,obj,offset,val) do {\
-  long long unsigned int _val = (long long unsigned int)(val);\
+  uint64_t _val = (uint64_t)(val);\
   grn_bulk_write_from((ctx), (obj), (char *)&_val,\
-                      (offset) * sizeof(long long unsigned int),\
-                      sizeof(long long unsigned int));\
+                      (offset) * sizeof(uint64_t),\
+                      sizeof(uint64_t));\
 } while (0)
 #define GRN_FLOAT_SET_AT(ctx,obj,offset,val) do {\
   double _val = (double)(val);\
@@ -1463,15 +1477,15 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
                       (offset) * sizeof(grn_obj *), sizeof(grn_obj *));\
 } while (0)
 
-#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)))
-#define GRN_INT16_VALUE(obj) (*((signed short *)GRN_BULK_HEAD(obj)))
-#define GRN_UINT16_VALUE(obj) (*((unsigned short *)GRN_BULK_HEAD(obj)))
-#define GRN_INT32_VALUE(obj) (*((int *)GRN_BULK_HEAD(obj)))
-#define GRN_UINT32_VALUE(obj) (*((unsigned int *)GRN_BULK_HEAD(obj)))
-#define GRN_INT64_VALUE(obj) (*((long long int *)GRN_BULK_HEAD(obj)))
-#define GRN_UINT64_VALUE(obj) (*((long long unsigned int *)GRN_BULK_HEAD(obj)))
+#define GRN_BOOL_VALUE(obj) (*((bool *)GRN_BULK_HEAD(obj)))
+#define GRN_INT8_VALUE(obj) (*((int8_t *)GRN_BULK_HEAD(obj)))
+#define GRN_UINT8_VALUE(obj) (*((uint8_t *)GRN_BULK_HEAD(obj)))
+#define GRN_INT16_VALUE(obj) (*((int16_t *)GRN_BULK_HEAD(obj)))
+#define GRN_UINT16_VALUE(obj) (*((uint16_t *)GRN_BULK_HEAD(obj)))
+#define GRN_INT32_VALUE(obj) (*((int32_t *)GRN_BULK_HEAD(obj)))
+#define GRN_UINT32_VALUE(obj) (*((uint32_t *)GRN_BULK_HEAD(obj)))
+#define GRN_INT64_VALUE(obj) (*((int64_t *)GRN_BULK_HEAD(obj)))
+#define GRN_UINT64_VALUE(obj) (*((uint64_t *)GRN_BULK_HEAD(obj)))
 #define GRN_FLOAT_VALUE(obj) (*((double *)GRN_BULK_HEAD(obj)))
 #define GRN_TIME_VALUE GRN_INT64_VALUE
 #define GRN_RECORD_VALUE(obj) (*((grn_id *)GRN_BULK_HEAD(obj)))
@@ -1482,52 +1496,52 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
   _longitude = _val->longitude;\
 } while (0)
 
-#define GRN_BOOL_VALUE_AT(obj,offset) (((unsigned char *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_INT8_VALUE_AT(obj,offset) (((signed char *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_UINT8_VALUE_AT(obj,offset) (((unsigned char *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_INT16_VALUE_AT(obj,offset) (((signed short *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_UINT16_VALUE_AT(obj,offset) (((unsigned short *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_INT32_VALUE_AT(obj,offset) (((int *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_UINT32_VALUE_AT(obj,offset) (((unsigned int *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_INT64_VALUE_AT(obj,offset) (((long long int *)GRN_BULK_HEAD(obj))[offset])
-#define GRN_UINT64_VALUE_AT(obj,offset) (((long long unsigned int *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_BOOL_VALUE_AT(obj,offset) (((bool *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_INT8_VALUE_AT(obj,offset) (((int8_t *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_UINT8_VALUE_AT(obj,offset) (((uint8_t *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_INT16_VALUE_AT(obj,offset) (((int16_t *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_UINT16_VALUE_AT(obj,offset) (((uint16_t *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_INT32_VALUE_AT(obj,offset) (((int32_t *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_UINT32_VALUE_AT(obj,offset) (((uint32_t *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_INT64_VALUE_AT(obj,offset) (((int64_t *)GRN_BULK_HEAD(obj))[offset])
+#define GRN_UINT64_VALUE_AT(obj,offset) (((uint64_t *)GRN_BULK_HEAD(obj))[offset])
 #define GRN_FLOAT_VALUE_AT(obj,offset) (((double *)GRN_BULK_HEAD(obj))[offset])
 #define GRN_TIME_VALUE_AT GRN_INT64_VALUE_AT
 #define GRN_RECORD_VALUE_AT(obj,offset) (((grn_id *)GRN_BULK_HEAD(obj))[offset])
 #define GRN_PTR_VALUE_AT(obj,offset) (((grn_obj **)GRN_BULK_HEAD(obj))[offset])
 
 #define GRN_BOOL_PUT(ctx,obj,val) do {\
-  unsigned char _val = (unsigned char)(val);\
-  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned char));\
+  bool _val = (bool)(val);\
+  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(bool));\
 } while (0)
 #define GRN_INT8_PUT(ctx,obj,val) do {\
-  signed char _val = (signed char)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(signed char));\
+  int8_t _val = (int8_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int8_t));\
 } while (0)
 #define GRN_UINT8_PUT(ctx,obj,val) do {\
-  unsigned char _val = (unsigned char)(val);\
-  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned char));\
+  uint8_t _val = (uint8_t)(val);\
+  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint8_t));\
 } while (0)
 #define GRN_INT16_PUT(ctx,obj,val) do {\
-  signed short _val = (signed short)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(signed short));\
+  int16_t _val = (int16_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int16_t));\
 } while (0)
 #define GRN_UINT16_PUT(ctx,obj,val) do {\
-  unsigned short _val = (unsigned short)(val);\
-  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned short));\
+  uint16_t _val = (uint16_t)(val);\
+  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint16_t));\
 } while (0)
 #define GRN_INT32_PUT(ctx,obj,val) do {\
-  int _val = (int)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int));\
+  int32_t _val = (int32_t)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int32_t));\
 } while (0)
 #define GRN_UINT32_PUT(ctx,obj,val) do {\
-  unsigned int _val = (unsigned int)(val);\
+  uint32_t _val = (uint32_t)(val);\
   grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int));\
 } while (0)
 #define GRN_INT64_PUT(ctx,obj,val) do {\
-  long long int _val = (long long int)(val);\
-  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(long long int));\
+  int64_t _val = (int64_t)(val);\
+  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int64_t));\
 } while (0)
 #define GRN_UINT64_PUT(ctx,obj,val) do {\
-  long long unsigned int _val = (long long unsigned int)(val);\
-  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(long long unsigned int));\
+  uint64_t _val = (uint64_t)(val);\
+  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint64_t));\
 } while (0)
 #define GRN_FLOAT_PUT(ctx,obj,val) do {\
   double _val = (double)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(double));\
@@ -1549,7 +1563,7 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
     value = default;\
   }\
 } while (0)
-#define GRN_BOOL_POP(obj, value) GRN_BULK_POP(obj, value, unsigned char, 0)
+#define GRN_BOOL_POP(obj, value) GRN_BULK_POP(obj, value, bool, 0)
 #define GRN_INT8_POP(obj, value) GRN_BULK_POP(obj, value, int8_t, 0)
 #define GRN_UINT8_POP(obj, value) GRN_BULK_POP(obj, value, uint8_t, 0)
 #define GRN_INT16_POP(obj, value) GRN_BULK_POP(obj, value, int16_t, 0)
@@ -1563,81 +1577,20 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
 #define GRN_RECORD_POP(obj, value) GRN_BULK_POP(obj, value, grn_id, GRN_ID_NIL)
 #define GRN_PTR_POP(obj, value) GRN_BULK_POP(obj, value, grn_obj *, NULL)
 
-/* grn_str: deprecated. use grn_string instead. */
-
-typedef struct {
-  const char *orig;
-  char *norm;
-  short *checks;
-  unsigned char *ctypes;
-  int flags;
-  unsigned int orig_blen;
-  unsigned int norm_blen;
-  unsigned int length;
-  grn_encoding encoding;
-} grn_str;
-
-#define GRN_STR_REMOVEBLANK            (0x01<<0)
-#define GRN_STR_WITH_CTYPES            (0x01<<1)
-#define GRN_STR_WITH_CHECKS            (0x01<<2)
-#define GRN_STR_NORMALIZE              GRN_OBJ_KEY_NORMALIZE
-
-GRN_API grn_str *grn_str_open(grn_ctx *ctx, const char *str, unsigned int str_len,
-                              int flags);
-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_TOKENIZED_DELIMITER (0x01<<3)
-
-#define GRN_NORMALIZER_AUTO ((grn_obj *)1)
-
-#define GRN_CHAR_BLANK 0x80
-#define GRN_CHAR_IS_BLANK(c) ((c) & (GRN_CHAR_BLANK))
-#define GRN_CHAR_TYPE(c) ((c) & 0x7f)
-
-typedef enum {
-  GRN_CHAR_NULL = 0,
-  GRN_CHAR_ALPHA,
-  GRN_CHAR_DIGIT,
-  GRN_CHAR_SYMBOL,
-  GRN_CHAR_HIRAGANA,
-  GRN_CHAR_KATAKANA,
-  GRN_CHAR_KANJI,
-  GRN_CHAR_OTHERS
-} grn_char_type;
-
-GRN_API grn_obj *grn_string_open(grn_ctx *ctx,
-                                 const char *string,
-                                 unsigned int length_in_bytes,
-                                 grn_obj *normalizer, int flags);
-GRN_API grn_rc grn_string_get_original(grn_ctx *ctx, grn_obj *string,
-                                       const char **original,
-                                       unsigned int *length_in_bytes);
-GRN_API int grn_string_get_flags(grn_ctx *ctx, grn_obj *string);
-GRN_API grn_rc grn_string_get_normalized(grn_ctx *ctx, grn_obj *string,
-                                         const char **normalized,
-                                         unsigned int *length_in_bytes,
-                                         unsigned int *n_characters);
-GRN_API grn_rc grn_string_set_normalized(grn_ctx *ctx, grn_obj *string,
-                                         char *normalized,
-                                         unsigned int length_in_bytes,
-                                         unsigned int n_characters);
-GRN_API const short *grn_string_get_checks(grn_ctx *ctx, grn_obj *string);
-GRN_API grn_rc grn_string_set_checks(grn_ctx *ctx,
-                                     grn_obj *string,
-                                     short *checks);
-GRN_API const unsigned char *grn_string_get_types(grn_ctx *ctx, grn_obj *string);
-GRN_API grn_rc grn_string_set_types(grn_ctx *ctx,
-                                    grn_obj *string,
-                                    unsigned char *types);
-GRN_API grn_encoding grn_string_get_encoding(grn_ctx *ctx, grn_obj *string);
-
-
-GRN_API int grn_charlen(grn_ctx *ctx, const char *str, const char *end);
+#define GRN_BULK_VECTOR_SIZE(obj, type) (GRN_BULK_VSIZE(obj) / sizeof(type))
+#define GRN_BOOL_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, bool)
+#define GRN_INT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int8_t)
+#define GRN_UINT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint8_t)
+#define GRN_INT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int16_t)
+#define GRN_UINT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint16_t)
+#define GRN_INT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int32_t)
+#define GRN_UINT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint32_t)
+#define GRN_INT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int64_t)
+#define GRN_UINT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint64_t)
+#define GRN_FLOAT_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, double)
+#define GRN_TIME_VECTOR_SIZE GRN_INT64_VECTOR_SIZE
+#define GRN_RECORD_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_id)
+#define GRN_PTR_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_obj *)
 
 GRN_API grn_rc grn_ctx_push(grn_ctx *ctx, grn_obj *obj);
 GRN_API grn_obj *grn_ctx_pop(grn_ctx *ctx);