Groonga
Loading...
Searching...
No Matches
Classes | Macros | Typedefs | Enumerations | Functions
groonga.h File Reference
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
Include dependency graph for groonga.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

union  grn_user_data
 
struct  _grn_ctx
 
struct  _grn_section
 
struct  _grn_obj_header
 
struct  _grn_obj
 
struct  grn_expr_var
 
struct  _grn_fuzzy_search_optarg
 
struct  _grn_match_info
 
struct  _grn_search_optarg
 
struct  _grn_index_datum
 
struct  _grn_snip_mapping
 
struct  _grn_logger_info
 
struct  _grn_logger
 
struct  _grn_query_logger
 
struct  _grn_ctx_info
 
struct  _grn_table_delete_optarg
 
struct  _grn_table_scan_hit
 
struct  grn_timeval
 

Macros

#define GRN_API
 
#define GRN_ID_NIL   (0x00)
 Means "does not exist".
 
#define GRN_ID_MAX   (0x3fffffff)
 
#define GRN_TRUE   true
 
#define GRN_FALSE   false
 
#define GRN_LZO_ERROR   GRN_LZ4_ERROR
 
#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_3
 
#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
 
#define GRN_QUERY_LOG_DEFAULT   GRN_QUERY_LOG_ALL
 
#define GRN_CTX_MSGSIZE   (0x80)
 
#define GRN_CTX_FIN   (0xff)
 
#define GRN_CTX_USER_DATA(ctx)   (&((ctx)->user_data))
 
#define GRN_CTX_USE_QL   (0x03)
 
#define GRN_CTX_BATCH_MODE   (0x04)
 
#define GRN_CTX_PER_DB   (0x08)
 
#define GRN_CTX_GET_ENCODING(ctx)   ((ctx)->encoding)
 
#define GRN_CTX_SET_ENCODING(ctx, enc)
 
#define GRN_OBJ_FLAGS_MASK   (0xffff)
 
#define GRN_OBJ_TABLE_TYPE_MASK   (0x07)
 
#define GRN_OBJ_TABLE_HASH_KEY   (0x00)
 
#define GRN_OBJ_TABLE_PAT_KEY   (0x01)
 
#define GRN_OBJ_TABLE_DAT_KEY   (0x02)
 
#define GRN_OBJ_TABLE_NO_KEY   (0x03)
 
#define GRN_OBJ_KEY_MASK   (0x07 << 3)
 Mask of GRN_OBJ_KEY_*
 
#define GRN_OBJ_KEY_UINT   (0x00 << 3)
 
#define GRN_OBJ_KEY_INT   (0x01 << 3)
 
#define GRN_OBJ_KEY_FLOAT   (0x02 << 3)
 
#define GRN_OBJ_KEY_GEO_POINT   (0x03 << 3)
 
#define GRN_OBJ_KEY_WITH_SIS   (0x01 << 6)
 
#define GRN_OBJ_KEY_NORMALIZE   (0x01 << 7)
 
#define GRN_OBJ_COLUMN_TYPE_MASK   (0x07)
 
#define GRN_OBJ_COLUMN_SCALAR   (0x00)
 
#define GRN_OBJ_COLUMN_VECTOR   (0x01)
 
#define GRN_OBJ_COLUMN_INDEX   (0x02)
 
#define GRN_OBJ_COMPRESS_MASK   (0x07 << 4)
 
#define GRN_OBJ_COMPRESS_NONE   (0x00 << 4)
 
#define GRN_OBJ_COMPRESS_ZLIB   (0x01 << 4)
 
#define GRN_OBJ_COMPRESS_LZ4   (0x02 << 4)
 
#define GRN_OBJ_COMPRESS_LZO   GRN_OBJ_COMPRESS_LZ4
 
#define GRN_OBJ_COMPRESS_ZSTD   (0x03 << 4)
 
#define GRN_OBJ_COMPRESS_OPENZL   (0x04 << 4)
 
#define GRN_OBJ_WITH_SECTION   (0x01 << 7)
 
#define GRN_OBJ_WITH_WEIGHT   (0x01 << 8)
 
#define GRN_OBJ_WITH_POSITION   (0x01 << 9)
 
#define GRN_OBJ_RING_BUFFER   (0x01 << 10)
 
#define GRN_OBJ_WEIGHT_BFLOAT16   (0x01 << 11)
 
#define GRN_OBJ_UNIT_MASK   (0x0f << 8)
 
#define GRN_OBJ_UNIT_DOCUMENT_NONE   (0x00 << 8)
 
#define GRN_OBJ_UNIT_DOCUMENT_SECTION   (0x01 << 8)
 
#define GRN_OBJ_UNIT_DOCUMENT_POSITION   (0x02 << 8)
 
#define GRN_OBJ_UNIT_SECTION_NONE   (0x03 << 8)
 
#define GRN_OBJ_UNIT_SECTION_POSITION   (0x04 << 8)
 
#define GRN_OBJ_UNIT_POSITION_NONE   (0x05 << 8)
 
#define GRN_OBJ_UNIT_USERDEF_DOCUMENT   (0x06 << 8)
 
#define GRN_OBJ_UNIT_USERDEF_SECTION   (0x07 << 8)
 
#define GRN_OBJ_UNIT_USERDEF_POSITION   (0x08 << 8)
 
#define GRN_OBJ_NO_SUBREC   (0x00 << 13)
 
#define GRN_OBJ_WITH_SUBREC   (0x01 << 13)
 
#define GRN_OBJ_KEY_VAR_SIZE   (0x01 << 14)
 
#define GRN_OBJ_TEMPORARY   (0x00 << 15)
 
#define GRN_OBJ_PERSISTENT   (0x01 << 15)
 
#define GRN_OBJ_KEY_LARGE   (0x01 << 16)
 
#define GRN_OBJ_INDEX_SMALL   (0x01 << 16)
 
#define GRN_OBJ_INDEX_MEDIUM   (0x01 << 17)
 
#define GRN_OBJ_INDEX_LARGE   (0x01 << 18)
 
#define GRN_OBJ_WEIGHT_FLOAT32   (0x01 << 19)
 
#define GRN_OBJ_MISSING_MASK   (0x03 << 20)
 
#define GRN_OBJ_MISSING_ADD   (0x00 << 20)
 
#define GRN_OBJ_MISSING_IGNORE   (0x01 << 20)
 
#define GRN_OBJ_MISSING_NIL   (0x02 << 20)
 
#define GRN_OBJ_INVALID_MASK   (0x03 << 22)
 
#define GRN_OBJ_INVALID_ERROR   (0x00 << 22)
 
#define GRN_OBJ_INVALID_WARN   (0x01 << 22)
 
#define GRN_OBJ_INVALID_IGNORE   (0x02 << 22)
 
#define GRN_OBJ_COMPRESS_FILTER_SHUFFLE   (0x01 << 24)
 
#define GRN_OBJ_COMPRESS_FILTER_BYTE_DELTA   (0x01 << 25)
 
#define GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_1BYTE   (0x01 << 26)
 
#define GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_2BYTES   (0x01 << 27)
 
#define GRN_OBJ_VISIBLE   ((uint32_t)(0x00 << 31))
 
#define GRN_OBJ_INVISIBLE   ((uint32_t)(0x01 << 31))
 
#define GRN_VOID   (0x00)
 
#define GRN_BULK   (0x02)
 
#define GRN_PTR   (0x03)
 
#define GRN_UVECTOR   (0x04)
 
#define GRN_PVECTOR   (0x05) /* vector of grn_obj* */
 
#define GRN_VECTOR   (0x06) /* vector of arbitrary data */
 
#define GRN_MSG   (0x07)
 
#define GRN_QUERY   (0x08)
 
#define GRN_ACCESSOR   (0x09)
 
#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)
 
#define GRN_CURSOR_TABLE_NO_KEY   (0x13)
 
#define GRN_CURSOR_COLUMN_INDEX   (0x18)
 
#define GRN_CURSOR_COLUMN_GEO_INDEX   (0x1a)
 
#define GRN_CURSOR_CONFIG   (0x1f)
 
#define GRN_TYPE   (0x20)
 
#define GRN_PROC   (0x21)
 
#define GRN_EXPR   (0x22)
 
#define GRN_TABLE_HASH_KEY   (0x30)
 
#define GRN_TABLE_PAT_KEY   (0x31)
 
#define GRN_TABLE_DAT_KEY   (0x32)
 
#define GRN_TABLE_NO_KEY   (0x33)
 
#define GRN_DB   (0x37)
 
#define GRN_COLUMN_FIX_SIZE   (0x40)
 
#define GRN_COLUMN_VAR_SIZE   (0x41)
 
#define GRN_COLUMN_INDEX   (0x48)
 
#define GRN_HTTP_CLIENT   (0x50)
 
#define GRN_OBJ_REFER   (0x01 << 0)
 
#define GRN_OBJ_OUTPLACE   (0x01 << 1)
 
#define GRN_OBJ_OWN   (0x01 << 5)
 
#define GRN_OBJ_INIT(obj, obj_type, obj_flags, obj_domain)
 
#define GRN_OBJ_FIN(ctx, obj)   (grn_obj_close((ctx), (obj)))
 
#define GRN_OP_BUT   GRN_OP_AND_NOT
 
#define GRN_OP_NEAR2   GRN_OP_NEAR_NO_OFFSET
 
#define GRN_INFO_SUPPORT_LZO   GRN_INFO_SUPPORT_LZ4
 
#define GRN_INFO_SUPPORT_ARROW   GRN_INFO_SUPPORT_APACHE_ARROW
 
#define GRN_COLUMN_EACH(ctx, column, id, value, block)
 
#define GRN_OBJ_SET_MASK   (0x07)
 
#define GRN_OBJ_SET   (0x01)
 Replace the value of the record/column with the specified value.
 
#define GRN_OBJ_INCR   (0x02)
 Add the specified value to the record/column value.
 
#define GRN_OBJ_DECR   (0x03)
 Subtract the specified value from the record/column value.
 
#define GRN_OBJ_APPEND   (0x04)
 Append the specified value to the column value.
 
#define GRN_OBJ_PREPEND   (0x05)
 Prepend the specified value to the column value.
 
#define GRN_OBJ_GET   (0x01 << 4)
 
#define GRN_OBJ_COMPARE   (0x01 << 5)
 
#define GRN_OBJ_LOCK   (0x01 << 6)
 
#define GRN_OBJ_UNLOCK   (0x01 << 7)
 
#define GRN_OBJ_REMOVE_DEPENDENT   (0x01 << 0)
 
#define GRN_OBJ_REMOVE_ENSURE   (0x01 << 1)
 
#define GRN_OBJ_GET_DOMAIN(obj)    ((obj)->header.type == GRN_TABLE_NO_KEY ? GRN_ID_NIL : (obj)->header.domain)
 
#define GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION   (0x01 << 0)
 
#define GRN_TABLE_FUZZY_SEARCH_USE_PREFIX_LENGTH   (0x01 << 1)
 
#define GRN_TABLE_FUZZY_SEARCH_USE_MAX_DISTANCE_RATIO   (0x01 << 2)
 
#define GRN_TABLE_FUZZY_SEARCH_SKIP_TOKENIZE   (0x01 << 3)
 
#define GRN_MATCH_INFO_GET_MIN_RECORD_ID   (0x01)
 
#define GRN_MATCH_INFO_ONLY_SKIP_TOKEN   (0x02)
 
#define GRN_N_HOOK_ENTRIES   5 /* (GRN_HOOK_SELECT + 1) */
 
#define GRN_QUERY_AND   '+'
 
#define GRN_QUERY_AND_NOT   '-'
 
#define GRN_QUERY_ADJ_INC   '>'
 
#define GRN_QUERY_ADJ_DEC   '<'
 
#define GRN_QUERY_ADJ_NEG   '~'
 
#define GRN_QUERY_PREFIX   '*'
 
#define GRN_QUERY_PARENL   '('
 
#define GRN_QUERY_PARENR   ')'
 
#define GRN_QUERY_QUOTEL   '"'
 
#define GRN_QUERY_QUOTER   '"'
 
#define GRN_QUERY_ESCAPE   '\\'
 
#define GRN_QUERY_COLUMN   ':'
 
#define GRN_SNIP_NORMALIZE   (0x01 << 0)
 
#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)
 
#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_CONTEXT_ID   (0x01 << 6)
 
#define GRN_LOG_CTX_ID   GRN_LOG_CONTEXT_ID
 
#define GRN_LOG_ALL
 
#define GRN_LOG_DEFAULT   (GRN_LOG_TIME | GRN_LOG_MESSAGE)
 
#define GRN_ATTRIBUTE_PRINTF(fmt_pos)
 
#define GRN_ATTRIBUTE_ALLOC_SIZE(size)
 
#define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size)
 
#define GRN_LOG_DEFAULT_LEVEL   GRN_LOG_NOTICE
 
#define GRN_LOG(ctx, level, ...)
 
#define GRN_SLOW_LOG_PUSH(ctx, level)
 
#define GRN_SLOW_LOG_POP_BEGIN(ctx, level, elapsed_time)
 
#define GRN_SLOW_LOG_POP_END(ctx)
 
#define GRN_QUERY_LOG(ctx, flag, mark, format, ...)
 
#define GRN_BULK_BUFSIZE   (sizeof(grn_obj) - sizeof(grn_obj_header))
 
#define GRN_BULK_BUFSIZE_MAX   0x1f
 
#define GRN_BULK_SIZE_IN_FLAGS(flags)   (size_t)((flags) & GRN_BULK_BUFSIZE_MAX)
 
#define GRN_BULK_OUTP(bulk)   ((bulk)->header.impl_flags & GRN_OBJ_OUTPLACE)
 
#define GRN_BULK_REWIND(bulk)
 
#define GRN_BULK_SET_CURR(buf, p)
 
#define GRN_BULK_INCR_LEN(bulk, len)
 
#define GRN_BULK_WSIZE(bulk)
 
#define GRN_BULK_REST(bulk)
 
#define GRN_BULK_VSIZE(bulk)
 
#define GRN_BULK_EMPTYP(bulk)
 
#define GRN_BULK_HEAD(bulk)    (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.head) : (char *)&((bulk)->u.b.head))
 
#define GRN_BULK_CURR(bulk)
 
#define GRN_BULK_TAIL(bulk)    (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.tail) : (char *)&((bulk)[1]))
 
#define GRN_OBJ_DO_SHALLOW_COPY   (GRN_OBJ_REFER | GRN_OBJ_OUTPLACE)
 
#define GRN_OBJ_VECTOR   (0x01 << 7)
 
#define GRN_OBJ_MUTABLE(obj)   ((obj) && (obj)->header.type <= GRN_VECTOR)
 
#define GRN_VALUE_FIX_SIZE_INIT(obj, flags, domain)
 
#define GRN_VALUE_VAR_SIZE_INIT(obj, flags, domain)
 
#define GRN_VOID_INIT(obj)   GRN_OBJ_INIT((obj), GRN_VOID, 0, GRN_DB_VOID)
 
#define GRN_TEXT_INIT(obj, flags)    GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_TEXT)
 
#define GRN_SHORT_TEXT_INIT(obj, flags)    GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_TEXT)
 
#define GRN_LONG_TEXT_INIT(obj, flags)    GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_TEXT)
 
#define GRN_TEXT_SET_REF(obj, str, len)
 
#define GRN_TEXT_SET(ctx, obj, str, len)
 
#define GRN_TEXT_PUT(ctx, obj, str, len)    grn_bulk_write((ctx), (obj), (const char *)(str), (unsigned int)(len))
 
#define GRN_TEXT_PUTC(ctx, obj, c)
 
#define GRN_TEXT_PUTS(ctx, obj, str)    GRN_TEXT_PUT((ctx), (obj), (str), strlen(str))
 
#define GRN_TEXT_SETS(ctx, obj, str)    GRN_TEXT_SET((ctx), (obj), (str), strlen(str))
 
#define GRN_TEXT_VALUE(obj)   GRN_BULK_HEAD(obj)
 
#define GRN_TEXT_LEN(obj)   GRN_BULK_VSIZE(obj)
 
#define GRN_TEXT_EQUAL_CSTRING(bulk, string)
 
#define GRN_BINARY_INIT(obj, flags)    GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_BINARY)
 
#define GRN_SHORT_BINARY_INIT(obj, flags)    GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_BINARY)
 
#define GRN_LONG_BINARY_INIT(obj, flags)    GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_BINARY)
 
#define GRN_BINARY_SET_REF(obj, data, len)
 
#define GRN_BINARY_SET(ctx, obj, data, len)
 
#define GRN_BINARY_PUT(ctx, obj, data, len)    grn_bulk_write((ctx), (obj), (const char *)(data), (unsigned int)(len))
 
#define GRN_BINARY_VALUE(obj)   ((const uint8_t *)GRN_BULK_HEAD(obj))
 
#define GRN_BINARY_LEN(obj)   GRN_BULK_VSIZE(obj)
 
#define GRN_JSON_INIT(obj, flags)    GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_JSON)
 
#define GRN_JSON_SET_REF(obj, data, len)
 
#define GRN_JSON_SET(ctx, obj, data, len)
 
#define GRN_JSON_VALUE(obj)   ((const uint8_t *)GRN_BULK_HEAD(obj))
 
#define GRN_JSON_LEN(obj)   GRN_BULK_VSIZE(obj)
 
#define GRN_BOOL_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BOOL)
 
#define GRN_INT8_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT8)
 
#define GRN_UINT8_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT8)
 
#define GRN_INT16_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT16)
 
#define GRN_UINT16_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT16)
 
#define GRN_INT32_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT32)
 
#define GRN_UINT32_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT32)
 
#define GRN_INT64_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT64)
 
#define GRN_UINT64_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT64)
 
#define GRN_BFLOAT16_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BFLOAT16)
 
#define GRN_FLOAT32_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT32)
 
#define GRN_FLOAT_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT)
 
#define GRN_TIME_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TIME)
 
#define GRN_RECORD_INIT   GRN_VALUE_FIX_SIZE_INIT
 
#define GRN_PTR_INIT(obj, flags, domain)
 
#define GRN_TOKYO_GEO_POINT_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TOKYO_GEO_POINT)
 
#define GRN_WGS84_GEO_POINT_INIT(obj, flags)    GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_WGS84_GEO_POINT)
 
#define GRN_BOOL_SET(ctx, obj, val)
 
#define GRN_INT8_SET(ctx, obj, val)
 
#define GRN_UINT8_SET(ctx, obj, val)
 
#define GRN_INT16_SET(ctx, obj, val)
 
#define GRN_UINT16_SET(ctx, obj, val)
 
#define GRN_INT32_SET(ctx, obj, val)
 
#define GRN_UINT32_SET(ctx, obj, val)
 
#define GRN_INT64_SET(ctx, obj, val)
 
#define GRN_UINT64_SET(ctx, obj, val)
 
#define GRN_BFLOAT16_SET(ctx, obj, val)
 
#define GRN_FLOAT32_SET(ctx, obj, val)
 
#define GRN_FLOAT_SET(ctx, obj, val)
 
#define GRN_TIME_SET   GRN_INT64_SET
 
#define GRN_RECORD_SET(ctx, obj, val)
 
#define GRN_PTR_SET(ctx, obj, val)
 
#define GRN_GEO_DEGREE2MSEC(degree)    ((int32_t)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))
 
#define GRN_GEO_MSEC2DEGREE(msec)   ((((int32_t)(msec)) / 3600.0) * 0.001)
 
#define GRN_GEO_RESOLUTION   3600000
 
#define GRN_GEO_M_PI   3.14159265358979323846
 
#define GRN_GEO_RADIAN2MSEC(radian)    ((int32_t)(((GRN_GEO_RESOLUTION * 180) / GRN_GEO_M_PI) * (radian)))
 
#define GRN_GEO_MSEC2RADIAN(msec)    ((GRN_GEO_M_PI / (GRN_GEO_RESOLUTION * 180)) * (msec))
 
#define GRN_GEO_POINT_SET(ctx, obj, _latitude, _longitude)
 
#define GRN_BOOL_SET_AT(ctx, obj, offset, val)
 
#define GRN_INT8_SET_AT(ctx, obj, offset, val)
 
#define GRN_UINT8_SET_AT(ctx, obj, offset, val)
 
#define GRN_INT16_SET_AT(ctx, obj, offset, val)
 
#define GRN_UINT16_SET_AT(ctx, obj, offset, val)
 
#define GRN_INT32_SET_AT(ctx, obj, offset, val)
 
#define GRN_UINT32_SET_AT(ctx, obj, offset, val)
 
#define GRN_INT64_SET_AT(ctx, obj, offset, val)
 
#define GRN_UINT64_SET_AT(ctx, obj, offset, val)
 
#define GRN_BFLOAT16_SET_AT(ctx, obj, offset, val)
 
#define GRN_FLOAT32_SET_AT(ctx, obj, offset, val)
 
#define GRN_FLOAT_SET_AT(ctx, obj, offset, val)
 
#define GRN_TIME_SET_AT   GRN_INT64_SET_AT
 
#define GRN_RECORD_SET_AT(ctx, obj, offset, val)
 
#define GRN_PTR_SET_AT(ctx, obj, offset, val)
 
#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_BFLOAT16_VALUE(obj)   (*((grn_bfloat16 *)GRN_BULK_HEAD(obj)))
 
#define GRN_FLOAT32_VALUE(obj)   (*((float *)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)))
 
#define GRN_PTR_VALUE(obj)   (*((grn_obj **)GRN_BULK_HEAD(obj)))
 
#define GRN_GEO_POINT_VALUE_RAW(obj)   (grn_geo_point *)GRN_BULK_HEAD(obj)
 
#define GRN_GEO_POINT_VALUE(obj, _latitude, _longitude)
 
#define GRN_GEO_POINT_VALUE_RADIAN(obj, _latitude, _longitude)
 
#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_BFLOAT16_VALUE_AT(obj, offset)    (((grn_bfloat16 *)GRN_BULK_HEAD(obj))[offset])
 
#define GRN_FLOAT32_VALUE_AT(obj, offset)    (((float *)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)
 
#define GRN_INT8_PUT(ctx, obj, val)
 
#define GRN_UINT8_PUT(ctx, obj, val)
 
#define GRN_INT16_PUT(ctx, obj, val)
 
#define GRN_UINT16_PUT(ctx, obj, val)
 
#define GRN_INT32_PUT(ctx, obj, val)
 
#define GRN_UINT32_PUT(ctx, obj, val)
 
#define GRN_INT64_PUT(ctx, obj, val)
 
#define GRN_UINT64_PUT(ctx, obj, val)
 
#define GRN_BFLOAT16_PUT(ctx, obj, val)
 
#define GRN_FLOAT32_PUT(ctx, obj, val)
 
#define GRN_FLOAT_PUT(ctx, obj, val)
 
#define GRN_TIME_PUT   GRN_INT64_PUT
 
#define GRN_RECORD_PUT(ctx, obj, val)
 
#define GRN_PTR_PUT(ctx, obj, val)
 
#define GRN_BULK_POP(obj, value, type, default)
 
#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)
 
#define GRN_UINT16_POP(obj, value)   GRN_BULK_POP(obj, value, uint16_t, 0)
 
#define GRN_INT32_POP(obj, value)   GRN_BULK_POP(obj, value, int32_t, 0)
 
#define GRN_UINT32_POP(obj, value)   GRN_BULK_POP(obj, value, uint32_t, 0)
 
#define GRN_INT64_POP(obj, value)   GRN_BULK_POP(obj, value, int64_t, 0)
 
#define GRN_UINT64_POP(obj, value)   GRN_BULK_POP(obj, value, uint64_t, 0)
 
#define GRN_BFLOAT16_POP(obj, value)   GRN_BULK_POP(obj, value, grn_bfloat16, 0.0)
 
#define GRN_FLOAT32_POP(obj, value)   GRN_BULK_POP(obj, value, float, 0.0)
 
#define GRN_FLOAT_POP(obj, value)   GRN_BULK_POP(obj, value, double, 0.0)
 
#define GRN_TIME_POP   GRN_INT64_POP
 
#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)
 
#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_BFLOAT16_VECTOR_SIZE(obj)   GRN_BULK_VECTOR_SIZE(obj, grn_bfloat16)
 
#define GRN_FLOAT32_VECTOR_SIZE(obj)   GRN_BULK_VECTOR_SIZE(obj, float)
 
#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 *)
 
#define GRN_CTX_MORE   (0x01 << 0)
 
#define GRN_CTX_TAIL   (0x01 << 1)
 
#define GRN_CTX_HEAD   (0x01 << 2)
 
#define GRN_CTX_QUIET   (0x01 << 3)
 
#define GRN_CTX_QUIT   (0x01 << 4)
 

Typedefs

typedef uint32_t grn_id
 
typedef bool grn_bool
 
typedef struct _grn_obj grn_obj
 The generic Groonga object type.
 
typedef struct _grn_ctx grn_ctx
 grn_ctx is the most important object.
 
typedef void(* grn_close_func) (grn_ctx *ctx, void *data)
 
typedef grn_obj * grn_proc_func(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
 
typedef uint16_t grn_obj_flags
 
typedef uint32_t grn_table_flags
 
typedef uint32_t grn_column_flags
 
typedef struct _grn_section grn_section
 
typedef struct _grn_obj_header grn_obj_header
 
typedef grn_rc(* grn_plugin_func) (grn_ctx *ctx)
 
typedef grn_obj grn_table_cursor
 
typedef struct _grn_fuzzy_search_optarg grn_fuzzy_search_optarg
 
typedef struct _grn_match_info grn_match_info
 
typedef struct _grn_search_optarg grn_search_optarg
 
typedef struct _grn_index_datum grn_index_datum
 
typedef struct _grn_snip_mapping grn_snip_mapping
 
typedef struct _grn_logger_info grn_logger_info
 
typedef struct _grn_logger grn_logger
 
typedef struct _grn_query_logger grn_query_logger
 
typedef void(* grn_recv_handler_func) (grn_ctx *ctx, int flags, void *user_data)
 
typedef struct _grn_ctx_info grn_ctx_info
 
typedef struct _grn_table_delete_optarg grn_table_delete_optarg
 

Enumerations

enum  grn_rc {
  GRN_SUCCESS = 0 , GRN_END_OF_DATA = 1 , GRN_UNKNOWN_ERROR = -1 , GRN_OPERATION_NOT_PERMITTED = -2 ,
  GRN_NO_SUCH_FILE_OR_DIRECTORY = -3 , GRN_NO_SUCH_PROCESS = -4 , GRN_INTERRUPTED_FUNCTION_CALL = -5 , GRN_INPUT_OUTPUT_ERROR = -6 ,
  GRN_NO_SUCH_DEVICE_OR_ADDRESS = -7 , GRN_ARG_LIST_TOO_LONG = -8 , GRN_EXEC_FORMAT_ERROR = -9 , GRN_BAD_FILE_DESCRIPTOR = -10 ,
  GRN_NO_CHILD_PROCESSES = -11 , GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = -12 , GRN_NOT_ENOUGH_SPACE = -13 , GRN_PERMISSION_DENIED = -14 ,
  GRN_BAD_ADDRESS = -15 , GRN_RESOURCE_BUSY = -16 , GRN_FILE_EXISTS = -17 , GRN_IMPROPER_LINK = -18 ,
  GRN_NO_SUCH_DEVICE = -19 , GRN_NOT_A_DIRECTORY = -20 , GRN_IS_A_DIRECTORY = -21 , GRN_INVALID_ARGUMENT = -22 ,
  GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = -23 , GRN_TOO_MANY_OPEN_FILES = -24 , GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = -25 , GRN_FILE_TOO_LARGE = -26 ,
  GRN_NO_SPACE_LEFT_ON_DEVICE = -27 , GRN_INVALID_SEEK = -28 , GRN_READ_ONLY_FILE_SYSTEM = -29 , GRN_TOO_MANY_LINKS = -30 ,
  GRN_BROKEN_PIPE = -31 , GRN_DOMAIN_ERROR = -32 , GRN_RESULT_TOO_LARGE = -33 , GRN_RESOURCE_DEADLOCK_AVOIDED = -34 ,
  GRN_NO_MEMORY_AVAILABLE = -35 , GRN_FILENAME_TOO_LONG = -36 , GRN_NO_LOCKS_AVAILABLE = -37 , GRN_FUNCTION_NOT_IMPLEMENTED = -38 ,
  GRN_DIRECTORY_NOT_EMPTY = -39 , GRN_ILLEGAL_BYTE_SEQUENCE = -40 , GRN_SOCKET_NOT_INITIALIZED = -41 , GRN_OPERATION_WOULD_BLOCK = -42 ,
  GRN_ADDRESS_IS_NOT_AVAILABLE = -43 , GRN_NETWORK_IS_DOWN = -44 , GRN_NO_BUFFER = -45 , GRN_SOCKET_IS_ALREADY_CONNECTED = -46 ,
  GRN_SOCKET_IS_NOT_CONNECTED = -47 , GRN_SOCKET_IS_ALREADY_SHUTDOWNED = -48 , GRN_OPERATION_TIMEOUT = -49 , GRN_CONNECTION_REFUSED = -50 ,
  GRN_RANGE_ERROR = -51 , GRN_TOKENIZER_ERROR = -52 , GRN_FILE_CORRUPT = -53 , GRN_INVALID_FORMAT = -54 ,
  GRN_OBJECT_CORRUPT = -55 , GRN_TOO_MANY_SYMBOLIC_LINKS = -56 , GRN_NOT_SOCKET = -57 , GRN_OPERATION_NOT_SUPPORTED = -58 ,
  GRN_ADDRESS_IS_IN_USE = -59 , GRN_ZLIB_ERROR = -60 , GRN_LZ4_ERROR = -61 , GRN_STACK_OVER_FLOW = -62 ,
  GRN_SYNTAX_ERROR = -63 , GRN_RETRY_MAX = -64 , GRN_INCOMPATIBLE_FILE_FORMAT = -65 , GRN_UPDATE_NOT_ALLOWED = -66 ,
  GRN_TOO_SMALL_OFFSET = -67 , GRN_TOO_LARGE_OFFSET = -68 , GRN_TOO_SMALL_LIMIT = -69 , GRN_CAS_ERROR = -70 ,
  GRN_UNSUPPORTED_COMMAND_VERSION = -71 , GRN_NORMALIZER_ERROR = -72 , GRN_TOKEN_FILTER_ERROR = -73 , GRN_COMMAND_ERROR = -74 ,
  GRN_PLUGIN_ERROR = -75 , GRN_SCORER_ERROR = -76 , GRN_CANCEL = -77 , GRN_WINDOW_FUNCTION_ERROR = -78 ,
  GRN_ZSTD_ERROR = -79 , GRN_CONNECTION_RESET = -80 , GRN_BLOSC_ERROR = -81 , GRN_OPENZL_ERROR = -82 ,
  GRN_EXTRACTOR_ERROR = -83
}
 
enum  grn_encoding {
  GRN_ENC_DEFAULT = 0 , GRN_ENC_NONE , GRN_ENC_EUC_JP , GRN_ENC_UTF8 ,
  GRN_ENC_SJIS , GRN_ENC_LATIN1 , GRN_ENC_KOI8R
}
 
enum  grn_command_version { GRN_COMMAND_VERSION_DEFAULT = 0 , GRN_COMMAND_VERSION_1 , GRN_COMMAND_VERSION_2 , GRN_COMMAND_VERSION_3 }
 
enum  grn_log_level {
  GRN_LOG_NONE = 0 , GRN_LOG_EMERG , GRN_LOG_ALERT , GRN_LOG_CRIT ,
  GRN_LOG_ERROR , GRN_LOG_WARNING , GRN_LOG_NOTICE , GRN_LOG_INFO ,
  GRN_LOG_DEBUG , GRN_LOG_DUMP
}
 
enum  grn_content_type {
  GRN_CONTENT_NONE = 0 , GRN_CONTENT_TSV , GRN_CONTENT_JSON , GRN_CONTENT_XML ,
  GRN_CONTENT_MSGPACK , GRN_CONTENT_GROONGA_COMMAND_LIST , GRN_CONTENT_APACHE_ARROW
}
 The input/output content format. More...
 
enum  grn_builtin_type {
  GRN_DB_VOID = 0 , GRN_DB_DB , GRN_DB_OBJECT , GRN_DB_BOOL ,
  GRN_DB_INT8 , GRN_DB_UINT8 , GRN_DB_INT16 , GRN_DB_UINT16 ,
  GRN_DB_INT32 , GRN_DB_UINT32 , GRN_DB_INT64 , GRN_DB_UINT64 ,
  GRN_DB_FLOAT , GRN_DB_TIME , GRN_DB_SHORT_TEXT , GRN_DB_TEXT ,
  GRN_DB_LONG_TEXT , GRN_DB_TOKYO_GEO_POINT , GRN_DB_WGS84_GEO_POINT , GRN_DB_FLOAT32 ,
  GRN_DB_BFLOAT16 , GRN_DB_SHORT_BINARY , GRN_DB_BINARY , GRN_DB_LONG_BINARY ,
  GRN_DB_JSON
}
 
enum  grn_builtin_tokenizer {
  GRN_DB_MECAB = 64 , GRN_DB_DELIMIT , GRN_DB_UNIGRAM , GRN_DB_BIGRAM ,
  GRN_DB_TRIGRAM
}
 
enum  grn_operator {
  GRN_OP_PUSH = 0 , GRN_OP_POP , GRN_OP_NOP , GRN_OP_CALL ,
  GRN_OP_INTERN , GRN_OP_GET_REF , GRN_OP_GET_VALUE , GRN_OP_AND ,
  GRN_OP_AND_NOT , GRN_OP_OR , GRN_OP_ASSIGN , GRN_OP_STAR_ASSIGN ,
  GRN_OP_SLASH_ASSIGN , GRN_OP_MOD_ASSIGN , GRN_OP_PLUS_ASSIGN , GRN_OP_MINUS_ASSIGN ,
  GRN_OP_SHIFTL_ASSIGN , GRN_OP_SHIFTR_ASSIGN , GRN_OP_SHIFTRR_ASSIGN , GRN_OP_AND_ASSIGN ,
  GRN_OP_XOR_ASSIGN , GRN_OP_OR_ASSIGN , GRN_OP_JUMP , GRN_OP_CJUMP ,
  GRN_OP_COMMA , GRN_OP_BITWISE_OR , GRN_OP_BITWISE_XOR , GRN_OP_BITWISE_AND ,
  GRN_OP_BITWISE_NOT , GRN_OP_EQUAL , GRN_OP_NOT_EQUAL , GRN_OP_LESS ,
  GRN_OP_GREATER , GRN_OP_LESS_EQUAL , GRN_OP_GREATER_EQUAL , GRN_OP_IN ,
  GRN_OP_MATCH , GRN_OP_NEAR , GRN_OP_NEAR_NO_OFFSET , GRN_OP_SIMILAR ,
  GRN_OP_TERM_EXTRACT , GRN_OP_SHIFTL , GRN_OP_SHIFTR , GRN_OP_SHIFTRR ,
  GRN_OP_PLUS , GRN_OP_MINUS , GRN_OP_STAR , GRN_OP_SLASH ,
  GRN_OP_MOD , GRN_OP_DELETE , GRN_OP_INCR , GRN_OP_DECR ,
  GRN_OP_INCR_POST , GRN_OP_DECR_POST , GRN_OP_NOT , GRN_OP_ADJUST ,
  GRN_OP_EXACT , GRN_OP_LCP , GRN_OP_PARTIAL , GRN_OP_UNSPLIT ,
  GRN_OP_PREFIX , GRN_OP_SUFFIX , GRN_OP_GEO_DISTANCE1 , GRN_OP_GEO_DISTANCE2 ,
  GRN_OP_GEO_DISTANCE3 , GRN_OP_GEO_DISTANCE4 , GRN_OP_GEO_WITHINP5 , GRN_OP_GEO_WITHINP6 ,
  GRN_OP_GEO_WITHINP8 , GRN_OP_OBJ_SEARCH , GRN_OP_EXPR_GET_VAR , GRN_OP_TABLE_CREATE ,
  GRN_OP_TABLE_SELECT , GRN_OP_TABLE_SORT , GRN_OP_TABLE_GROUP , GRN_OP_JSON_PUT ,
  GRN_OP_GET_MEMBER , GRN_OP_REGEXP , GRN_OP_FUZZY , GRN_OP_QUORUM ,
  GRN_OP_NEAR_PHRASE , GRN_OP_ORDERED_NEAR_PHRASE , GRN_OP_NEAR_PHRASE_PRODUCT , GRN_OP_ORDERED_NEAR_PHRASE_PRODUCT
}
 
enum  grn_info_type {
  GRN_INFO_ENCODING = 0 , GRN_INFO_SOURCE , GRN_INFO_DEFAULT_TOKENIZER , GRN_INFO_ELEMENT_SIZE ,
  GRN_INFO_CURR_MAX , GRN_INFO_MAX_ELEMENT_SIZE , GRN_INFO_SEG_SIZE , GRN_INFO_CHUNK_SIZE ,
  GRN_INFO_MAX_SECTION , GRN_INFO_HOOK_LOCAL_DATA , GRN_INFO_ELEMENT_A , GRN_INFO_ELEMENT_CHUNK ,
  GRN_INFO_ELEMENT_CHUNK_SIZE , GRN_INFO_ELEMENT_BUFFER_FREE , GRN_INFO_ELEMENT_NTERMS , GRN_INFO_ELEMENT_NTERMS_VOID ,
  GRN_INFO_ELEMENT_SIZE_IN_CHUNK , GRN_INFO_ELEMENT_POS_IN_CHUNK , GRN_INFO_ELEMENT_SIZE_IN_BUFFER , GRN_INFO_ELEMENT_POS_IN_BUFFER ,
  GRN_INFO_ELEMENT_ESTIMATE_SIZE , GRN_INFO_NGRAM_UNIT_SIZE , GRN_INFO_PARTIAL_MATCH_THRESHOLD , GRN_INFO_II_SPLIT_THRESHOLD ,
  GRN_INFO_SUPPORT_ZLIB , GRN_INFO_SUPPORT_LZ4 , GRN_INFO_NORMALIZER , GRN_INFO_TOKEN_FILTERS ,
  GRN_INFO_SUPPORT_ZSTD , GRN_INFO_SUPPORT_APACHE_ARROW , GRN_INFO_NORMALIZERS , GRN_INFO_GENERATOR ,
  GRN_INFO_SUPPORT_LLAMA_CPP , GRN_INFO_SUPPORT_FAISS , GRN_INFO_EXTRACTORS
}
 
enum  grn_hook_entry {
  GRN_HOOK_SET = 0 , GRN_HOOK_GET , GRN_HOOK_INSERT , GRN_HOOK_DELETE ,
  GRN_HOOK_SELECT
}
 

Functions

GRN_API grn_rc grn_init (void)
 
GRN_API grn_rc grn_fin (void)
 
GRN_API const char * grn_get_global_error_message (void)
 
GRN_API const char * grn_log_level_to_string (grn_log_level level)
 
GRN_API bool grn_log_level_parse (const char *string, grn_log_level *level)
 
GRN_API grn_rc grn_ctx_init (grn_ctx *ctx, int flags)
 Initialize the context.
 
GRN_API grn_rc grn_ctx_fin (grn_ctx *ctx)
 Finish the context.
 
GRN_API grn_ctx * grn_ctx_open (int flags)
 Open the context.
 
GRN_API grn_rc grn_ctx_close (grn_ctx *ctx)
 Close the context.
 
GRN_API grn_rc grn_ctx_set_finalizer (grn_ctx *ctx, grn_proc_func *func)
 Set the callback function to be called when the context is finished.
 
GRN_API grn_rc grn_ctx_push_temporary_open_space (grn_ctx *ctx)
 
GRN_API grn_rc grn_ctx_pop_temporary_open_space (grn_ctx *ctx)
 
GRN_API grn_rc grn_ctx_merge_temporary_open_space (grn_ctx *ctx)
 
GRN_API grn_encoding grn_get_default_encoding (void)
 
GRN_API grn_rc grn_set_default_encoding (grn_encoding encoding)
 Set the default encoding.
 
GRN_API const char * grn_get_version (void)
 
GRN_API uint32_t grn_get_version_major (void)
 
GRN_API uint32_t grn_get_version_minor (void)
 
GRN_API uint32_t grn_get_version_micro (void)
 
GRN_API const char * grn_get_package (void)
 
GRN_API const char * grn_get_package_label (void)
 
GRN_API grn_command_version grn_get_default_command_version (void)
 
GRN_API grn_rc grn_set_default_command_version (grn_command_version version)
 Set default command version.
 
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)
 Set command version for this context.
 
GRN_API int64_t grn_ctx_get_match_escalation_threshold (grn_ctx *ctx)
 
GRN_API grn_rc grn_ctx_set_match_escalation_threshold (grn_ctx *ctx, int64_t threshold)
 Set the threshold to determine whether search strategy escalation is used or not.
 
GRN_API bool grn_ctx_get_force_match_escalation (grn_ctx *ctx)
 
GRN_API grn_rc grn_ctx_set_force_match_escalation (grn_ctx *ctx, bool force)
 
GRN_API int32_t grn_ctx_get_n_workers (grn_ctx *ctx)
 
GRN_API grn_rc grn_ctx_set_n_workers (grn_ctx *ctx, int32_t n_workers)
 
GRN_API int64_t grn_get_default_match_escalation_threshold (void)
 
GRN_API grn_rc grn_set_default_match_escalation_threshold (int64_t threshold)
 Set the default threshold to determine whether search strategy escalation is used or not.
 
GRN_API int32_t grn_get_default_n_workers (void)
 
GRN_API grn_rc grn_set_default_n_workers (int32_t n_workers)
 
GRN_API bool grn_is_back_trace_enable (void)
 
GRN_API grn_rc grn_set_back_trace_enable (bool enable)
 
GRN_API bool grn_is_reference_count_enable (void)
 
GRN_API grn_rc grn_set_reference_count_enable (bool enable)
 
GRN_API grn_rc grn_ctx_set_variable (grn_ctx *ctx, const char *name, int name_size, void *data, grn_close_func close_func)
 
GRN_API void * grn_ctx_get_variable (grn_ctx *ctx, const char *name, int name_size)
 
GRN_API grn_rc grn_unset_variable (const char *name, int name_size)
 
GRN_API int grn_get_lock_timeout (void)
 Retrieve the current lock timeout.
 
GRN_API grn_rc grn_set_lock_timeout (int timeout)
 Set the lock timeout used during write operations.
 
GRN_API size_t grn_get_memory_map_size (void)
 
GRN_API const char * grn_encoding_to_string (grn_encoding encoding)
 Return string representation for the encoding. For example, grn_encoding_to_string(GRN_ENC_UTF8) returns "utf8".
 
GRN_API grn_encoding grn_encoding_parse (const char *name)
 Parse encoding name and return grn_encoding. For example, grn_encoding_parse("UTF8") returns GRN_ENC_UTF8.
 
GRN_API grn_rc grn_ctx_use (grn_ctx *ctx, grn_obj *db)
 Set the database that the context is using.
 
GRN_API grn_obj * grn_ctx_db (grn_ctx *ctx)
 Retrieve the database that the context is using.
 
GRN_API grn_obj * grn_ctx_get (grn_ctx *ctx, const char *name, int name_size)
 Retrieve the object corresponding to the specified name from the database that the context is using.
 
GRN_API grn_rc grn_ctx_get_all_tables (grn_ctx *ctx, grn_obj *tables_buffer)
 Retrieve all tables from the database that the context is using.
 
GRN_API grn_rc grn_ctx_get_all_types (grn_ctx *ctx, grn_obj *types_buffer)
 
GRN_API grn_rc grn_ctx_get_all_tokenizers (grn_ctx *ctx, grn_obj *tokenizers_buffer)
 
GRN_API grn_rc grn_ctx_get_all_normalizers (grn_ctx *ctx, grn_obj *normalizers_buffer)
 
GRN_API grn_rc grn_ctx_get_all_token_filters (grn_ctx *ctx, grn_obj *token_filters_buffer)
 
GRN_API grn_obj * grn_ctx_at (grn_ctx *ctx, grn_id id)
 Retrieve the object corresponding to the specified ID from the context or the database that the context is using.
 
GRN_API bool grn_ctx_is_opened (grn_ctx *ctx, grn_id id)
 
GRN_API grn_rc grn_plugin_register (grn_ctx *ctx, const char *name)
 
GRN_API grn_rc grn_plugin_unregister (grn_ctx *ctx, const char *name)
 
GRN_API grn_rc grn_plugin_register_by_path (grn_ctx *ctx, const char *path)
 
GRN_API grn_rc grn_plugin_unregister_by_path (grn_ctx *ctx, const char *path)
 
GRN_API const char * grn_plugin_get_system_plugins_dir (void)
 
GRN_API const char * grn_plugin_get_suffix (void)
 
GRN_API const char * grn_plugin_get_ruby_suffix (void)
 
GRN_API grn_rc grn_plugin_get_names (grn_ctx *ctx, grn_obj *names)
 
GRN_API grn_obj * grn_obj_column (grn_ctx *ctx, grn_obj *table, const char *name, uint32_t name_size)
 Retrieve a column or an accessor from a specified table or accessor.
 
GRN_API grn_obj * grn_obj_get_info (grn_ctx *ctx, grn_obj *obj, grn_info_type type, grn_obj *valuebuf)
 Get information on the object.
 
GRN_API grn_rc grn_obj_set_info (grn_ctx *ctx, grn_obj *obj, grn_info_type type, grn_obj *value)
 Set information on the object.
 
GRN_API grn_obj * grn_obj_get_element_info (grn_ctx *ctx, grn_obj *obj, grn_id id, grn_info_type type, grn_obj *valuebuf)
 Get information on the record with the ID in the object.
 
GRN_API grn_rc grn_obj_set_element_info (grn_ctx *ctx, grn_obj *obj, grn_id id, grn_info_type type, grn_obj *value)
 Set information on the record with the ID in the object.
 
GRN_API grn_obj * grn_obj_get_value (grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value)
 Retrieve the value of the record corresponding to the given ID in the specified object.
 
GRN_API int grn_obj_get_values (grn_ctx *ctx, grn_obj *obj, grn_id offset, void **values)
 Retrieve an array of fixed-size column values starting from a specified record ID.
 
GRN_API grn_rc grn_obj_set_value (grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value, int flags)
 Update the value of a record identified by the given ID in the specified object.
 
GRN_API grn_rc grn_obj_remove (grn_ctx *ctx, grn_obj *obj)
 Remove the specified object.
 
GRN_API grn_rc grn_obj_remove_dependent (grn_ctx *ctx, grn_obj *obj)
 
GRN_API grn_rc grn_obj_remove_flags (grn_ctx *ctx, grn_obj *obj, uint32_t flags)
 
GRN_API grn_rc grn_obj_remove_force (grn_ctx *ctx, const char *name, int name_size)
 
GRN_API grn_rc grn_ctx_remove (grn_ctx *ctx, const char *name, int name_size, uint32_t flags)
 
GRN_API grn_rc grn_ctx_remove_by_id (grn_ctx *ctx, grn_id id, uint32_t flags)
 
GRN_API grn_rc grn_obj_rename (grn_ctx *ctx, grn_obj *obj, const char *name, unsigned int name_size)
 Rename a persistent object in the database used by the context.
 
GRN_API grn_rc grn_column_rename (grn_ctx *ctx, grn_obj *column, const char *name, unsigned int name_size)
 Rename a column in the database used by the context.
 
GRN_API grn_rc grn_obj_close (grn_ctx *ctx, grn_obj *obj)
 Close an object.
 
GRN_API grn_rc grn_obj_reinit (grn_ctx *ctx, grn_obj *obj, grn_id domain, uint8_t flags)
 Reinitialize an object.
 
GRN_API grn_rc grn_obj_unlink (grn_ctx *ctx, grn_obj *obj)
 Unlink an object.
 
GRN_API grn_rc grn_obj_refer (grn_ctx *ctx, grn_obj *obj)
 
GRN_API grn_rc grn_obj_refer_recursive (grn_ctx *ctx, grn_obj *obj)
 
GRN_API grn_rc grn_obj_refer_recursive_dependent (grn_ctx *ctx, grn_obj *obj)
 
GRN_API void grn_obj_unref (grn_ctx *ctx, grn_obj *obj)
 
GRN_API void grn_obj_unref_recursive (grn_ctx *ctx, grn_obj *obj)
 
GRN_API void grn_obj_unref_recursive_dependent (grn_ctx *ctx, grn_obj *obj)
 
GRN_API grn_user_data * grn_obj_user_data (grn_ctx *ctx, grn_obj *obj)
 Returns a pointer to user data that can be registered in the object.
 
GRN_API grn_rc grn_obj_set_finalizer (grn_ctx *ctx, grn_obj *obj, grn_proc_func *func)
 Set the callback function when finalizing the object.
 
GRN_API const char * grn_obj_path (grn_ctx *ctx, grn_obj *obj)
 Return the file path associated with an object.
 
GRN_API int grn_obj_name (grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size)
 Return an object's name by storing it in namebuf.
 
GRN_API int grn_column_name (grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size)
 Return a column's name by storing it in namebuf.
 
GRN_API grn_id grn_obj_get_range (grn_ctx *ctx, grn_obj *obj)
 Retrieve the value range based on the ID associated with an object.
 
GRN_API int grn_obj_expire (grn_ctx *ctx, grn_obj *obj, int threshold)
 Free allocatable memory occupied by an object based on a threshold.
 
GRN_API int grn_obj_check (grn_ctx *ctx, grn_obj *obj)
 Check the integrity of the file corresponding to an object.
 
GRN_API grn_rc grn_obj_lock (grn_ctx *ctx, grn_obj *obj, grn_id id, int timeout)
 Lock an object with a specified timeout.
 
GRN_API grn_rc grn_obj_unlock (grn_ctx *ctx, grn_obj *obj, grn_id id)
 Unlock an object.
 
GRN_API grn_rc grn_obj_clear_lock (grn_ctx *ctx, grn_obj *obj)
 Forcefully clear locks on an object.
 
GRN_API unsigned int grn_obj_is_locked (grn_ctx *ctx, grn_obj *obj)
 Check if an object is currently locked.
 
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 grn_rc grn_obj_flush_only_opened (grn_ctx *ctx, grn_obj *obj)
 
GRN_API uint64_t grn_obj_defrag (grn_ctx *ctx, grn_obj *obj, int threshold)
 Defragment an object to reduce fragmentation in the database file.
 
GRN_API grn_obj * grn_obj_db (grn_ctx *ctx, grn_obj *obj)
 Return the database to which obj belongs.
 
GRN_API grn_id grn_obj_id (grn_ctx *ctx, grn_obj *obj)
 Return the ID of an object.
 
GRN_API grn_rc grn_obj_search (grn_ctx *ctx, grn_obj *obj, grn_obj *query, grn_obj *res, grn_operator op, grn_search_optarg *optarg)
 Search for obj in query.
 
GRN_API grn_rc grn_proc_set_is_stable (grn_ctx *ctx, grn_obj *proc, bool is_stable)
 
GRN_API bool grn_proc_is_stable (grn_ctx *ctx, grn_obj *proc)
 
GRN_API int grn_proc_call_next (grn_ctx *ctx, grn_obj *exec_info, grn_obj *in, grn_obj *out)
 
GRN_API void * grn_proc_get_ctx_local_data (grn_ctx *ctx, grn_obj *exec_info)
 
GRN_API void * grn_proc_get_hook_local_data (grn_ctx *ctx, grn_obj *exec_info)
 
GRN_API const char * grn_hook_entry_to_string (grn_hook_entry entry)
 
GRN_API grn_rc grn_obj_add_hook (grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry, int offset, grn_obj *proc, grn_obj *data)
 Add a hook to the object. If multiple hooks are set for the object, they are called in the order they are registered in the hook list.
 
GRN_API int grn_obj_get_nhooks (grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry)
 Get the number of hooks set on the object.
 
GRN_API grn_obj * grn_obj_get_hook (grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry, int offset, grn_obj *data)
 Get the hook set on the object. If hook data is set, it is stored in data.
 
GRN_API grn_rc grn_obj_delete_hook (grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry, int offset)
 Delete the hook set on the object.
 
GRN_API grn_obj * grn_obj_open (grn_ctx *ctx, unsigned char type, grn_obj_flags flags, grn_id domain)
 
GRN_API int grn_column_index (grn_ctx *ctx, grn_obj *column, grn_operator op, grn_obj **indexbuf, int buf_size, int *section)
 
GRN_API unsigned int grn_column_find_index_data (grn_ctx *ctx, grn_obj *column, grn_operator op, grn_index_datum *index_data, unsigned int n_index_data)
 Return indexes that can perform a specified operation by storing it in index_data.
 
GRN_API uint32_t grn_column_get_all_index_data (grn_ctx *ctx, grn_obj *column, grn_index_datum *index_data, uint32_t n_index_data)
 
GRN_API grn_rc grn_column_get_all_index_columns (grn_ctx *ctx, grn_obj *column, grn_obj *index_columns)
 
GRN_API grn_rc grn_obj_delete_by_id (grn_ctx *ctx, grn_obj *db, grn_id id, bool remove_p)
 Delete an object (such as a table or column) identified by the ID from the database.
 
GRN_API grn_rc grn_obj_path_by_id (grn_ctx *ctx, grn_obj *db, grn_id id, char *buffer)
 Return the pathname of an object ID.
 
GRN_API grn_obj * grn_snip_open (grn_ctx *ctx, int flags, unsigned int width, unsigned int max_results, const char *defaultopentag, unsigned int defaultopentag_len, const char *defaultclosetag, unsigned int defaultclosetag_len, grn_snip_mapping *mapping)
 
GRN_API grn_rc grn_snip_add_cond (grn_ctx *ctx, grn_obj *snip, const char *keyword, unsigned int keyword_len, const char *opentag, unsigned int opentag_len, const char *closetag, unsigned int closetag_len)
 
GRN_API grn_rc grn_snip_set_normalizer (grn_ctx *ctx, grn_obj *snip, grn_obj *normalizer)
 
GRN_API grn_obj * grn_snip_get_normalizer (grn_ctx *ctx, grn_obj *snip)
 
GRN_API grn_rc grn_snip_set_normalizers (grn_ctx *ctx, grn_obj *snip, grn_obj *normalizers)
 
GRN_API grn_obj * grn_snip_get_normalizers (grn_ctx *ctx, grn_obj *snip)
 
GRN_API grn_rc grn_snip_set_delimiter_regexp (grn_ctx *ctx, grn_obj *snip, const char *pattern, int pattern_length)
 
GRN_API const char * grn_snip_get_delimiter_regexp (grn_ctx *ctx, grn_obj *snip, size_t *pattern_length)
 
GRN_API grn_rc grn_snip_exec (grn_ctx *ctx, grn_obj *snip, const char *string, unsigned int string_len, unsigned int *nresults, unsigned int *max_tagged_len)
 
GRN_API grn_rc grn_snip_get_result (grn_ctx *ctx, grn_obj *snip, const unsigned int index, char *result, unsigned int *result_len)
 
GRN_API grn_rc grn_logger_info_set (grn_ctx *ctx, const grn_logger_info *info)
 
GRN_API 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)
 
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 bool grn_logger_pass (grn_ctx *ctx, grn_log_level level)
 
GRN_API bool grn_logger_is_default_logger (grn_ctx *ctx)
 
GRN_API void grn_default_logger_set_max_level (grn_log_level level)
 
GRN_API grn_log_level grn_default_logger_get_max_level (void)
 
GRN_API void grn_default_logger_set_flags (int flags)
 
GRN_API int grn_default_logger_get_flags (void)
 
GRN_API void grn_default_logger_set_path (const char *path)
 
GRN_API const char * grn_default_logger_get_path (void)
 
GRN_API void grn_default_logger_set_rotate_threshold_size (off_t threshold)
 
GRN_API off_t grn_default_logger_get_rotate_threshold_size (void)
 
GRN_API grn_rc grn_slow_log_push (grn_ctx *ctx)
 
GRN_API double grn_slow_log_pop (grn_ctx *ctx)
 
GRN_API bool grn_slow_log_is_slow (grn_ctx *ctx, double elapsed_time)
 
GRN_API bool grn_query_log_flags_parse (const char *string, int string_size, unsigned int *flags)
 
GRN_API grn_rc grn_query_logger_set (grn_ctx *ctx, const grn_query_logger *logger)
 
GRN_API void grn_query_logger_set_flags (grn_ctx *ctx, unsigned int flags)
 
GRN_API void grn_query_logger_add_flags (grn_ctx *ctx, unsigned int flags)
 
GRN_API void grn_query_logger_remove_flags (grn_ctx *ctx, unsigned int flags)
 
GRN_API unsigned int grn_query_logger_get_flags (grn_ctx *ctx)
 
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 void grn_query_logger_reopen (grn_ctx *ctx)
 
GRN_API 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)
 
GRN_API void grn_default_query_logger_set_path (const char *path)
 
GRN_API const char * grn_default_query_logger_get_path (void)
 
GRN_API void grn_default_query_logger_set_rotate_threshold_size (off_t threshold)
 
GRN_API off_t grn_default_query_logger_get_rotate_threshold_size (void)
 
GRN_API grn_rc grn_bulk_reinit (grn_ctx *ctx, grn_obj *bulk, size_t size)
 
GRN_API grn_rc grn_bulk_resize (grn_ctx *ctx, grn_obj *bulk, size_t new_size)
 
GRN_API grn_rc grn_bulk_write (grn_ctx *ctx, grn_obj *bulk, const char *str, size_t len)
 
GRN_API grn_rc grn_bulk_write_from (grn_ctx *ctx, grn_obj *bulk, const char *str, size_t from, size_t len)
 
GRN_API grn_rc grn_bulk_reserve (grn_ctx *ctx, grn_obj *bulk, size_t len)
 
GRN_API grn_rc grn_bulk_space (grn_ctx *ctx, grn_obj *bulk, size_t len)
 
GRN_API grn_rc grn_bulk_truncate (grn_ctx *ctx, grn_obj *bulk, size_t len)
 
GRN_API char * grn_bulk_detach (grn_ctx *ctx, grn_obj *bulk)
 
GRN_API grn_rc grn_bulk_fin (grn_ctx *ctx, grn_obj *bulk)
 
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, size_t len)
 
GRN_API grn_rc grn_text_lltoa (grn_ctx *ctx, grn_obj *bulk, long long int i)
 
GRN_API grn_rc grn_text_f32toa (grn_ctx *ctx, grn_obj *bulk, float f)
 
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, unsigned int i, size_t 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)
 
GRN_API grn_rc grn_text_esc (grn_ctx *ctx, grn_obj *bulk, const char *s, size_t len)
 
GRN_API grn_rc grn_text_code_point (grn_ctx *ctx, grn_obj *buffer, uint32_t code_point)
 
GRN_API grn_rc grn_text_urlenc (grn_ctx *ctx, grn_obj *buf, const char *str, size_t len)
 
GRN_API const char * grn_text_urldec (grn_ctx *ctx, grn_obj *buf, const char *s, const char *e, char d)
 
GRN_API grn_rc grn_text_escape_xml (grn_ctx *ctx, grn_obj *buf, const char *s, size_t len)
 
GRN_API grn_rc grn_text_time2rfc1123 (grn_ctx *ctx, grn_obj *bulk, int sec)
 
GRN_API grn_rc grn_text_printf (grn_ctx *ctx, grn_obj *bulk, const char *format,...) GRN_ATTRIBUTE_PRINTF(3)
 
GRN_API grn_rc grn_text_printfv (grn_ctx *ctx, grn_obj *bulk, const char *format, va_list args)
 
GRN_API grn_rc grn_text_vprintf (grn_ctx *ctx, grn_obj *bulk, const char *format, va_list args)
 
GRN_API void grn_ctx_recv_handler_set (grn_ctx *, grn_recv_handler_func func, void *user_data)
 
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_rc grn_obj_columns (grn_ctx *ctx, grn_obj *table, const char *str, unsigned int str_size, grn_obj *res)
 
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, const char *values, unsigned int values_len, const char *ifexists, unsigned int ifexists_len, const char *each, unsigned int each_len)
 
GRN_API grn_rc grn_ctx_connect (grn_ctx *ctx, const char *host, int port, int flags)
 
GRN_API unsigned int grn_ctx_send (grn_ctx *ctx, const char *str, unsigned int str_len, int flags)
 
GRN_API grn_rc grn_ctx_recv (grn_ctx *ctx, char **str, unsigned int *str_len, int *flags)
 
GRN_API grn_rc grn_ctx_info_get (grn_ctx *ctx, grn_ctx_info *info)
 
GRN_API grn_rc grn_set_segv_handler (void)
 
GRN_API grn_rc grn_set_abrt_handler (void)
 
GRN_API grn_rc grn_set_int_handler (void)
 
GRN_API grn_rc grn_set_term_handler (void)
 

Macro Definition Documentation

◆ GRN_ACCESSOR

#define GRN_ACCESSOR   (0x09)

◆ GRN_API

#define GRN_API

◆ GRN_ATTRIBUTE_ALLOC_SIZE

#define GRN_ATTRIBUTE_ALLOC_SIZE (   size)

◆ GRN_ATTRIBUTE_ALLOC_SIZE_N

#define GRN_ATTRIBUTE_ALLOC_SIZE_N (   n,
  size 
)

◆ GRN_ATTRIBUTE_PRINTF

#define GRN_ATTRIBUTE_PRINTF (   fmt_pos)

◆ GRN_BFLOAT16_INIT

#define GRN_BFLOAT16_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BFLOAT16)

◆ GRN_BFLOAT16_POP

#define GRN_BFLOAT16_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, grn_bfloat16, 0.0)

◆ GRN_BFLOAT16_PUT

#define GRN_BFLOAT16_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
grn_bfloat16 _val = (grn_bfloat16)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_bfloat16)); \
} while (0)

◆ GRN_BFLOAT16_SET

#define GRN_BFLOAT16_SET (   ctx,
  obj,
  val 
)
Value:
do { \
grn_bfloat16 _val = (grn_bfloat16)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_bfloat16)); \
} while (0)

◆ GRN_BFLOAT16_SET_AT

#define GRN_BFLOAT16_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
grn_bfloat16 _val = (grn_bfloat16)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(grn_bfloat16), \
sizeof(grn_bfloat16)); \
} while (0)

◆ GRN_BFLOAT16_VALUE

#define GRN_BFLOAT16_VALUE (   obj)    (*((grn_bfloat16 *)GRN_BULK_HEAD(obj)))

◆ GRN_BFLOAT16_VALUE_AT

#define GRN_BFLOAT16_VALUE_AT (   obj,
  offset 
)     (((grn_bfloat16 *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_BFLOAT16_VECTOR_SIZE

#define GRN_BFLOAT16_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, grn_bfloat16)

◆ GRN_BINARY_INIT

#define GRN_BINARY_INIT (   obj,
  flags 
)     GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_BINARY)

◆ GRN_BINARY_LEN

#define GRN_BINARY_LEN (   obj)    GRN_BULK_VSIZE(obj)

◆ GRN_BINARY_PUT

#define GRN_BINARY_PUT (   ctx,
  obj,
  data,
  len 
)     grn_bulk_write((ctx), (obj), (const char *)(data), (unsigned int)(len))

◆ GRN_BINARY_SET

#define GRN_BINARY_SET (   ctx,
  obj,
  data,
  len 
)
Value:
do { \
if ((obj)->header.impl_flags & GRN_OBJ_REFER) { \
GRN_BINARY_SET_REF((obj), (data), (len)); \
} else { \
grn_bulk_write_from((ctx), \
(obj), \
(const char *)(data), \
0, \
(unsigned int)(len)); \
} \
} while (0)
GRN_OBJ_REFER
#define GRN_OBJ_REFER
Definition groonga.h:935

◆ GRN_BINARY_SET_REF

#define GRN_BINARY_SET_REF (   obj,
  data,
  len 
)
Value:
do { \
(obj)->u.b.head = (char *)(data); \
(obj)->u.b.curr = (char *)(data) + (len); \
} while (0)

◆ GRN_BINARY_VALUE

#define GRN_BINARY_VALUE (   obj)    ((const uint8_t *)GRN_BULK_HEAD(obj))

◆ GRN_BOOL_INIT

#define GRN_BOOL_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BOOL)

◆ GRN_BOOL_POP

#define GRN_BOOL_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, bool, 0)

◆ GRN_BOOL_PUT

#define GRN_BOOL_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
bool _val = (bool)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(bool)); \
} while (0)

◆ GRN_BOOL_SET

#define GRN_BOOL_SET (   ctx,
  obj,
  val 
)
Value:
do { \
bool _val = (bool)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(bool)); \
} while (0)

◆ GRN_BOOL_SET_AT

#define GRN_BOOL_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
bool _val = (bool)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, (offset), sizeof(bool)); \
} while (0)

◆ GRN_BOOL_VALUE

#define GRN_BOOL_VALUE (   obj)    (*((bool *)GRN_BULK_HEAD(obj)))

◆ GRN_BOOL_VALUE_AT

#define GRN_BOOL_VALUE_AT (   obj,
  offset 
)    (((bool *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_BOOL_VECTOR_SIZE

#define GRN_BOOL_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, bool)

◆ GRN_BULK

#define GRN_BULK   (0x02)

Auto-extendable buffer that can be used for storing a number and variable size string.

◆ GRN_BULK_BUFSIZE

#define GRN_BULK_BUFSIZE   (sizeof(grn_obj) - sizeof(grn_obj_header))

◆ GRN_BULK_BUFSIZE_MAX

#define GRN_BULK_BUFSIZE_MAX   0x1f

◆ GRN_BULK_CURR

#define GRN_BULK_CURR (   bulk)
Value:
(GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.curr) \
: (char *)&((bulk)->u.b.head) + \
GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))
GRN_BULK_SIZE_IN_FLAGS
#define GRN_BULK_SIZE_IN_FLAGS(flags)
Definition groonga.h:2597
GRN_BULK_OUTP
#define GRN_BULK_OUTP(bulk)
Definition groonga.h:2598

◆ GRN_BULK_EMPTYP

#define GRN_BULK_EMPTYP (   bulk)
Value:
(GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.curr == (bulk)->u.b.head) \
: !(GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags)))

◆ GRN_BULK_HEAD

#define GRN_BULK_HEAD (   bulk)     (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.head) : (char *)&((bulk)->u.b.head))

◆ GRN_BULK_INCR_LEN

#define GRN_BULK_INCR_LEN (   bulk,
  len 
)
Value:
do { \
if (GRN_BULK_OUTP(bulk)) { \
(bulk)->u.b.curr += (len); \
} else { \
(bulk)->header.flags += (grn_obj_flags)(len); \
} \
} while (0)
grn_obj_flags
uint16_t grn_obj_flags
Definition groonga.h:679

◆ GRN_BULK_OUTP

#define GRN_BULK_OUTP (   bulk)    ((bulk)->header.impl_flags & GRN_OBJ_OUTPLACE)

◆ GRN_BULK_POP

#define GRN_BULK_POP (   obj,
  value,
  type,
  default 
)
Value:
do { \
if (GRN_BULK_VSIZE(obj) >= sizeof(type)) { \
ssize_t value_size = (ssize_t)(sizeof(type)); \
GRN_BULK_INCR_LEN((obj), -value_size); \
value = *(type *)(GRN_BULK_CURR(obj)); \
} else { \
value = default; \
} \
} while (0)
GRN_BULK_VSIZE
#define GRN_BULK_VSIZE(bulk)
Definition groonga.h:2642
GRN_BULK_CURR
#define GRN_BULK_CURR(bulk)
Definition groonga.h:2650

◆ GRN_BULK_REST

#define GRN_BULK_REST (   bulk)
Value:
(GRN_BULK_OUTP(bulk) \
? (size_t)((bulk)->u.b.tail - (bulk)->u.b.curr) \
: GRN_BULK_BUFSIZE - GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))
GRN_BULK_BUFSIZE
#define GRN_BULK_BUFSIZE
Definition groonga.h:2594

◆ GRN_BULK_REWIND

#define GRN_BULK_REWIND (   bulk)
Value:
do { \
if ((bulk)->header.type == GRN_VECTOR) { \
grn_obj *_body = (bulk)->u.v.body; \
if (_body) { \
if (GRN_BULK_OUTP(_body)) { \
(_body)->u.b.curr = (_body)->u.b.head; \
} else { \
(_body)->header.flags &= (grn_obj_flags)(~GRN_BULK_BUFSIZE_MAX); \
} \
} \
(bulk)->u.v.n_sections = 0; \
} else { \
if (GRN_BULK_OUTP(bulk)) { \
(bulk)->u.b.curr = (bulk)->u.b.head; \
} else { \
(bulk)->header.flags &= (grn_obj_flags)(~GRN_BULK_BUFSIZE_MAX); \
} \
} \
} while (0)
GRN_VECTOR
#define GRN_VECTOR
Definition groonga.h:877
_grn_obj
Definition groonga.h:919
_grn_obj::body
grn_obj * body
Definition groonga.h:928
_grn_obj::v
struct _grn_obj::@0::@2 v

◆ GRN_BULK_SET_CURR

#define GRN_BULK_SET_CURR (   buf,
  p 
)
Value:
do { \
if (GRN_BULK_OUTP(buf)) { \
(buf)->u.b.curr = (char *)(p); \
} else { \
(buf)->header.flags = (grn_obj_flags)((char *)(p) - GRN_BULK_HEAD(buf)); \
} \
} while (0)
GRN_BULK_HEAD
#define GRN_BULK_HEAD(bulk)
Definition groonga.h:2648

◆ GRN_BULK_SIZE_IN_FLAGS

#define GRN_BULK_SIZE_IN_FLAGS (   flags)    (size_t)((flags) & GRN_BULK_BUFSIZE_MAX)

◆ GRN_BULK_TAIL

#define GRN_BULK_TAIL (   bulk)     (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.tail) : (char *)&((bulk)[1]))

◆ GRN_BULK_VECTOR_SIZE

#define GRN_BULK_VECTOR_SIZE (   obj,
  type 
)    (GRN_BULK_VSIZE(obj) / sizeof(type))

◆ GRN_BULK_VSIZE

#define GRN_BULK_VSIZE (   bulk)
Value:
(GRN_BULK_OUTP(bulk) ? (size_t)((bulk)->u.b.curr - (bulk)->u.b.head) \
: GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))

◆ GRN_BULK_WSIZE

#define GRN_BULK_WSIZE (   bulk)
Value:
(GRN_BULK_OUTP(bulk) ? (size_t)((bulk)->u.b.tail - (bulk)->u.b.head) \
: GRN_BULK_BUFSIZE)

◆ GRN_COLUMN_EACH

#define GRN_COLUMN_EACH (   ctx,
  column,
  id,
  value,
  block 
)
Value:
do { \
int _n; \
grn_id id = 1; \
while ((_n = grn_obj_get_values(ctx, column, id, (void **)&value)) > 0) { \
for (; _n; _n--, id++, value++) { \
block \
} \
} \
} while (0)
grn_id
uint32_t grn_id
Definition groonga.h:44
grn_obj_get_values
GRN_API int grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void **values)
Retrieve an array of fixed-size column values starting from a specified record ID.

◆ GRN_COLUMN_FIX_SIZE

#define GRN_COLUMN_FIX_SIZE   (0x40)

◆ GRN_COLUMN_INDEX

#define GRN_COLUMN_INDEX   (0x48)

◆ GRN_COLUMN_VAR_SIZE

#define GRN_COLUMN_VAR_SIZE   (0x41)

◆ GRN_COMMAND_VERSION_MAX

#define GRN_COMMAND_VERSION_MAX   GRN_COMMAND_VERSION_3

◆ GRN_COMMAND_VERSION_MIN

#define GRN_COMMAND_VERSION_MIN   GRN_COMMAND_VERSION_1

◆ GRN_COMMAND_VERSION_STABLE

#define GRN_COMMAND_VERSION_STABLE   GRN_COMMAND_VERSION_1

◆ GRN_CTX_BATCH_MODE

#define GRN_CTX_BATCH_MODE   (0x04)

◆ GRN_CTX_FIN

#define GRN_CTX_FIN   (0xff)

◆ GRN_CTX_GET_ENCODING

#define GRN_CTX_GET_ENCODING (   ctx)    ((ctx)->encoding)

◆ GRN_CTX_HEAD

#define GRN_CTX_HEAD   (0x01 << 2)

◆ GRN_CTX_MORE

#define GRN_CTX_MORE   (0x01 << 0)

◆ GRN_CTX_MSGSIZE

#define GRN_CTX_MSGSIZE   (0x80)

◆ GRN_CTX_PER_DB

#define GRN_CTX_PER_DB   (0x08)

◆ GRN_CTX_QUIET

#define GRN_CTX_QUIET   (0x01 << 3)

◆ GRN_CTX_QUIT

#define GRN_CTX_QUIT   (0x01 << 4)

◆ GRN_CTX_SET_ENCODING

#define GRN_CTX_SET_ENCODING (   ctx,
  enc 
)
Value:
((ctx)->encoding = \
(enc == GRN_ENC_DEFAULT) ? grn_get_default_encoding() : enc)
grn_get_default_encoding
GRN_API grn_encoding grn_get_default_encoding(void)
GRN_ENC_DEFAULT
@ GRN_ENC_DEFAULT
Definition groonga.h:166

◆ GRN_CTX_TAIL

#define GRN_CTX_TAIL   (0x01 << 1)

◆ GRN_CTX_USE_QL

#define GRN_CTX_USE_QL   (0x03)

◆ GRN_CTX_USER_DATA

#define GRN_CTX_USER_DATA (   ctx)    (&((ctx)->user_data))

◆ GRN_CURSOR_COLUMN_GEO_INDEX

#define GRN_CURSOR_COLUMN_GEO_INDEX   (0x1a)

◆ GRN_CURSOR_COLUMN_INDEX

#define GRN_CURSOR_COLUMN_INDEX   (0x18)

◆ GRN_CURSOR_CONFIG

#define GRN_CURSOR_CONFIG   (0x1f)

◆ GRN_CURSOR_TABLE_DAT_KEY

#define GRN_CURSOR_TABLE_DAT_KEY   (0x12)

◆ GRN_CURSOR_TABLE_HASH_KEY

#define GRN_CURSOR_TABLE_HASH_KEY   (0x10)

◆ GRN_CURSOR_TABLE_NO_KEY

#define GRN_CURSOR_TABLE_NO_KEY   (0x13)

◆ GRN_CURSOR_TABLE_PAT_KEY

#define GRN_CURSOR_TABLE_PAT_KEY   (0x11)

◆ GRN_DB

#define GRN_DB   (0x37)

◆ GRN_EXPR

#define GRN_EXPR   (0x22)

◆ GRN_FALSE

#define GRN_FALSE   false

◆ GRN_FLOAT32_INIT

#define GRN_FLOAT32_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT32)

◆ GRN_FLOAT32_POP

#define GRN_FLOAT32_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, float, 0.0)

◆ GRN_FLOAT32_PUT

#define GRN_FLOAT32_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
float _val = (float)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(float)); \
} while (0)

◆ GRN_FLOAT32_SET

#define GRN_FLOAT32_SET (   ctx,
  obj,
  val 
)
Value:
do { \
float _val = (float)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(float)); \
} while (0)

◆ GRN_FLOAT32_SET_AT

#define GRN_FLOAT32_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
float _val = (float)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(float), \
sizeof(float)); \
} while (0)

◆ GRN_FLOAT32_VALUE

#define GRN_FLOAT32_VALUE (   obj)    (*((float *)GRN_BULK_HEAD(obj)))

◆ GRN_FLOAT32_VALUE_AT

#define GRN_FLOAT32_VALUE_AT (   obj,
  offset 
)     (((float *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_FLOAT32_VECTOR_SIZE

#define GRN_FLOAT32_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, float)

◆ GRN_FLOAT_INIT

#define GRN_FLOAT_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT)

◆ GRN_FLOAT_POP

#define GRN_FLOAT_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, double, 0.0)

◆ GRN_FLOAT_PUT

#define GRN_FLOAT_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
double _val = (double)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(double)); \
} while (0)

◆ GRN_FLOAT_SET

#define GRN_FLOAT_SET (   ctx,
  obj,
  val 
)
Value:
do { \
double _val = (double)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(double)); \
} while (0)

◆ GRN_FLOAT_SET_AT

#define GRN_FLOAT_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
double _val = (double)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(double), \
sizeof(double)); \
} while (0)

◆ GRN_FLOAT_VALUE

#define GRN_FLOAT_VALUE (   obj)    (*((double *)GRN_BULK_HEAD(obj)))

◆ GRN_FLOAT_VALUE_AT

#define GRN_FLOAT_VALUE_AT (   obj,
  offset 
)    (((double *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_FLOAT_VECTOR_SIZE

#define GRN_FLOAT_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, double)

◆ GRN_GEO_DEGREE2MSEC

#define GRN_GEO_DEGREE2MSEC (   degree)     ((int32_t)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))

◆ GRN_GEO_M_PI

#define GRN_GEO_M_PI   3.14159265358979323846

◆ GRN_GEO_MSEC2DEGREE

#define GRN_GEO_MSEC2DEGREE (   msec)    ((((int32_t)(msec)) / 3600.0) * 0.001)

◆ GRN_GEO_MSEC2RADIAN

#define GRN_GEO_MSEC2RADIAN (   msec)     ((GRN_GEO_M_PI / (GRN_GEO_RESOLUTION * 180)) * (msec))

◆ GRN_GEO_POINT_SET

#define GRN_GEO_POINT_SET (   ctx,
  obj,
  _latitude,
  _longitude 
)
Value:
do { \
grn_geo_point _val; \
_val.latitude = (int)(_latitude); \
_val.longitude = (int)(_longitude); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
0, \
sizeof(grn_geo_point)); \
} while (0)
grn_geo_point
Definition geo.h:26
grn_geo_point::longitude
int32_t longitude
Definition geo.h:28
grn_geo_point::latitude
int32_t latitude
Definition geo.h:27

◆ GRN_GEO_POINT_VALUE

#define GRN_GEO_POINT_VALUE (   obj,
  _latitude,
  _longitude 
)
Value:
do { \
grn_geo_point *_val = GRN_GEO_POINT_VALUE_RAW(obj); \
_latitude = _val->latitude; \
_longitude = _val->longitude; \
} while (0)
GRN_GEO_POINT_VALUE_RAW
#define GRN_GEO_POINT_VALUE_RAW(obj)
Definition groonga.h:3112

◆ GRN_GEO_POINT_VALUE_RADIAN

#define GRN_GEO_POINT_VALUE_RADIAN (   obj,
  _latitude,
  _longitude 
)
Value:
do { \
grn_geo_point *_val = GRN_GEO_POINT_VALUE_RAW(obj); \
_latitude = GRN_GEO_MSEC2RADIAN(_val->latitude); \
_longitude = GRN_GEO_MSEC2RADIAN(_val->longitude); \
} while (0)
GRN_GEO_MSEC2RADIAN
#define GRN_GEO_MSEC2RADIAN(msec)
Definition groonga.h:2958

◆ GRN_GEO_POINT_VALUE_RAW

#define GRN_GEO_POINT_VALUE_RAW (   obj)    (grn_geo_point *)GRN_BULK_HEAD(obj)

◆ GRN_GEO_RADIAN2MSEC

#define GRN_GEO_RADIAN2MSEC (   radian)     ((int32_t)(((GRN_GEO_RESOLUTION * 180) / GRN_GEO_M_PI) * (radian)))

◆ GRN_GEO_RESOLUTION

#define GRN_GEO_RESOLUTION   3600000

◆ GRN_HIGHLIGHTER

#define GRN_HIGHLIGHTER   (0x0e)

◆ GRN_HTTP_CLIENT

#define GRN_HTTP_CLIENT   (0x50)

◆ GRN_ID_MAX

#define GRN_ID_MAX   (0x3fffffff)

◆ GRN_ID_NIL

#define GRN_ID_NIL   (0x00)

Means "does not exist".

◆ GRN_INFO_SUPPORT_ARROW

#define GRN_INFO_SUPPORT_ARROW   GRN_INFO_SUPPORT_APACHE_ARROW

◆ GRN_INFO_SUPPORT_LZO

#define GRN_INFO_SUPPORT_LZO   GRN_INFO_SUPPORT_LZ4

◆ GRN_INT16_INIT

#define GRN_INT16_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT16)

◆ GRN_INT16_POP

#define GRN_INT16_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, int16_t, 0)

◆ GRN_INT16_PUT

#define GRN_INT16_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
int16_t _val = (int16_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int16_t)); \
} while (0)

◆ GRN_INT16_SET

#define GRN_INT16_SET (   ctx,
  obj,
  val 
)
Value:
do { \
int16_t _val = (int16_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int16_t)); \
} while (0)

◆ GRN_INT16_SET_AT

#define GRN_INT16_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
int16_t _val = (int16_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(int16_t), \
sizeof(int16_t)); \
} while (0)

◆ GRN_INT16_VALUE

#define GRN_INT16_VALUE (   obj)    (*((int16_t *)GRN_BULK_HEAD(obj)))

◆ GRN_INT16_VALUE_AT

#define GRN_INT16_VALUE_AT (   obj,
  offset 
)     (((int16_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_INT16_VECTOR_SIZE

#define GRN_INT16_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, int16_t)

◆ GRN_INT32_INIT

#define GRN_INT32_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT32)

◆ GRN_INT32_POP

#define GRN_INT32_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, int32_t, 0)

◆ GRN_INT32_PUT

#define GRN_INT32_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
int32_t _val = (int32_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int32_t)); \
} while (0)

◆ GRN_INT32_SET

#define GRN_INT32_SET (   ctx,
  obj,
  val 
)
Value:
do { \
int32_t _val = (int32_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int32_t)); \
} while (0)

◆ GRN_INT32_SET_AT

#define GRN_INT32_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
int32_t _val = (int32_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(int32_t), \
sizeof(int32_t)); \
} while (0)

◆ GRN_INT32_VALUE

#define GRN_INT32_VALUE (   obj)    (*((int32_t *)GRN_BULK_HEAD(obj)))

◆ GRN_INT32_VALUE_AT

#define GRN_INT32_VALUE_AT (   obj,
  offset 
)     (((int32_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_INT32_VECTOR_SIZE

#define GRN_INT32_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, int32_t)

◆ GRN_INT64_INIT

#define GRN_INT64_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT64)

◆ GRN_INT64_POP

#define GRN_INT64_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, int64_t, 0)

◆ GRN_INT64_PUT

#define GRN_INT64_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
int64_t _val = (int64_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int64_t)); \
} while (0)

◆ GRN_INT64_SET

#define GRN_INT64_SET (   ctx,
  obj,
  val 
)
Value:
do { \
int64_t _val = (int64_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int64_t)); \
} while (0)

◆ GRN_INT64_SET_AT

#define GRN_INT64_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
int64_t _val = (int64_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(int64_t), \
sizeof(int64_t)); \
} while (0)

◆ GRN_INT64_VALUE

#define GRN_INT64_VALUE (   obj)    (*((int64_t *)GRN_BULK_HEAD(obj)))

◆ GRN_INT64_VALUE_AT

#define GRN_INT64_VALUE_AT (   obj,
  offset 
)     (((int64_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_INT64_VECTOR_SIZE

#define GRN_INT64_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, int64_t)

◆ GRN_INT8_INIT

#define GRN_INT8_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT8)

◆ GRN_INT8_POP

#define GRN_INT8_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, int8_t, 0)

◆ GRN_INT8_PUT

#define GRN_INT8_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
int8_t _val = (int8_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int8_t)); \
} while (0)

◆ GRN_INT8_SET

#define GRN_INT8_SET (   ctx,
  obj,
  val 
)
Value:
do { \
int8_t _val = (int8_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int8_t)); \
} while (0)

◆ GRN_INT8_SET_AT

#define GRN_INT8_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
int8_t _val = (int8_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(int8_t), \
sizeof(int8_t)); \
} while (0)

◆ GRN_INT8_VALUE

#define GRN_INT8_VALUE (   obj)    (*((int8_t *)GRN_BULK_HEAD(obj)))

◆ GRN_INT8_VALUE_AT

#define GRN_INT8_VALUE_AT (   obj,
  offset 
)    (((int8_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_INT8_VECTOR_SIZE

#define GRN_INT8_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, int8_t)

◆ GRN_JSON_INIT

#define GRN_JSON_INIT (   obj,
  flags 
)     GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_JSON)

◆ GRN_JSON_LEN

#define GRN_JSON_LEN (   obj)    GRN_BULK_VSIZE(obj)

◆ GRN_JSON_SET

#define GRN_JSON_SET (   ctx,
  obj,
  data,
  len 
)
Value:
do { \
if ((obj)->header.impl_flags & GRN_OBJ_REFER) { \
GRN_JSON_SET_REF((obj), (data), (len)); \
} else { \
grn_bulk_write_from((ctx), \
(obj), \
(const char *)(data), \
0, \
(unsigned int)(len)); \
} \
} while (0)

◆ GRN_JSON_SET_REF

#define GRN_JSON_SET_REF (   obj,
  data,
  len 
)
Value:
do { \
(obj)->u.b.head = (char *)(data); \
(obj)->u.b.curr = (char *)(data) + (len); \
} while (0)

◆ GRN_JSON_VALUE

#define GRN_JSON_VALUE (   obj)    ((const uint8_t *)GRN_BULK_HEAD(obj))

◆ GRN_LOG

#define GRN_LOG (   ctx,
  level,
  ... 
)
Value:
do { \
if (grn_logger_pass(ctx, level)) { \
grn_logger_put(ctx, \
(level), \
__FILE__, \
__LINE__, \
__FUNCTION__, \
__VA_ARGS__); \
} \
} while (0)
grn_logger_pass
GRN_API bool grn_logger_pass(grn_ctx *ctx, grn_log_level level)

◆ GRN_LOG_ALL

#define GRN_LOG_ALL
Value:
(GRN_LOG_TIME | GRN_LOG_TITLE | GRN_LOG_MESSAGE | GRN_LOG_LOCATION | \
GRN_LOG_PROCESS_ID | GRN_LOG_THREAD_ID | GRN_LOG_CONTEXT_ID)
GRN_LOG_THREAD_ID
#define GRN_LOG_THREAD_ID
Definition groonga.h:2369
GRN_LOG_CONTEXT_ID
#define GRN_LOG_CONTEXT_ID
Definition groonga.h:2370
GRN_LOG_LOCATION
#define GRN_LOG_LOCATION
Definition groonga.h:2366
GRN_LOG_TIME
#define GRN_LOG_TIME
Definition groonga.h:2363
GRN_LOG_PROCESS_ID
#define GRN_LOG_PROCESS_ID
Definition groonga.h:2368
GRN_LOG_MESSAGE
#define GRN_LOG_MESSAGE
Definition groonga.h:2365
GRN_LOG_TITLE
#define GRN_LOG_TITLE
Definition groonga.h:2364

◆ GRN_LOG_CONTEXT_ID

#define GRN_LOG_CONTEXT_ID   (0x01 << 6)

◆ GRN_LOG_CTX_ID

#define GRN_LOG_CTX_ID   GRN_LOG_CONTEXT_ID

◆ GRN_LOG_DEFAULT

#define GRN_LOG_DEFAULT   (GRN_LOG_TIME | GRN_LOG_MESSAGE)

◆ GRN_LOG_DEFAULT_LEVEL

#define GRN_LOG_DEFAULT_LEVEL   GRN_LOG_NOTICE

◆ GRN_LOG_LOCATION

#define GRN_LOG_LOCATION   (0x01 << 3)

◆ GRN_LOG_MESSAGE

#define GRN_LOG_MESSAGE   (0x01 << 2)

◆ GRN_LOG_NONE

#define GRN_LOG_NONE   (0x00 << 0)

◆ GRN_LOG_PID

#define GRN_LOG_PID   (0x01 << 4)

◆ GRN_LOG_PROCESS_ID

#define GRN_LOG_PROCESS_ID   GRN_LOG_PID

◆ GRN_LOG_THREAD_ID

#define GRN_LOG_THREAD_ID   (0x01 << 5)

◆ GRN_LOG_TIME

#define GRN_LOG_TIME   (0x01 << 0)

◆ GRN_LOG_TITLE

#define GRN_LOG_TITLE   (0x01 << 1)

◆ GRN_LONG_BINARY_INIT

#define GRN_LONG_BINARY_INIT (   obj,
  flags 
)     GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_BINARY)

◆ GRN_LONG_TEXT_INIT

#define GRN_LONG_TEXT_INIT (   obj,
  flags 
)     GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_TEXT)

◆ GRN_LZO_ERROR

#define GRN_LZO_ERROR   GRN_LZ4_ERROR

◆ GRN_MATCH_INFO_GET_MIN_RECORD_ID

#define GRN_MATCH_INFO_GET_MIN_RECORD_ID   (0x01)

◆ GRN_MATCH_INFO_ONLY_SKIP_TOKEN

#define GRN_MATCH_INFO_ONLY_SKIP_TOKEN   (0x02)

◆ GRN_MSG

#define GRN_MSG   (0x07)

◆ GRN_N_HOOK_ENTRIES

#define GRN_N_HOOK_ENTRIES   5 /* (GRN_HOOK_SELECT + 1) */

◆ GRN_OBJ_APPEND

#define GRN_OBJ_APPEND   (0x04)

Append the specified value to the column value.

◆ GRN_OBJ_COLUMN_INDEX

#define GRN_OBJ_COLUMN_INDEX   (0x02)

Index column type. Indicates that the column is an inverted index.

◆ GRN_OBJ_COLUMN_SCALAR

#define GRN_OBJ_COLUMN_SCALAR   (0x00)

Scalar column type. Indicates that the column stores a scalar value.

◆ GRN_OBJ_COLUMN_TYPE_MASK

#define GRN_OBJ_COLUMN_TYPE_MASK   (0x07)

Mask for column types. Used to isolate the column type bits from the flags.

◆ GRN_OBJ_COLUMN_VECTOR

#define GRN_OBJ_COLUMN_VECTOR   (0x01)

Vector column type. Indicates that the column stores a vector of values.

◆ GRN_OBJ_COMPARE

#define GRN_OBJ_COMPARE   (0x01 << 5)

◆ GRN_OBJ_COMPRESS_FILTER_BYTE_DELTA

#define GRN_OBJ_COMPRESS_FILTER_BYTE_DELTA   (0x01 << 25)

◆ GRN_OBJ_COMPRESS_FILTER_SHUFFLE

#define GRN_OBJ_COMPRESS_FILTER_SHUFFLE   (0x01 << 24)

◆ GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_1BYTE

#define GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_1BYTE   (0x01 << 26)

◆ GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_2BYTES

#define GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_2BYTES   (0x01 << 27)

◆ GRN_OBJ_COMPRESS_LZ4

#define GRN_OBJ_COMPRESS_LZ4   (0x02 << 4)

LZ4 compression. Indicates that the objects are compressed using LZ4.

◆ GRN_OBJ_COMPRESS_LZO

#define GRN_OBJ_COMPRESS_LZO   GRN_OBJ_COMPRESS_LZ4

◆ GRN_OBJ_COMPRESS_MASK

#define GRN_OBJ_COMPRESS_MASK   (0x07 << 4)

◆ GRN_OBJ_COMPRESS_NONE

#define GRN_OBJ_COMPRESS_NONE   (0x00 << 4)

◆ GRN_OBJ_COMPRESS_OPENZL

#define GRN_OBJ_COMPRESS_OPENZL   (0x04 << 4)

OpenZL compression. Indicates that the objects are compressed using OpenZL.

Since
15.2.2

◆ GRN_OBJ_COMPRESS_ZLIB

#define GRN_OBJ_COMPRESS_ZLIB   (0x01 << 4)

zlib compression. Indicates that the objects are compressed using zlib.

◆ GRN_OBJ_COMPRESS_ZSTD

#define GRN_OBJ_COMPRESS_ZSTD   (0x03 << 4)

Zstandard (zstd) compression. Indicates that the objects are compressed using Zstandard.

◆ GRN_OBJ_DECR

#define GRN_OBJ_DECR   (0x03)

Subtract the specified value from the record/column value.

◆ GRN_OBJ_DO_SHALLOW_COPY

#define GRN_OBJ_DO_SHALLOW_COPY   (GRN_OBJ_REFER | GRN_OBJ_OUTPLACE)

◆ GRN_OBJ_FIN

#define GRN_OBJ_FIN (   ctx,
  obj 
)    (grn_obj_close((ctx), (obj)))

◆ GRN_OBJ_FLAGS_MASK

#define GRN_OBJ_FLAGS_MASK   (0xffff)

◆ GRN_OBJ_GET

#define GRN_OBJ_GET   (0x01 << 4)

◆ GRN_OBJ_GET_DOMAIN

#define GRN_OBJ_GET_DOMAIN (   obj)     ((obj)->header.type == GRN_TABLE_NO_KEY ? GRN_ID_NIL : (obj)->header.domain)

◆ GRN_OBJ_INCR

#define GRN_OBJ_INCR   (0x02)

Add the specified value to the record/column value.

◆ GRN_OBJ_INDEX_LARGE

#define GRN_OBJ_INDEX_LARGE   (0x01 << 18)

◆ GRN_OBJ_INDEX_MEDIUM

#define GRN_OBJ_INDEX_MEDIUM   (0x01 << 17)

◆ GRN_OBJ_INDEX_SMALL

#define GRN_OBJ_INDEX_SMALL   (0x01 << 16)

◆ GRN_OBJ_INIT

#define GRN_OBJ_INIT (   obj,
  obj_type,
  obj_flags,
  obj_domain 
)
Value:
do { \
(obj)->header.type = (obj_type); \
(obj)->header.impl_flags = (obj_flags); \
(obj)->header.flags = 0; \
(obj)->header.domain = (obj_domain); \
(obj)->u.b.head = NULL; \
(obj)->u.b.curr = NULL; \
(obj)->u.b.tail = NULL; \
} while (0)

◆ GRN_OBJ_INVALID_ERROR

#define GRN_OBJ_INVALID_ERROR   (0x00 << 22)

◆ GRN_OBJ_INVALID_IGNORE

#define GRN_OBJ_INVALID_IGNORE   (0x02 << 22)

◆ GRN_OBJ_INVALID_MASK

#define GRN_OBJ_INVALID_MASK   (0x03 << 22)

◆ GRN_OBJ_INVALID_WARN

#define GRN_OBJ_INVALID_WARN   (0x01 << 22)

◆ GRN_OBJ_INVISIBLE

#define GRN_OBJ_INVISIBLE   ((uint32_t)(0x01 << 31))

◆ GRN_OBJ_KEY_FLOAT

#define GRN_OBJ_KEY_FLOAT   (0x02 << 3)

Float (Used to create data types. Used to determine sorting method.)

◆ GRN_OBJ_KEY_GEO_POINT

#define GRN_OBJ_KEY_GEO_POINT   (0x03 << 3)

Latitude and longitude (grn_geo_point) (Used to create data types. Used to determine sorting method.)

◆ GRN_OBJ_KEY_INT

#define GRN_OBJ_KEY_INT   (0x01 << 3)

Signed integer (Used to create data types. Used to determine sorting method.)

◆ GRN_OBJ_KEY_LARGE

#define GRN_OBJ_KEY_LARGE   (0x01 << 16)

◆ GRN_OBJ_KEY_MASK

#define GRN_OBJ_KEY_MASK   (0x07 << 3)

Mask of GRN_OBJ_KEY_*

◆ GRN_OBJ_KEY_NORMALIZE

#define GRN_OBJ_KEY_NORMALIZE   (0x01 << 7)
Deprecated:
This was used when only NormalizerAuto was available. Now you can specify a normalizer, so there is no need to use it.

◆ GRN_OBJ_KEY_UINT

#define GRN_OBJ_KEY_UINT   (0x00 << 3)

Unsigned integer (Used to create data types. Used to determine sorting method.)

◆ GRN_OBJ_KEY_VAR_SIZE

#define GRN_OBJ_KEY_VAR_SIZE   (0x01 << 14)

It shows that the key is variable size not fixed size. If you're using DB API such as grn_table_create(), you don't need to use this. You can use type object such as ShortText instead. If you're using a low-level table such as grn_hash and grn_pat directly, you can use this to show that the table uses variable size key.

◆ GRN_OBJ_KEY_WITH_SIS

#define GRN_OBJ_KEY_WITH_SIS   (0x01 << 6)

Enable semi-infinite string support. This is only available with GRN_OBJ_TABLE_PAT_KEY. You can use efficient suffix search with this but it requires more storage/memory size. Because it generates many additional data for efficient suffix search implicitly.

◆ GRN_OBJ_LOCK

#define GRN_OBJ_LOCK   (0x01 << 6)

◆ GRN_OBJ_MISSING_ADD

#define GRN_OBJ_MISSING_ADD   (0x00 << 20)

◆ GRN_OBJ_MISSING_IGNORE

#define GRN_OBJ_MISSING_IGNORE   (0x01 << 20)

◆ GRN_OBJ_MISSING_MASK

#define GRN_OBJ_MISSING_MASK   (0x03 << 20)

◆ GRN_OBJ_MISSING_NIL

#define GRN_OBJ_MISSING_NIL   (0x02 << 20)

◆ GRN_OBJ_MUTABLE

#define GRN_OBJ_MUTABLE (   obj)    ((obj) && (obj)->header.type <= GRN_VECTOR)

◆ GRN_OBJ_NO_SUBREC

#define GRN_OBJ_NO_SUBREC   (0x00 << 13)

◆ GRN_OBJ_OUTPLACE

#define GRN_OBJ_OUTPLACE   (0x01 << 1)

◆ GRN_OBJ_OWN

#define GRN_OBJ_OWN   (0x01 << 5)

A flag to represent that GRN_PTR or GRN_PVECTOR owns associated grn_obj. When this flag is set, the associated grn_obj will be automatically closed using grn_obj_close when owning GRN_PTR or GRN_PVECTOR is closed.

You can use this flag only with GRN_PTR_INIT.

◆ GRN_OBJ_PERSISTENT

#define GRN_OBJ_PERSISTENT   (0x01 << 15)

Persistent object. When set, the object is persisted to storage.

◆ GRN_OBJ_PREPEND

#define GRN_OBJ_PREPEND   (0x05)

Prepend the specified value to the column value.

◆ GRN_OBJ_REFER

#define GRN_OBJ_REFER   (0x01 << 0)

◆ GRN_OBJ_REMOVE_DEPENDENT

#define GRN_OBJ_REMOVE_DEPENDENT   (0x01 << 0)

◆ GRN_OBJ_REMOVE_ENSURE

#define GRN_OBJ_REMOVE_ENSURE   (0x01 << 1)

◆ GRN_OBJ_RING_BUFFER

#define GRN_OBJ_RING_BUFFER   (0x01 << 10)

◆ GRN_OBJ_SET

#define GRN_OBJ_SET   (0x01)

Replace the value of the record/column with the specified value.

◆ GRN_OBJ_SET_MASK

#define GRN_OBJ_SET_MASK   (0x07)

◆ GRN_OBJ_TABLE_DAT_KEY

#define GRN_OBJ_TABLE_DAT_KEY   (0x02)

◆ GRN_OBJ_TABLE_HASH_KEY

#define GRN_OBJ_TABLE_HASH_KEY   (0x00)

◆ GRN_OBJ_TABLE_NO_KEY

#define GRN_OBJ_TABLE_NO_KEY   (0x03)

◆ GRN_OBJ_TABLE_PAT_KEY

#define GRN_OBJ_TABLE_PAT_KEY   (0x01)

◆ GRN_OBJ_TABLE_TYPE_MASK

#define GRN_OBJ_TABLE_TYPE_MASK   (0x07)

◆ GRN_OBJ_TEMPORARY

#define GRN_OBJ_TEMPORARY   (0x00 << 15)

◆ GRN_OBJ_UNIT_DOCUMENT_NONE

#define GRN_OBJ_UNIT_DOCUMENT_NONE   (0x00 << 8)

◆ GRN_OBJ_UNIT_DOCUMENT_POSITION

#define GRN_OBJ_UNIT_DOCUMENT_POSITION   (0x02 << 8)

◆ GRN_OBJ_UNIT_DOCUMENT_SECTION

#define GRN_OBJ_UNIT_DOCUMENT_SECTION   (0x01 << 8)

◆ GRN_OBJ_UNIT_MASK

#define GRN_OBJ_UNIT_MASK   (0x0f << 8)

◆ GRN_OBJ_UNIT_POSITION_NONE

#define GRN_OBJ_UNIT_POSITION_NONE   (0x05 << 8)

◆ GRN_OBJ_UNIT_SECTION_NONE

#define GRN_OBJ_UNIT_SECTION_NONE   (0x03 << 8)

◆ GRN_OBJ_UNIT_SECTION_POSITION

#define GRN_OBJ_UNIT_SECTION_POSITION   (0x04 << 8)

◆ GRN_OBJ_UNIT_USERDEF_DOCUMENT

#define GRN_OBJ_UNIT_USERDEF_DOCUMENT   (0x06 << 8)

◆ GRN_OBJ_UNIT_USERDEF_POSITION

#define GRN_OBJ_UNIT_USERDEF_POSITION   (0x08 << 8)

◆ GRN_OBJ_UNIT_USERDEF_SECTION

#define GRN_OBJ_UNIT_USERDEF_SECTION   (0x07 << 8)

◆ GRN_OBJ_UNLOCK

#define GRN_OBJ_UNLOCK   (0x01 << 7)

◆ GRN_OBJ_VECTOR

#define GRN_OBJ_VECTOR   (0x01 << 7)

◆ GRN_OBJ_VISIBLE

#define GRN_OBJ_VISIBLE   ((uint32_t)(0x00 << 31))

◆ GRN_OBJ_WEIGHT_BFLOAT16

#define GRN_OBJ_WEIGHT_BFLOAT16   (0x01 << 11)

◆ GRN_OBJ_WEIGHT_FLOAT32

#define GRN_OBJ_WEIGHT_FLOAT32   (0x01 << 19)

◆ GRN_OBJ_WITH_POSITION

#define GRN_OBJ_WITH_POSITION   (0x01 << 9)

Enable position information. This flag is only effective when used in conjunction with GRN_OBJ_COLUMN_INDEX. When set, the inverted index will store the occurrence positions of terms within documents. This enables phrase searches. Full-text search indexes must have position information enabled because phrase searches rely on it.

◆ GRN_OBJ_WITH_SECTION

#define GRN_OBJ_WITH_SECTION   (0x01 << 7)

Enable section information. This flag is only effective when used in conjunction with GRN_OBJ_COLUMN_INDEX. When set, the inverted index will store section information. This allows the same index column to support multiple documents using multiple columns.

◆ GRN_OBJ_WITH_SUBREC

#define GRN_OBJ_WITH_SUBREC   (0x01 << 13)

◆ GRN_OBJ_WITH_WEIGHT

#define GRN_OBJ_WITH_WEIGHT   (0x01 << 8)

Enable weight information. This flag is only effective when used in conjunction with GRN_OBJ_COLUMN_INDEX. When set, the inverted index will store weight information. This allows search results to be scored based on the weights assigned to individual columns.

◆ GRN_OP_BUT

#define GRN_OP_BUT   GRN_OP_AND_NOT

◆ GRN_OP_NEAR2

#define GRN_OP_NEAR2   GRN_OP_NEAR_NO_OFFSET

◆ GRN_PATSNIP

#define GRN_PATSNIP   (0x0c)

◆ GRN_PROC

#define GRN_PROC   (0x21)

◆ GRN_PTR

#define GRN_PTR   (0x03)

Buffer that has a grn_obj *. The hold grn_obj * can be closed automatically when this is closed by specifying GRN_OBJ_OWN flag.

◆ GRN_PTR_INIT

#define GRN_PTR_INIT (   obj,
  flags,
  domain 
)
Value:
GRN_OBJ_INIT((obj), \
((flags) & GRN_OBJ_VECTOR) ? GRN_PVECTOR : GRN_PTR, \
((flags) & (GRN_OBJ_DO_SHALLOW_COPY | GRN_OBJ_OWN)), \
(domain))
GRN_OBJ_VECTOR
#define GRN_OBJ_VECTOR
Definition groonga.h:2734
GRN_PVECTOR
#define GRN_PVECTOR
Definition groonga.h:876
GRN_OBJ_OWN
#define GRN_OBJ_OWN
Definition groonga.h:945
GRN_OBJ_INIT
#define GRN_OBJ_INIT(obj, obj_type, obj_flags, obj_domain)
Definition groonga.h:947
GRN_PTR
#define GRN_PTR
Definition groonga.h:873
GRN_OBJ_DO_SHALLOW_COPY
#define GRN_OBJ_DO_SHALLOW_COPY
Definition groonga.h:2732

◆ GRN_PTR_POP

#define GRN_PTR_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, grn_obj *, NULL)

◆ GRN_PTR_PUT

#define GRN_PTR_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
grn_obj *_val = (grn_obj *)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_obj *)); \
} while (0)

◆ GRN_PTR_SET

#define GRN_PTR_SET (   ctx,
  obj,
  val 
)
Value:
do { \
grn_obj *_val = (grn_obj *)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_obj *)); \
} while (0)

◆ GRN_PTR_SET_AT

#define GRN_PTR_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
grn_obj *_val = (grn_obj *)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(grn_obj *), \
sizeof(grn_obj *)); \
} while (0)

◆ GRN_PTR_VALUE

#define GRN_PTR_VALUE (   obj)    (*((grn_obj **)GRN_BULK_HEAD(obj)))

◆ GRN_PTR_VALUE_AT

#define GRN_PTR_VALUE_AT (   obj,
  offset 
)    (((grn_obj **)GRN_BULK_HEAD(obj))[offset])

◆ GRN_PTR_VECTOR_SIZE

#define GRN_PTR_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, grn_obj *)

◆ GRN_PVECTOR

#define GRN_PVECTOR   (0x05) /* vector of grn_obj* */

◆ GRN_QUERY

#define GRN_QUERY   (0x08)

◆ GRN_QUERY_ADJ_DEC

#define GRN_QUERY_ADJ_DEC   '<'

◆ GRN_QUERY_ADJ_INC

#define GRN_QUERY_ADJ_INC   '>'

◆ GRN_QUERY_ADJ_NEG

#define GRN_QUERY_ADJ_NEG   '~'

◆ GRN_QUERY_AND

#define GRN_QUERY_AND   '+'

◆ GRN_QUERY_AND_NOT

#define GRN_QUERY_AND_NOT   '-'

◆ GRN_QUERY_COLUMN

#define GRN_QUERY_COLUMN   ':'

◆ GRN_QUERY_ESCAPE

#define GRN_QUERY_ESCAPE   '\\'

◆ GRN_QUERY_LOG

#define GRN_QUERY_LOG (   ctx,
  flag,
  mark,
  format,
  ... 
)
Value:
do { \
if (grn_query_logger_pass(ctx, flag)) { \
grn_query_logger_put(ctx, (flag), (mark), format, __VA_ARGS__); \
} \
} while (0)
grn_query_logger_pass
GRN_API bool grn_query_logger_pass(grn_ctx *ctx, unsigned int flag)

◆ GRN_QUERY_LOG_ALL

#define GRN_QUERY_LOG_ALL
Value:
(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)
GRN_QUERY_LOG_COMMAND
#define GRN_QUERY_LOG_COMMAND
Definition groonga.h:212
GRN_QUERY_LOG_RESULT_CODE
#define GRN_QUERY_LOG_RESULT_CODE
Definition groonga.h:213
GRN_QUERY_LOG_SCORE
#define GRN_QUERY_LOG_SCORE
Definition groonga.h:217
GRN_QUERY_LOG_DESTINATION
#define GRN_QUERY_LOG_DESTINATION
Definition groonga.h:214
GRN_QUERY_LOG_CACHE
#define GRN_QUERY_LOG_CACHE
Definition groonga.h:215
GRN_QUERY_LOG_SIZE
#define GRN_QUERY_LOG_SIZE
Definition groonga.h:216

◆ GRN_QUERY_LOG_CACHE

#define GRN_QUERY_LOG_CACHE   (0x01 << 3)

◆ GRN_QUERY_LOG_COMMAND

#define GRN_QUERY_LOG_COMMAND   (0x01 << 0)

◆ GRN_QUERY_LOG_DEFAULT

#define GRN_QUERY_LOG_DEFAULT   GRN_QUERY_LOG_ALL

◆ GRN_QUERY_LOG_DESTINATION

#define GRN_QUERY_LOG_DESTINATION   (0x01 << 2)

◆ GRN_QUERY_LOG_NONE

#define GRN_QUERY_LOG_NONE   (0x00)

◆ GRN_QUERY_LOG_RESULT_CODE

#define GRN_QUERY_LOG_RESULT_CODE   (0x01 << 1)

◆ GRN_QUERY_LOG_SCORE

#define GRN_QUERY_LOG_SCORE   (0x01 << 5)

◆ GRN_QUERY_LOG_SIZE

#define GRN_QUERY_LOG_SIZE   (0x01 << 4)

◆ GRN_QUERY_PARENL

#define GRN_QUERY_PARENL   '('

◆ GRN_QUERY_PARENR

#define GRN_QUERY_PARENR   ')'

◆ GRN_QUERY_PREFIX

#define GRN_QUERY_PREFIX   '*'

◆ GRN_QUERY_QUOTEL

#define GRN_QUERY_QUOTEL   '"'

◆ GRN_QUERY_QUOTER

#define GRN_QUERY_QUOTER   '"'

◆ GRN_RECORD_INIT

#define GRN_RECORD_INIT   GRN_VALUE_FIX_SIZE_INIT

◆ GRN_RECORD_POP

#define GRN_RECORD_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, grn_id, GRN_ID_NIL)

◆ GRN_RECORD_PUT

#define GRN_RECORD_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
grn_id _val = (grn_id)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_id)); \
} while (0)

◆ GRN_RECORD_SET

#define GRN_RECORD_SET (   ctx,
  obj,
  val 
)
Value:
do { \
grn_id _val = (grn_id)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_id)); \
} while (0)

◆ GRN_RECORD_SET_AT

#define GRN_RECORD_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
grn_id _val = (grn_id)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(grn_id), \
sizeof(grn_id)); \
} while (0)

◆ GRN_RECORD_VALUE

#define GRN_RECORD_VALUE (   obj)    (*((grn_id *)GRN_BULK_HEAD(obj)))

◆ GRN_RECORD_VALUE_AT

#define GRN_RECORD_VALUE_AT (   obj,
  offset 
)     (((grn_id *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_RECORD_VECTOR_SIZE

#define GRN_RECORD_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, grn_id)

◆ GRN_SHORT_BINARY_INIT

#define GRN_SHORT_BINARY_INIT (   obj,
  flags 
)     GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_BINARY)

◆ GRN_SHORT_TEXT_INIT

#define GRN_SHORT_TEXT_INIT (   obj,
  flags 
)     GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_TEXT)

◆ GRN_SLOW_LOG_POP_BEGIN

#define GRN_SLOW_LOG_POP_BEGIN (   ctx,
  level,
  elapsed_time 
)
Value:
do { \
if (grn_logger_pass(ctx, level)) { \
double elapsed_time = grn_slow_log_pop(ctx); \
if (grn_slow_log_is_slow(ctx, elapsed_time)) {
grn_slow_log_pop
GRN_API double grn_slow_log_pop(grn_ctx *ctx)
grn_slow_log_is_slow
GRN_API bool grn_slow_log_is_slow(grn_ctx *ctx, double elapsed_time)

◆ GRN_SLOW_LOG_POP_END

#define GRN_SLOW_LOG_POP_END (   ctx)
Value:
} \
} \
} \
while (false)

◆ GRN_SLOW_LOG_PUSH

#define GRN_SLOW_LOG_PUSH (   ctx,
  level 
)
Value:
do { \
if (grn_logger_pass(ctx, level)) { \
grn_slow_log_push(ctx); \
} \
} while (false)

◆ GRN_SNIP

#define GRN_SNIP   (0x0b)

◆ GRN_SNIP_COPY_TAG

#define GRN_SNIP_COPY_TAG   (0x01 << 1)

◆ GRN_SNIP_MAPPING_HTML_ESCAPE

#define GRN_SNIP_MAPPING_HTML_ESCAPE   ((grn_snip_mapping *)-1)

◆ GRN_SNIP_NORMALIZE

#define GRN_SNIP_NORMALIZE   (0x01 << 0)

◆ GRN_SNIP_SKIP_LEADING_SPACES

#define GRN_SNIP_SKIP_LEADING_SPACES   (0x01 << 2)

◆ GRN_STRING

#define GRN_STRING   (0x0d)

◆ GRN_TABLE_DAT_KEY

#define GRN_TABLE_DAT_KEY   (0x32)

◆ GRN_TABLE_FUZZY_SEARCH_SKIP_TOKENIZE

#define GRN_TABLE_FUZZY_SEARCH_SKIP_TOKENIZE   (0x01 << 3)

◆ GRN_TABLE_FUZZY_SEARCH_USE_MAX_DISTANCE_RATIO

#define GRN_TABLE_FUZZY_SEARCH_USE_MAX_DISTANCE_RATIO   (0x01 << 2)

◆ GRN_TABLE_FUZZY_SEARCH_USE_PREFIX_LENGTH

#define GRN_TABLE_FUZZY_SEARCH_USE_PREFIX_LENGTH   (0x01 << 1)

◆ GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION

#define GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION   (0x01 << 0)

◆ GRN_TABLE_HASH_KEY

#define GRN_TABLE_HASH_KEY   (0x30)

◆ GRN_TABLE_NO_KEY

#define GRN_TABLE_NO_KEY   (0x33)

◆ GRN_TABLE_PAT_KEY

#define GRN_TABLE_PAT_KEY   (0x31)

◆ GRN_TEXT_EQUAL_CSTRING

#define GRN_TEXT_EQUAL_CSTRING (   bulk,
  string 
)
Value:
(GRN_TEXT_LEN(bulk) == strlen(string) && \
memcmp(GRN_TEXT_VALUE(bulk), string, GRN_TEXT_LEN(bulk)) == 0)
GRN_TEXT_VALUE
#define GRN_TEXT_VALUE(obj)
Definition groonga.h:2785
GRN_TEXT_LEN
#define GRN_TEXT_LEN(obj)
Definition groonga.h:2786

◆ GRN_TEXT_INIT

#define GRN_TEXT_INIT (   obj,
  flags 
)     GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_TEXT)

◆ GRN_TEXT_LEN

#define GRN_TEXT_LEN (   obj)    GRN_BULK_VSIZE(obj)

◆ GRN_TEXT_PUT

#define GRN_TEXT_PUT (   ctx,
  obj,
  str,
  len 
)     grn_bulk_write((ctx), (obj), (const char *)(str), (unsigned int)(len))

◆ GRN_TEXT_PUTC

#define GRN_TEXT_PUTC (   ctx,
  obj,
  c 
)
Value:
do { \
char _c = (c); \
grn_bulk_write((ctx), (obj), &_c, 1); \
} while (0)

◆ GRN_TEXT_PUTS

#define GRN_TEXT_PUTS (   ctx,
  obj,
  str 
)     GRN_TEXT_PUT((ctx), (obj), (str), strlen(str))

◆ GRN_TEXT_SET

#define GRN_TEXT_SET (   ctx,
  obj,
  str,
  len 
)
Value:
do { \
if ((obj)->header.impl_flags & GRN_OBJ_REFER) { \
GRN_TEXT_SET_REF((obj), (str), (len)); \
} else { \
grn_bulk_write_from((ctx), \
(obj), \
(const char *)(str), \
0, \
(unsigned int)(len)); \
} \
} while (0)

◆ GRN_TEXT_SET_REF

#define GRN_TEXT_SET_REF (   obj,
  str,
  len 
)
Value:
do { \
(obj)->u.b.head = (char *)(str); \
(obj)->u.b.curr = (char *)(str) + (len); \
} while (0)

◆ GRN_TEXT_SETS

#define GRN_TEXT_SETS (   ctx,
  obj,
  str 
)     GRN_TEXT_SET((ctx), (obj), (str), strlen(str))

◆ GRN_TEXT_VALUE

#define GRN_TEXT_VALUE (   obj)    GRN_BULK_HEAD(obj)

◆ GRN_TIME_INIT

#define GRN_TIME_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TIME)

◆ GRN_TIME_POP

#define GRN_TIME_POP   GRN_INT64_POP

◆ GRN_TIME_PUT

#define GRN_TIME_PUT   GRN_INT64_PUT

◆ GRN_TIME_SET

#define GRN_TIME_SET   GRN_INT64_SET

◆ GRN_TIME_SET_AT

#define GRN_TIME_SET_AT   GRN_INT64_SET_AT

◆ GRN_TIME_VALUE

#define GRN_TIME_VALUE   GRN_INT64_VALUE

◆ GRN_TIME_VALUE_AT

#define GRN_TIME_VALUE_AT   GRN_INT64_VALUE_AT

◆ GRN_TIME_VECTOR_SIZE

#define GRN_TIME_VECTOR_SIZE   GRN_INT64_VECTOR_SIZE

◆ GRN_TOKYO_GEO_POINT_INIT

#define GRN_TOKYO_GEO_POINT_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TOKYO_GEO_POINT)

◆ GRN_TRUE

#define GRN_TRUE   true

◆ GRN_TYPE

#define GRN_TYPE   (0x20)

◆ GRN_UINT16_INIT

#define GRN_UINT16_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT16)

◆ GRN_UINT16_POP

#define GRN_UINT16_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, uint16_t, 0)

◆ GRN_UINT16_PUT

#define GRN_UINT16_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
uint16_t _val = (uint16_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint16_t)); \
} while (0)

◆ GRN_UINT16_SET

#define GRN_UINT16_SET (   ctx,
  obj,
  val 
)
Value:
do { \
uint16_t _val = (uint16_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint16_t)); \
} while (0)

◆ GRN_UINT16_SET_AT

#define GRN_UINT16_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
uint16_t _val = (uint16_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(uint16_t), \
sizeof(uint16_t)); \
} while (0)

◆ GRN_UINT16_VALUE

#define GRN_UINT16_VALUE (   obj)    (*((uint16_t *)GRN_BULK_HEAD(obj)))

◆ GRN_UINT16_VALUE_AT

#define GRN_UINT16_VALUE_AT (   obj,
  offset 
)     (((uint16_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_UINT16_VECTOR_SIZE

#define GRN_UINT16_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, uint16_t)

◆ GRN_UINT32_INIT

#define GRN_UINT32_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT32)

◆ GRN_UINT32_POP

#define GRN_UINT32_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, uint32_t, 0)

◆ GRN_UINT32_PUT

#define GRN_UINT32_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
uint32_t _val = (uint32_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int)); \
} while (0)

◆ GRN_UINT32_SET

#define GRN_UINT32_SET (   ctx,
  obj,
  val 
)
Value:
do { \
uint32_t _val = (uint32_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint32_t)); \
} while (0)

◆ GRN_UINT32_SET_AT

#define GRN_UINT32_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
uint32_t _val = (uint32_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(uint32_t), \
sizeof(uint32_t)); \
} while (0)

◆ GRN_UINT32_VALUE

#define GRN_UINT32_VALUE (   obj)    (*((uint32_t *)GRN_BULK_HEAD(obj)))

◆ GRN_UINT32_VALUE_AT

#define GRN_UINT32_VALUE_AT (   obj,
  offset 
)     (((uint32_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_UINT32_VECTOR_SIZE

#define GRN_UINT32_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, uint32_t)

◆ GRN_UINT64_INIT

#define GRN_UINT64_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT64)

◆ GRN_UINT64_POP

#define GRN_UINT64_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, uint64_t, 0)

◆ GRN_UINT64_PUT

#define GRN_UINT64_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
uint64_t _val = (uint64_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint64_t)); \
} while (0)

◆ GRN_UINT64_SET

#define GRN_UINT64_SET (   ctx,
  obj,
  val 
)
Value:
do { \
uint64_t _val = (uint64_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint64_t)); \
} while (0)

◆ GRN_UINT64_SET_AT

#define GRN_UINT64_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
uint64_t _val = (uint64_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(uint64_t), \
sizeof(uint64_t)); \
} while (0)

◆ GRN_UINT64_VALUE

#define GRN_UINT64_VALUE (   obj)    (*((uint64_t *)GRN_BULK_HEAD(obj)))

◆ GRN_UINT64_VALUE_AT

#define GRN_UINT64_VALUE_AT (   obj,
  offset 
)     (((uint64_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_UINT64_VECTOR_SIZE

#define GRN_UINT64_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, uint64_t)

◆ GRN_UINT8_INIT

#define GRN_UINT8_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT8)

◆ GRN_UINT8_POP

#define GRN_UINT8_POP (   obj,
  value 
)    GRN_BULK_POP(obj, value, uint8_t, 0)

◆ GRN_UINT8_PUT

#define GRN_UINT8_PUT (   ctx,
  obj,
  val 
)
Value:
do { \
uint8_t _val = (uint8_t)(val); \
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint8_t)); \
} while (0)

◆ GRN_UINT8_SET

#define GRN_UINT8_SET (   ctx,
  obj,
  val 
)
Value:
do { \
uint8_t _val = (uint8_t)(val); \
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint8_t)); \
} while (0)

◆ GRN_UINT8_SET_AT

#define GRN_UINT8_SET_AT (   ctx,
  obj,
  offset,
  val 
)
Value:
do { \
uint8_t _val = (uint8_t)(val); \
grn_bulk_write_from((ctx), \
(obj), \
(char *)&_val, \
(offset) * sizeof(uint8_t), \
sizeof(uint8_t)); \
} while (0)

◆ GRN_UINT8_VALUE

#define GRN_UINT8_VALUE (   obj)    (*((uint8_t *)GRN_BULK_HEAD(obj)))

◆ GRN_UINT8_VALUE_AT

#define GRN_UINT8_VALUE_AT (   obj,
  offset 
)     (((uint8_t *)GRN_BULK_HEAD(obj))[offset])

◆ GRN_UINT8_VECTOR_SIZE

#define GRN_UINT8_VECTOR_SIZE (   obj)    GRN_BULK_VECTOR_SIZE(obj, uint8_t)

◆ GRN_UVECTOR

#define GRN_UVECTOR   (0x04)

◆ GRN_VALUE_FIX_SIZE_INIT

#define GRN_VALUE_FIX_SIZE_INIT (   obj,
  flags,
  domain 
)
Value:
GRN_OBJ_INIT((obj), \
((flags) & GRN_OBJ_VECTOR) ? GRN_UVECTOR : GRN_BULK, \
((flags) & GRN_OBJ_DO_SHALLOW_COPY), \
(domain))
GRN_UVECTOR
#define GRN_UVECTOR
Definition groonga.h:875
GRN_BULK
#define GRN_BULK
Definition groonga.h:868

◆ GRN_VALUE_VAR_SIZE_INIT

#define GRN_VALUE_VAR_SIZE_INIT (   obj,
  flags,
  domain 
)
Value:
GRN_OBJ_INIT((obj), \
((flags) & GRN_OBJ_VECTOR) ? GRN_VECTOR : GRN_BULK, \
((flags) & GRN_OBJ_DO_SHALLOW_COPY), \
(domain))

◆ GRN_VECTOR

#define GRN_VECTOR   (0x06) /* vector of arbitrary data */

◆ GRN_VOID

#define GRN_VOID   (0x00)

◆ GRN_VOID_INIT

#define GRN_VOID_INIT (   obj)    GRN_OBJ_INIT((obj), GRN_VOID, 0, GRN_DB_VOID)

◆ GRN_WGS84_GEO_POINT_INIT

#define GRN_WGS84_GEO_POINT_INIT (   obj,
  flags 
)     GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_WGS84_GEO_POINT)

Typedef Documentation

◆ grn_bool

typedef bool grn_bool

◆ grn_close_func

typedef void(* grn_close_func) (grn_ctx *ctx, void *data)

◆ grn_column_flags

typedef uint32_t grn_column_flags

◆ grn_ctx

typedef struct _grn_ctx grn_ctx

grn_ctx is the most important object.

grn_ctx keeps the current information such as:

  • The last occurred error.
  • The current encoding.
  • The default thresholds.
    • e.g. match_escalation_threshold.
  • The default command version.

grn_ctx provides platform features such as:

  • Memory management.
  • Logging.
Note
Most APIs receive grn_ctx as the first argument.
Attention
You can't use the same grn_ctx from two or more threads. You need to create a grn_ctx for a thread. You can use two or more grn_ctx in a thread but it is not needed for usual use-case.

◆ grn_ctx_info

typedef struct _grn_ctx_info grn_ctx_info

◆ grn_fuzzy_search_optarg

typedef struct _grn_fuzzy_search_optarg grn_fuzzy_search_optarg

◆ grn_id

typedef uint32_t grn_id

◆ grn_index_datum

typedef struct _grn_index_datum grn_index_datum

◆ grn_logger

typedef struct _grn_logger grn_logger

◆ grn_logger_info

typedef struct _grn_logger_info grn_logger_info

◆ grn_match_info

typedef struct _grn_match_info grn_match_info

◆ grn_obj

typedef struct _grn_obj grn_obj

The generic Groonga object type.

This is a generic type to represent most Groonga objects such as database, table, column, buffer and so on. You can use grn_obj to represent different types of objects. For example, you can use grn_obj both for grn_hash and grn_pat. This is convenient to provide generic API. For example, you can use grn_obj_get_value for table, column and accessor.

This is convenient but this may be difficult to understand when you don't have a common knowledge of object-oriented programming in C. Here are some examples of common grn_obj usages:

Buffer

You can use grn_obj as a buffer. You can store scalar values or vector values in a grn_obj.

For this usage, you need to allocate a grn_obj on stack or heap. In general, stack is used to reduce memory allocation cost. Then you need to initialize the allocated grn_obj by GRN_*_INIT() macros such as GRN_TEXT_INIT and GRN_INT32_INIT. You need to free the allocated grn_obj when it's no longer needed. You can use GRN_OBJ_FIN or grn_obj_close for it. (GRN_OBJ_FIN is an alias of grn_obj_close.) In general, GRN_OBJ_FIN is used for a grn_obj in stack.

Here is an example to use grn_obj as a text buffer:

grn_obj text_buffer;
GRN_TEXT_INIT(&text_buffer, 0);
GRN_TEXT_PUTS(ctx, &text_buffer, "hello ");
grn_text_printf(ctx, &text_buffer, "%s!", "world");
GRN_OBJ_FIN(ctx, &text_buffer);
GRN_OBJ_FIN
#define GRN_OBJ_FIN(ctx, obj)
Definition groonga.h:958
GRN_TEXT_PUTS
#define GRN_TEXT_PUTS(ctx, obj, str)
Definition groonga.h:2781
grn_text_printf
GRN_API grn_rc grn_text_printf(grn_ctx *ctx, grn_obj *bulk, const char *format,...) GRN_ATTRIBUTE_PRINTF(3)
GRN_TEXT_INIT
#define GRN_TEXT_INIT(obj, flags)
Definition groonga.h:2750

Object

You can use grn_obj as a generic type for database, table, column and so on. In this usage, you use a heap allocated grn_obj. So grn_obj * is used instead of grn_obj.

For example, you can use grn_db_open to open a database:

grn_obj *db = grn_db_open(ctx, "/tmp/db/db");
grn_db_open
GRN_API grn_obj * grn_db_open(grn_ctx *ctx, const char *path)
Open the database.

You can use grn_obj_close to free the opened database:

grn_obj_close(ctx, db);
grn_obj_close
GRN_API grn_rc grn_obj_close(grn_ctx *ctx, grn_obj *obj)
Close an object.

◆ grn_obj_flags

typedef uint16_t grn_obj_flags

◆ grn_obj_header

typedef struct _grn_obj_header grn_obj_header

◆ grn_plugin_func

typedef grn_rc(* grn_plugin_func) (grn_ctx *ctx)

◆ grn_proc_func

typedef grn_obj * grn_proc_func(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)

◆ grn_query_logger

typedef struct _grn_query_logger grn_query_logger

◆ grn_recv_handler_func

typedef void(* grn_recv_handler_func) (grn_ctx *ctx, int flags, void *user_data)

◆ grn_search_optarg

typedef struct _grn_search_optarg grn_search_optarg

◆ grn_section

typedef struct _grn_section grn_section

◆ grn_snip_mapping

typedef struct _grn_snip_mapping grn_snip_mapping

◆ grn_table_cursor

typedef grn_obj grn_table_cursor

◆ grn_table_delete_optarg

typedef struct _grn_table_delete_optarg grn_table_delete_optarg

◆ grn_table_flags

typedef uint32_t grn_table_flags

Enumeration Type Documentation

◆ grn_builtin_tokenizer

enum grn_builtin_tokenizer
Enumerator
GRN_DB_MECAB 
GRN_DB_DELIMIT 
GRN_DB_UNIGRAM 
GRN_DB_BIGRAM 
GRN_DB_TRIGRAM 

◆ grn_builtin_type

enum grn_builtin_type
Enumerator
GRN_DB_VOID 
GRN_DB_DB 
GRN_DB_OBJECT 
GRN_DB_BOOL 
GRN_DB_INT8 
GRN_DB_UINT8 
GRN_DB_INT16 
GRN_DB_UINT16 
GRN_DB_INT32 
GRN_DB_UINT32 
GRN_DB_INT64 
GRN_DB_UINT64 
GRN_DB_FLOAT 
GRN_DB_TIME 
GRN_DB_SHORT_TEXT 
GRN_DB_TEXT 
GRN_DB_LONG_TEXT 
GRN_DB_TOKYO_GEO_POINT 
GRN_DB_WGS84_GEO_POINT 
GRN_DB_FLOAT32 
GRN_DB_BFLOAT16 
GRN_DB_SHORT_BINARY 
GRN_DB_BINARY 
GRN_DB_LONG_BINARY 
GRN_DB_JSON 

◆ grn_command_version

enum grn_command_version
Enumerator
GRN_COMMAND_VERSION_DEFAULT 
GRN_COMMAND_VERSION_1 
GRN_COMMAND_VERSION_2 
GRN_COMMAND_VERSION_3 

◆ grn_content_type

enum grn_content_type

The input/output content format.

Enumerator
GRN_CONTENT_NONE 

The content is in no specific format. This means that either no content is produced or the content remains in its original format.

GRN_CONTENT_TSV 

The content is in a tab-separated values (TSV) format.

GRN_CONTENT_JSON 

The content is in JSON format.

GRN_CONTENT_XML 

The content is in XML format.

GRN_CONTENT_MSGPACK 

The content is in MessagePack format. This requires that MessagePack is available during Groonga's build process. Without it, this type cannot be used.

GRN_CONTENT_GROONGA_COMMAND_LIST 

The content is a list of Groonga commands.

GRN_CONTENT_APACHE_ARROW 

The content is in Apache Arrow format, specifically using the only IPC Streaming Format, although Apache Arrow supports two IPC Formats which are the IPC Streaming Format and the IPC File Format. This requires that Apache Arrow is available during Groonga's build process. Without it, this type cannot be used.

◆ grn_encoding

enum grn_encoding
Enumerator
GRN_ENC_DEFAULT 

The default encoding specified at build time (0). The default at build time is "UTF-8".

GRN_ENC_NONE 

Process strings as binary data (1)

GRN_ENC_EUC_JP 

EUC-JP (2)

GRN_ENC_UTF8 

UTF-8 (3)

GRN_ENC_SJIS 

Shift_JIS (4)

GRN_ENC_LATIN1 

Latin-1 (5)

GRN_ENC_KOI8R 

KOI8-R (6)

◆ grn_hook_entry

enum grn_hook_entry
Enumerator
GRN_HOOK_SET 

Hooked on update.

GRN_HOOK_GET 

Hooked on getting.

GRN_HOOK_INSERT 

Hooked on insertion.

GRN_HOOK_DELETE 

Hooked on deletion.

GRN_HOOK_SELECT 

Hooked during the search process. You can use it to check the status of a process or to terminate a process.

◆ grn_info_type

enum grn_info_type
Enumerator
GRN_INFO_ENCODING 
GRN_INFO_SOURCE 
GRN_INFO_DEFAULT_TOKENIZER 
GRN_INFO_ELEMENT_SIZE 
GRN_INFO_CURR_MAX 
GRN_INFO_MAX_ELEMENT_SIZE 
GRN_INFO_SEG_SIZE 
GRN_INFO_CHUNK_SIZE 
GRN_INFO_MAX_SECTION 
GRN_INFO_HOOK_LOCAL_DATA 
GRN_INFO_ELEMENT_A 
GRN_INFO_ELEMENT_CHUNK 
GRN_INFO_ELEMENT_CHUNK_SIZE 
GRN_INFO_ELEMENT_BUFFER_FREE 
GRN_INFO_ELEMENT_NTERMS 
GRN_INFO_ELEMENT_NTERMS_VOID 
GRN_INFO_ELEMENT_SIZE_IN_CHUNK 
GRN_INFO_ELEMENT_POS_IN_CHUNK 
GRN_INFO_ELEMENT_SIZE_IN_BUFFER 
GRN_INFO_ELEMENT_POS_IN_BUFFER 
GRN_INFO_ELEMENT_ESTIMATE_SIZE 
GRN_INFO_NGRAM_UNIT_SIZE 
GRN_INFO_PARTIAL_MATCH_THRESHOLD 
GRN_INFO_II_SPLIT_THRESHOLD 
GRN_INFO_SUPPORT_ZLIB 
GRN_INFO_SUPPORT_LZ4 
GRN_INFO_NORMALIZER 
GRN_INFO_TOKEN_FILTERS 
GRN_INFO_SUPPORT_ZSTD 
GRN_INFO_SUPPORT_APACHE_ARROW 
GRN_INFO_NORMALIZERS 
GRN_INFO_GENERATOR 
GRN_INFO_SUPPORT_LLAMA_CPP 
GRN_INFO_SUPPORT_FAISS 
GRN_INFO_EXTRACTORS 

◆ grn_log_level

enum grn_log_level
Enumerator
GRN_LOG_NONE 
GRN_LOG_EMERG 
GRN_LOG_ALERT 
GRN_LOG_CRIT 
GRN_LOG_ERROR 
GRN_LOG_WARNING 
GRN_LOG_NOTICE 
GRN_LOG_INFO 
GRN_LOG_DEBUG 
GRN_LOG_DUMP 

◆ grn_operator

enum grn_operator
Enumerator
GRN_OP_PUSH 
GRN_OP_POP 
GRN_OP_NOP 
GRN_OP_CALL 
GRN_OP_INTERN 
GRN_OP_GET_REF 
GRN_OP_GET_VALUE 
GRN_OP_AND 
GRN_OP_AND_NOT 
GRN_OP_OR 
GRN_OP_ASSIGN 
GRN_OP_STAR_ASSIGN 
GRN_OP_SLASH_ASSIGN 
GRN_OP_MOD_ASSIGN 
GRN_OP_PLUS_ASSIGN 
GRN_OP_MINUS_ASSIGN 
GRN_OP_SHIFTL_ASSIGN 
GRN_OP_SHIFTR_ASSIGN 
GRN_OP_SHIFTRR_ASSIGN 
GRN_OP_AND_ASSIGN 
GRN_OP_XOR_ASSIGN 
GRN_OP_OR_ASSIGN 
GRN_OP_JUMP 
GRN_OP_CJUMP 
GRN_OP_COMMA 
GRN_OP_BITWISE_OR 
GRN_OP_BITWISE_XOR 
GRN_OP_BITWISE_AND 
GRN_OP_BITWISE_NOT 
GRN_OP_EQUAL 
GRN_OP_NOT_EQUAL 
GRN_OP_LESS 
GRN_OP_GREATER 
GRN_OP_LESS_EQUAL 
GRN_OP_GREATER_EQUAL 
GRN_OP_IN 
GRN_OP_MATCH 
GRN_OP_NEAR 
GRN_OP_NEAR_NO_OFFSET 
GRN_OP_SIMILAR 
GRN_OP_TERM_EXTRACT 
GRN_OP_SHIFTL 
GRN_OP_SHIFTR 
GRN_OP_SHIFTRR 
GRN_OP_PLUS 
GRN_OP_MINUS 
GRN_OP_STAR 
GRN_OP_SLASH 
GRN_OP_MOD 
GRN_OP_DELETE 
GRN_OP_INCR 
GRN_OP_DECR 
GRN_OP_INCR_POST 
GRN_OP_DECR_POST 
GRN_OP_NOT 
GRN_OP_ADJUST 
GRN_OP_EXACT 
GRN_OP_LCP 
GRN_OP_PARTIAL 
GRN_OP_UNSPLIT 
GRN_OP_PREFIX 
GRN_OP_SUFFIX 
GRN_OP_GEO_DISTANCE1 
GRN_OP_GEO_DISTANCE2 
GRN_OP_GEO_DISTANCE3 
GRN_OP_GEO_DISTANCE4 
GRN_OP_GEO_WITHINP5 
GRN_OP_GEO_WITHINP6 
GRN_OP_GEO_WITHINP8 
GRN_OP_OBJ_SEARCH 
GRN_OP_EXPR_GET_VAR 
GRN_OP_TABLE_CREATE 
GRN_OP_TABLE_SELECT 
GRN_OP_TABLE_SORT 
GRN_OP_TABLE_GROUP 
GRN_OP_JSON_PUT 
GRN_OP_GET_MEMBER 
GRN_OP_REGEXP 
GRN_OP_FUZZY 
GRN_OP_QUORUM 
GRN_OP_NEAR_PHRASE 
GRN_OP_ORDERED_NEAR_PHRASE 
GRN_OP_NEAR_PHRASE_PRODUCT 
GRN_OP_ORDERED_NEAR_PHRASE_PRODUCT 

◆ grn_rc

enum grn_rc
Enumerator
GRN_SUCCESS 

Success (0)

GRN_END_OF_DATA 
GRN_UNKNOWN_ERROR 
GRN_OPERATION_NOT_PERMITTED 
GRN_NO_SUCH_FILE_OR_DIRECTORY 
GRN_NO_SUCH_PROCESS 
GRN_INTERRUPTED_FUNCTION_CALL 
GRN_INPUT_OUTPUT_ERROR 
GRN_NO_SUCH_DEVICE_OR_ADDRESS 
GRN_ARG_LIST_TOO_LONG 
GRN_EXEC_FORMAT_ERROR 
GRN_BAD_FILE_DESCRIPTOR 
GRN_NO_CHILD_PROCESSES 
GRN_RESOURCE_TEMPORARILY_UNAVAILABLE 
GRN_NOT_ENOUGH_SPACE 
GRN_PERMISSION_DENIED 
GRN_BAD_ADDRESS 
GRN_RESOURCE_BUSY 
GRN_FILE_EXISTS 
GRN_IMPROPER_LINK 
GRN_NO_SUCH_DEVICE 
GRN_NOT_A_DIRECTORY 
GRN_IS_A_DIRECTORY 
GRN_INVALID_ARGUMENT 

Invalid function argument (-22)

GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM 
GRN_TOO_MANY_OPEN_FILES 
GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION 
GRN_FILE_TOO_LARGE 
GRN_NO_SPACE_LEFT_ON_DEVICE 
GRN_INVALID_SEEK 
GRN_READ_ONLY_FILE_SYSTEM 
GRN_TOO_MANY_LINKS 
GRN_BROKEN_PIPE 
GRN_DOMAIN_ERROR 
GRN_RESULT_TOO_LARGE 
GRN_RESOURCE_DEADLOCK_AVOIDED 
GRN_NO_MEMORY_AVAILABLE 

Not enough memory available (-35)

GRN_FILENAME_TOO_LONG 
GRN_NO_LOCKS_AVAILABLE 
GRN_FUNCTION_NOT_IMPLEMENTED 
GRN_DIRECTORY_NOT_EMPTY 
GRN_ILLEGAL_BYTE_SEQUENCE 
GRN_SOCKET_NOT_INITIALIZED 
GRN_OPERATION_WOULD_BLOCK 
GRN_ADDRESS_IS_NOT_AVAILABLE 
GRN_NETWORK_IS_DOWN 
GRN_NO_BUFFER 
GRN_SOCKET_IS_ALREADY_CONNECTED 
GRN_SOCKET_IS_NOT_CONNECTED 
GRN_SOCKET_IS_ALREADY_SHUTDOWNED 
GRN_OPERATION_TIMEOUT 
GRN_CONNECTION_REFUSED 
GRN_RANGE_ERROR 
GRN_TOKENIZER_ERROR 
GRN_FILE_CORRUPT 
GRN_INVALID_FORMAT 
GRN_OBJECT_CORRUPT 
GRN_TOO_MANY_SYMBOLIC_LINKS 
GRN_NOT_SOCKET 
GRN_OPERATION_NOT_SUPPORTED 
GRN_ADDRESS_IS_IN_USE 
GRN_ZLIB_ERROR 
GRN_LZ4_ERROR 
GRN_STACK_OVER_FLOW 
GRN_SYNTAX_ERROR 
GRN_RETRY_MAX 
GRN_INCOMPATIBLE_FILE_FORMAT 
GRN_UPDATE_NOT_ALLOWED 
GRN_TOO_SMALL_OFFSET 
GRN_TOO_LARGE_OFFSET 
GRN_TOO_SMALL_LIMIT 
GRN_CAS_ERROR 
GRN_UNSUPPORTED_COMMAND_VERSION 

When a version not supported by the default version set is specified (-71)

GRN_NORMALIZER_ERROR 
GRN_TOKEN_FILTER_ERROR 
GRN_COMMAND_ERROR 
GRN_PLUGIN_ERROR 
GRN_SCORER_ERROR 
GRN_CANCEL 
GRN_WINDOW_FUNCTION_ERROR 
GRN_ZSTD_ERROR 
GRN_CONNECTION_RESET 
GRN_BLOSC_ERROR 
GRN_OPENZL_ERROR 
GRN_EXTRACTOR_ERROR 

Function Documentation

◆ grn_bulk_detach()

GRN_API char * grn_bulk_detach ( grn_ctx *  ctx,
grn_obj *  bulk 
)

◆ grn_bulk_fin()

GRN_API grn_rc grn_bulk_fin ( grn_ctx *  ctx,
grn_obj *  bulk 
)

◆ grn_bulk_reinit()

GRN_API grn_rc grn_bulk_reinit ( grn_ctx *  ctx,
grn_obj *  bulk,
size_t  size 
)

◆ grn_bulk_reserve()

GRN_API grn_rc grn_bulk_reserve ( grn_ctx *  ctx,
grn_obj *  bulk,
size_t  len 
)

◆ grn_bulk_resize()

GRN_API grn_rc grn_bulk_resize ( grn_ctx *  ctx,
grn_obj *  bulk,
size_t  new_size 
)

◆ grn_bulk_space()

GRN_API grn_rc grn_bulk_space ( grn_ctx *  ctx,
grn_obj *  bulk,
size_t  len 
)

◆ grn_bulk_truncate()

GRN_API grn_rc grn_bulk_truncate ( grn_ctx *  ctx,
grn_obj *  bulk,
size_t  len 
)

◆ grn_bulk_write()

GRN_API grn_rc grn_bulk_write ( grn_ctx *  ctx,
grn_obj *  bulk,
const char *  str,
size_t  len 
)

◆ grn_bulk_write_from()

GRN_API grn_rc grn_bulk_write_from ( grn_ctx *  ctx,
grn_obj *  bulk,
const char *  str,
size_t  from,
size_t  len 
)

◆ grn_column_find_index_data()

GRN_API unsigned int grn_column_find_index_data ( grn_ctx *  ctx,
grn_obj *  column,
grn_operator  op,
grn_index_datum *  index_data,
unsigned int  n_index_data 
)

Return indexes that can perform a specified operation by storing it in index_data.

Note
This function replaces the deprecated grn_column_index function.
Since
5.0.1
Parameters
ctxThe context object.
columnThe target column to search for associated indexes.
opThe operator that the indexes should support. (e.g., GRN_OP_EQUAL, GRN_OP_PREFIX, GRN_OP_LESS, and so on.).
index_dataAn array to store information about the found indexes. Each element is a grn_index_datum structure containing details about an index. The caller must allocate this array with at least n_index_data elements.
n_index_dataThe maximum number of entries to store in index_data.
Returns
The total number of found indexes that support the specified operation. If more indexes are found than n_index_data, only the first n_index_data entries are filled in index_data.

◆ grn_column_get_all_index_columns()

GRN_API grn_rc grn_column_get_all_index_columns ( grn_ctx *  ctx,
grn_obj *  column,
grn_obj *  index_columns 
)

◆ grn_column_get_all_index_data()

GRN_API uint32_t grn_column_get_all_index_data ( grn_ctx *  ctx,
grn_obj *  column,
grn_index_datum *  index_data,
uint32_t  n_index_data 
)

◆ grn_column_index()

GRN_API int grn_column_index ( grn_ctx *  ctx,
grn_obj *  column,
grn_operator  op,
grn_obj **  indexbuf,
int  buf_size,
int *  section 
)
Deprecated:
Since 5.0.1. Use grn_column_find_index_data instead.

◆ grn_column_name()

GRN_API int grn_column_name ( grn_ctx *  ctx,
grn_obj *  obj,
char *  namebuf,
int  buf_size 
)

Return a column's name by storing it in namebuf.

If the column has a name and buf_size is greater than or equal to the length of the name, the name is copied into namebuf.

If the length of the name exceeds buf_size, the name is not copied into namebuf, but the length of the name is still returned.

The maximum possible length of the name is limited by GRN_TABLE_MAX_KEY_SIZE.

If the obj is an accessor, it returns the accessor's name instead. For detailed information on accessor's naming conventions, see grn_obj_column.

Parameters
ctxThe context object.
objThe column whose name is to be retrieved.
namebufA buffer allocated by the caller to store the column's name.
buf_sizeThe size of namebuf in bytes.
Returns
The length of the column's name. Returns 0 if the obj parameter is NULL.

◆ grn_column_rename()

GRN_API grn_rc grn_column_rename ( grn_ctx *  ctx,
grn_obj *  column,
const char *  name,
unsigned int  name_size 
)

Rename a column in the database used by the context.

Parameters
ctxThe context object.
columnThe column object to be renamed. It must be a persistent object.
nameThe new name for the column.
name_sizeThe size of the name in bytes.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_INVALID_ARGUMENT is returned if the new name exceeds the maximum allowed size which is defined by GRN_TABLE_MAX_KEY_SIZE.

◆ grn_ctx_at()

GRN_API grn_obj * grn_ctx_at ( grn_ctx *  ctx,
grn_id  id 
)

Retrieve the object corresponding to the specified ID from the context or the database that the context is using.

Parameters
ctxThe context object.
idThe object ID to be retrieved.
Returns
grn_obj if the object that has the specified ID is found, NULL otherwise.

◆ grn_ctx_close()

GRN_API grn_rc grn_ctx_close ( grn_ctx *  ctx)

Close the context.

This function releases memory that was managed by the context and closes. (Internally, grn_ctx_fin is called to release allocated memory.)

Attention
This function closes the context opened by grn_ctx_open. If the context is initialized with grn_ctx_init, it needs to be closed with grn_ctx_fin.
Parameters
ctxThe context object initialized by grn_ctx_open.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_ctx_connect()

GRN_API grn_rc grn_ctx_connect ( grn_ctx *  ctx,
const char *  host,
int  port,
int  flags 
)

◆ grn_ctx_db()

GRN_API grn_obj * grn_ctx_db ( grn_ctx *  ctx)

Retrieve the database that the context is using.

Parameters
ctxThe context object.
Returns
The database object in use, NULL if database is not in use.

◆ grn_ctx_fin()

GRN_API grn_rc grn_ctx_fin ( grn_ctx *  ctx)

Finish the context.

This function releases memory that was managed by the context and finishes.

Attention
This function finishes the context initialized by grn_ctx_init. If the context is opened with grn_ctx_open, it need to be closed with grn_ctx_close.
Parameters
ctxThe context object initialized by grn_ctx_init.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_ctx_get()

GRN_API grn_obj * grn_ctx_get ( grn_ctx *  ctx,
const char *  name,
int  name_size 
)

Retrieve the object corresponding to the specified name from the database that the context is using.

Parameters
ctxThe context object.
nameThe name of the object to be retrieved.
name_sizeThe size of the name in bytes.
Returns
grn_obj if the object that has the specified name is found, NULL otherwise.

◆ grn_ctx_get_all_normalizers()

GRN_API grn_rc grn_ctx_get_all_normalizers ( grn_ctx *  ctx,
grn_obj *  normalizers_buffer 
)

◆ grn_ctx_get_all_tables()

GRN_API grn_rc grn_ctx_get_all_tables ( grn_ctx *  ctx,
grn_obj *  tables_buffer 
)

Retrieve all tables from the database that the context is using.

Note
Ensure that tables_buffer is properly initialized as a GRN_PVECTOR using GRN_PTR_INIT with the GRN_OBJ_VECTOR flag before invoking this function.
Attention
After processing the tables, it is essential to release the allocated resources by un-referring each table object and finalizing the tables_buffer using GRN_OBJ_FIN. Otherwise, memory leaks may occur.

Here is an example of how to use grn_ctx_get_all_tables to retrieve and process all tables:

grn_rc rc;
grn_obj tables;
int i;
int n_tables;
// Initialize the tables buffer as a vector of `grn_obj *`.
GRN_PTR_INIT(&tables, GRN_OBJ_VECTOR, GRN_ID_NIL);
// Retrieve all tables in database that the context is using.
rc = grn_ctx_get_all_tables(ctx, &tables);
if (rc != GRN_SUCCESS) {
GRN_OBJ_FIN(ctx, &tables);
// Handle error appropriately.
return rc;
}
// Calculate the number of tables retrieved.
n_tables = GRN_PTR_VECTOR_SIZE(&tables);
// Iterate over each table.
for (i = 0; i < n_tables; i++) {
grn_obj *table = GRN_PTR_VALUE_AT(&tables, i);
// Use table.
}
// Free resources by un-referring each table when the reference count mode is
// enabled.
for (i = 0; i < n_tables; i++) {
grn_obj *table = GRN_PTR_VALUE_AT(&tables, i);
grn_obj_unref(ctx, table);
}
// Finalize the tables buffer.
GRN_OBJ_FIN(ctx, &tables);
grn_rc
grn_rc
Definition groonga.h:61
GRN_SUCCESS
@ GRN_SUCCESS
Success (0)
Definition groonga.h:63
GRN_PTR_INIT
#define GRN_PTR_INIT(obj, flags, domain)
Definition groonga.h:2869
GRN_ID_NIL
#define GRN_ID_NIL
Means "does not exist".
Definition groonga.h:55
grn_obj_unref
GRN_API void grn_obj_unref(grn_ctx *ctx, grn_obj *obj)
grn_ctx_get_all_tables
GRN_API grn_rc grn_ctx_get_all_tables(grn_ctx *ctx, grn_obj *tables_buffer)
Retrieve all tables from the database that the context is using.
GRN_PTR_VECTOR_SIZE
#define GRN_PTR_VECTOR_SIZE(obj)
Definition groonga.h:3265
GRN_PTR_VALUE_AT
#define GRN_PTR_VALUE_AT(obj, offset)
Definition groonga.h:3150
Parameters
ctxThe context object.
tables_bufferThe buffer to store the retrieved tables (must be prepared by the caller).
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_ctx_get_all_token_filters()

GRN_API grn_rc grn_ctx_get_all_token_filters ( grn_ctx *  ctx,
grn_obj *  token_filters_buffer 
)

◆ grn_ctx_get_all_tokenizers()

GRN_API grn_rc grn_ctx_get_all_tokenizers ( grn_ctx *  ctx,
grn_obj *  tokenizers_buffer 
)

◆ grn_ctx_get_all_types()

GRN_API grn_rc grn_ctx_get_all_types ( grn_ctx *  ctx,
grn_obj *  types_buffer 
)

◆ grn_ctx_get_command_version()

GRN_API grn_command_version grn_ctx_get_command_version ( grn_ctx *  ctx)
Parameters
ctxThe context object.
Returns
Command version of this context.

◆ grn_ctx_get_force_match_escalation()

GRN_API bool grn_ctx_get_force_match_escalation ( grn_ctx *  ctx)

◆ grn_ctx_get_match_escalation_threshold()

GRN_API int64_t grn_ctx_get_match_escalation_threshold ( grn_ctx *  ctx)
Parameters
ctxThe context object.
Returns
The threshold to determine whether search strategy escalation is used or not.
See also
https://groonga.org/docs/reference/commands/select.html#match-escalation-threshold

◆ grn_ctx_get_n_workers()

GRN_API int32_t grn_ctx_get_n_workers ( grn_ctx *  ctx)

◆ grn_ctx_get_variable()

GRN_API void * grn_ctx_get_variable ( grn_ctx *  ctx,
const char *  name,
int  name_size 
)

◆ grn_ctx_info_get()

GRN_API grn_rc grn_ctx_info_get ( grn_ctx *  ctx,
grn_ctx_info *  info 
)

◆ grn_ctx_init()

GRN_API grn_rc grn_ctx_init ( grn_ctx *  ctx,
int  flags 
)

Initialize the context.

Parameters
ctxThe context object allocated by the caller.
flagsInitialization options.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_ctx_is_opened()

GRN_API bool grn_ctx_is_opened ( grn_ctx *  ctx,
grn_id  id 
)

◆ grn_ctx_merge_temporary_open_space()

GRN_API grn_rc grn_ctx_merge_temporary_open_space ( grn_ctx *  ctx)

◆ grn_ctx_open()

GRN_API grn_ctx * grn_ctx_open ( int  flags)

Open the context.

Note
This function also allocates the context itself. However, grn_ctx_init requires the caller to allocate a context itself.
Attention
The context opened with this function should be closed with grn_ctx_close.
Parameters
flagsInitialization options.
Returns
Initialized context object, NULL if initialization fails.

◆ grn_ctx_pop()

GRN_API grn_obj * grn_ctx_pop ( grn_ctx *  ctx)

◆ grn_ctx_pop_temporary_open_space()

GRN_API grn_rc grn_ctx_pop_temporary_open_space ( grn_ctx *  ctx)

◆ grn_ctx_push()

GRN_API grn_rc grn_ctx_push ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_ctx_push_temporary_open_space()

GRN_API grn_rc grn_ctx_push_temporary_open_space ( grn_ctx *  ctx)

◆ grn_ctx_recv()

GRN_API grn_rc grn_ctx_recv ( grn_ctx *  ctx,
char **  str,
unsigned int *  str_len,
int *  flags 
)

◆ grn_ctx_recv_handler_set()

GRN_API void grn_ctx_recv_handler_set ( grn_ctx *  ,
grn_recv_handler_func  func,
void *  user_data 
)

◆ grn_ctx_remove()

GRN_API grn_rc grn_ctx_remove ( grn_ctx *  ctx,
const char *  name,
int  name_size,
uint32_t  flags 
)

◆ grn_ctx_remove_by_id()

GRN_API grn_rc grn_ctx_remove_by_id ( grn_ctx *  ctx,
grn_id  id,
uint32_t  flags 
)

◆ grn_ctx_send()

GRN_API unsigned int grn_ctx_send ( grn_ctx *  ctx,
const char *  str,
unsigned int  str_len,
int  flags 
)

◆ grn_ctx_set_command_version()

GRN_API grn_rc grn_ctx_set_command_version ( grn_ctx *  ctx,
grn_command_version  version 
)

Set command version for this context.

Parameters
ctxThe context object.
versionNew command version.
Returns
GRN_SUCCESS on success, GRN_UNSUPPORTED_COMMAND_VERSION on error.

◆ grn_ctx_set_finalizer()

GRN_API grn_rc grn_ctx_set_finalizer ( grn_ctx *  ctx,
grn_proc_func *  func 
)

Set the callback function to be called when the context is finished.

Parameters
ctxThe context object.
funcThe callback function called on finish.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_ctx_set_force_match_escalation()

GRN_API grn_rc grn_ctx_set_force_match_escalation ( grn_ctx *  ctx,
bool  force 
)

◆ grn_ctx_set_match_escalation_threshold()

GRN_API grn_rc grn_ctx_set_match_escalation_threshold ( grn_ctx *  ctx,
int64_t  threshold 
)

Set the threshold to determine whether search strategy escalation is used or not.

Parameters
ctxThe context object.
thresholdNew threshold.
Returns
GRN_SUCCESS.
See also
https://groonga.org/docs/reference/commands/select.html#match-escalation-threshold

◆ grn_ctx_set_n_workers()

GRN_API grn_rc grn_ctx_set_n_workers ( grn_ctx *  ctx,
int32_t  n_workers 
)

◆ grn_ctx_set_variable()

GRN_API grn_rc grn_ctx_set_variable ( grn_ctx *  ctx,
const char *  name,
int  name_size,
void *  data,
grn_close_func  close_func 
)

◆ grn_ctx_use()

GRN_API grn_rc grn_ctx_use ( grn_ctx *  ctx,
grn_obj *  db 
)

Set the database that the context is using.

You can initialize it if you specify NULL for the parameter db.

Attention
Don't use it with context that has GRN_CTX_PER_DB flag.
Parameters
ctxThe context object.
dbThe database object.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_default_logger_get_flags()

GRN_API int grn_default_logger_get_flags ( void  )

◆ grn_default_logger_get_max_level()

GRN_API grn_log_level grn_default_logger_get_max_level ( void  )

◆ grn_default_logger_get_path()

GRN_API const char * grn_default_logger_get_path ( void  )

◆ grn_default_logger_get_rotate_threshold_size()

GRN_API off_t grn_default_logger_get_rotate_threshold_size ( void  )

◆ grn_default_logger_set_flags()

GRN_API void grn_default_logger_set_flags ( int  flags)

◆ grn_default_logger_set_max_level()

GRN_API void grn_default_logger_set_max_level ( grn_log_level  level)

◆ grn_default_logger_set_path()

GRN_API void grn_default_logger_set_path ( const char *  path)

◆ grn_default_logger_set_rotate_threshold_size()

GRN_API void grn_default_logger_set_rotate_threshold_size ( off_t  threshold)

◆ grn_default_query_logger_get_flags()

GRN_API unsigned int grn_default_query_logger_get_flags ( void  )

◆ grn_default_query_logger_get_path()

GRN_API const char * grn_default_query_logger_get_path ( void  )

◆ grn_default_query_logger_get_rotate_threshold_size()

GRN_API off_t grn_default_query_logger_get_rotate_threshold_size ( void  )

◆ grn_default_query_logger_set_flags()

GRN_API void grn_default_query_logger_set_flags ( unsigned int  flags)

◆ grn_default_query_logger_set_path()

GRN_API void grn_default_query_logger_set_path ( const char *  path)

◆ grn_default_query_logger_set_rotate_threshold_size()

GRN_API void grn_default_query_logger_set_rotate_threshold_size ( off_t  threshold)

◆ grn_encoding_parse()

GRN_API grn_encoding grn_encoding_parse ( const char *  name)

Parse encoding name and return grn_encoding. For example, grn_encoding_parse("UTF8") returns GRN_ENC_UTF8.

Parameters
nameThe encoding name
Returns
grn_encoding matching name on success, GRN_ENC_UTF8 on invalid encoding name.

◆ grn_encoding_to_string()

GRN_API const char * grn_encoding_to_string ( grn_encoding  encoding)

Return string representation for the encoding. For example, grn_encoding_to_string(GRN_ENC_UTF8) returns "utf8".

Parameters
encodingThe encoding
Returns
String representation for the encoding on success, "unknown" on invalid encoding.

◆ grn_fin()

GRN_API grn_rc grn_fin ( void  )

◆ grn_get_default_command_version()

GRN_API grn_command_version grn_get_default_command_version ( void  )
Returns
Default command version

◆ grn_get_default_encoding()

GRN_API grn_encoding grn_get_default_encoding ( void  )
Returns
The default encoding

◆ grn_get_default_match_escalation_threshold()

GRN_API int64_t grn_get_default_match_escalation_threshold ( void  )
Returns
The default threshold to determine whether search strategy escalation is used or not.
See also
https://groonga.org/docs/reference/commands/select.html#match-escalation-threshold

◆ grn_get_default_n_workers()

GRN_API int32_t grn_get_default_n_workers ( void  )

◆ grn_get_global_error_message()

GRN_API const char * grn_get_global_error_message ( void  )

◆ grn_get_lock_timeout()

GRN_API int grn_get_lock_timeout ( void  )

Retrieve the current lock timeout.

Groonga uses a read lock-free mechanism. It allows multiple threads or processes to perform read operations concurrently, even during write operations. Write operations, in contrast, require locking to ensure data consistency.

When performing write operations:

  • If acquiring a lock is not immediately available, it waits for 1 millisecond before retrying.
  • The retries continue until the cumulative wait time reaches the lock timeout duration.
  • If the lock cannot be acquired within the specified timeout duration, the operation fails.

The default lock timeout is set to 900,000 milliseconds (15 minutes).

Returns
The current lock timeout in milliseconds.

◆ grn_get_memory_map_size()

GRN_API size_t grn_get_memory_map_size ( void  )

◆ grn_get_package()

GRN_API const char * grn_get_package ( void  )

◆ grn_get_package_label()

GRN_API const char * grn_get_package_label ( void  )

◆ grn_get_version()

GRN_API const char * grn_get_version ( void  )

◆ grn_get_version_major()

GRN_API uint32_t grn_get_version_major ( void  )

◆ grn_get_version_micro()

GRN_API uint32_t grn_get_version_micro ( void  )

◆ grn_get_version_minor()

GRN_API uint32_t grn_get_version_minor ( void  )

◆ grn_hook_entry_to_string()

GRN_API const char * grn_hook_entry_to_string ( grn_hook_entry  entry)

◆ grn_init()

GRN_API grn_rc grn_init ( void  )

◆ grn_is_back_trace_enable()

GRN_API bool grn_is_back_trace_enable ( void  )

◆ grn_is_reference_count_enable()

GRN_API bool grn_is_reference_count_enable ( void  )

◆ grn_load()

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,
const char *  values,
unsigned int  values_len,
const char *  ifexists,
unsigned int  ifexists_len,
const char *  each,
unsigned int  each_len 
)

◆ grn_log_flags_parse()

GRN_API bool grn_log_flags_parse ( const char *  string,
int  string_size,
int *  flags 
)

◆ grn_log_level_parse()

GRN_API bool grn_log_level_parse ( const char *  string,
grn_log_level *  level 
)

◆ grn_log_level_to_string()

GRN_API const char * grn_log_level_to_string ( grn_log_level  level)

◆ grn_logger_get_max_level()

GRN_API grn_log_level grn_logger_get_max_level ( grn_ctx *  ctx)

◆ grn_logger_info_set()

GRN_API grn_rc grn_logger_info_set ( grn_ctx *  ctx,
const grn_logger_info *  info 
)

◆ grn_logger_is_default_logger()

GRN_API bool grn_logger_is_default_logger ( grn_ctx *  ctx)

◆ grn_logger_pass()

GRN_API bool grn_logger_pass ( grn_ctx *  ctx,
grn_log_level  level 
)

◆ grn_logger_put()

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_logger_putv()

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_logger_reopen()

GRN_API void grn_logger_reopen ( grn_ctx *  ctx)

◆ grn_logger_set()

GRN_API grn_rc grn_logger_set ( grn_ctx *  ctx,
const grn_logger *  logger 
)

◆ grn_logger_set_max_level()

GRN_API void grn_logger_set_max_level ( grn_ctx *  ctx,
grn_log_level  max_level 
)

◆ grn_obj_add_hook()

GRN_API grn_rc grn_obj_add_hook ( grn_ctx *  ctx,
grn_obj *  obj,
grn_hook_entry  entry,
int  offset,
grn_obj *  proc,
grn_obj *  data 
)

Add a hook to the object. If multiple hooks are set for the object, they are called in the order they are registered in the hook list.

Parameters
ctxThe context object.
objThe target object.
entryThe type of hook.
offsetThe offset of execution order. Add to the beginning if 0 is specified. Add to the end if -1 is specified.
procThe procedure object.
dataThe hook data.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_obj_check()

GRN_API int grn_obj_check ( grn_ctx *  ctx,
grn_obj *  obj 
)

Check the integrity of the file corresponding to an object.

Note
This function is not implemented yet.
Parameters
ctxThe context object.
objThe target object whose file is to be checked.
Returns
GRN_SUCCESS on success.

◆ grn_obj_clear_lock()

GRN_API grn_rc grn_obj_clear_lock ( grn_ctx *  ctx,
grn_obj *  obj 
)

Forcefully clear locks on an object.

Unlike grn_obj_unlock, which decrements the lock count by one, this function forcefully resets the lock count of an object to zero, unlocking it regardless of the current lock count.

Attention
In general you should not use this function. Forcefully clearing locks might lead to data corruption or inconsistencies within the database. Use it only when absolutely necessary and ensure that you understand the potential consequences.
Parameters
ctxThe context object.
objThe target object whose lock is to be cleared.
Returns
GRN_SUCCESS on success.

◆ grn_obj_close()

GRN_API grn_rc grn_obj_close ( grn_ctx *  ctx,
grn_obj *  obj 
)

Close an object. 

   This function frees all resources used by the specified object (`obj`)
   from memory. All resources include other associated objects.

   In general, you must close temporary objects explicitly. You don't
   need to close persistent objects explicitly because you can close
   persistent objects implicitly by closing a DB object.

   You can use \ref grn_obj_unlink instead. It closes temporary objects
   but does nothing for most persistent objects. It's useful for normal
   use cases.
Attention
In general, you should not close persistent objects such as tables and columns for performance reasons. If you close persistent objects, you need to re-open them when they are needed again. This is inefficient.
Parameters
ctxThe context object.
objThe object to be closed.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_obj_column()

GRN_API grn_obj * grn_obj_column ( grn_ctx *  ctx,
grn_obj *  table,
const char *  name,
uint32_t  name_size 
)

Retrieve a column or an accessor from a specified table or accessor.

This function returns a column corresponding to the given name from the specified table. If the name does not correspond to any column, it returns NULL. If the name is an accessor string, it returns the corresponding accessor. Accessor strings are dot-concatenated column names. Column names that are started with _ such as _id and _key are pseudo column names. This function returns an accessor for a pseudo column name. See https://groonga.org/docs/reference/columns/pseudo.html for pseudo column.

Column name examples: name, age

Pseudo column name examples: _key, _score, _nsubrecs

Accessor string examples: tag.name, user.bookmarks.url

If this function returns an accessor, you must call grn_obj_unlink with it when it's no longer needed. You can use grn_obj_is_accessor to detect whether it's an accessor or not.

To illustrate its usage, here is an example to use grn_obj_column with pseudo column like GRN_COLUMN_NAME_ID and GRN_COLUMN_NAME_ID_LEN to retrieve the accessor object for _id.

grn_obj *id_accessor = grn_obj_column(ctx,
table,
GRN_COLUMN_NAME_ID,
GRN_COLUMN_NAME_ID_LEN);
// ...
grn_obj_unlink(ctx, id_accessor);
GRN_COLUMN_NAME_ID
#define GRN_COLUMN_NAME_ID
Name of the pseudo column _id.
Definition column.h:41
GRN_COLUMN_NAME_ID_LEN
#define GRN_COLUMN_NAME_ID_LEN
Length of the pseudo _id column name.
Definition column.h:50
grn_obj_column
GRN_API grn_obj * grn_obj_column(grn_ctx *ctx, grn_obj *table, const char *name, uint32_t name_size)
Retrieve a column or an accessor from a specified table or accessor.
grn_obj_unlink
GRN_API grn_rc grn_obj_unlink(grn_ctx *ctx, grn_obj *obj)
Unlink an object.
Parameters
ctxThe context object.
tableThe target table or accessor from which the column or accessor is retrieved.
nameThe name of the column or an accessor string.
name_sizeThe length of the name string.
Returns
The column or accessor, or NULL if not found.

◆ grn_obj_columns()

GRN_API grn_rc grn_obj_columns ( grn_ctx *  ctx,
grn_obj *  table,
const char *  str,
unsigned int  str_size,
grn_obj *  res 
)

◆ grn_obj_db()

GRN_API grn_obj * grn_obj_db ( grn_ctx *  ctx,
grn_obj *  obj 
)

Return the database to which obj belongs.

Parameters
ctxThe context object.
objTarget object.
Returns
The database object to which obj belongs, NULL if obj doesn't belong to any database.

◆ grn_obj_defrag()

GRN_API uint64_t grn_obj_defrag ( grn_ctx *  ctx,
grn_obj *  obj,
int  threshold 
)

Defragment an object to reduce fragmentation in the database file.

The defragmentation process aims to reduce the fragmentation in the database file area occupied by the object, based on the provided threshold value.

Parameters
ctxThe context object.
objThe target object to defragment.
thresholdThe threshold value used to guide the defragmentation process.
Returns
The total number of reduced bytes or segments on which defragmentation was performed.

See ctx->rc for error details.

◆ grn_obj_delete_by_id()

GRN_API grn_rc grn_obj_delete_by_id ( grn_ctx *  ctx,
grn_obj *  db,
grn_id  id,
bool  remove_p 
)

Delete an object (such as a table or column) identified by the ID from the database.

Note
In general, you should use grn_obj_remove() instead. grn_obj_remove is a higher-level API that easily manages operations for users. Use this lower-level API, grn_obj_delete_by_id, only when finer control over the deletion process is necessary.
Parameters
ctxThe context object.
dbThe target database object.
idThe ID of the object to be deleted.
remove_pA boolean flag indicating the deletion mode:
  • If true, the function clears the object cache and also removes the relation between the ID and the key in the database.
  • If false, the function only clears the object cache.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_INVALID_ARGUMENT is returned if id is GRN_ID_NIL.

◆ grn_obj_delete_hook()

GRN_API grn_rc grn_obj_delete_hook ( grn_ctx *  ctx,
grn_obj *  obj,
grn_hook_entry  entry,
int  offset 
)

Delete the hook set on the object.

Parameters
ctxThe context object.
objThe target object.
entryThe type of hook.
offsetThe offset of execution order.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_INVALID_ARGUMENT is returned if there was no hook in offset.

◆ grn_obj_expire()

GRN_API int grn_obj_expire ( grn_ctx *  ctx,
grn_obj *  obj,
int  threshold 
)

Free allocatable memory occupied by an object based on a threshold.

Note
This function is not implemented yet. The grn_obj_expire function is intended to serve as a generic version of grn_ii_expire() and grn_io_expire().
Parameters
ctxThe context object.
objThe target object whose memory is to be managed.
thresholdThe threshold value used as a benchmark for freeing memory spaces.
Returns
GRN_SUCCESS on success.

◆ grn_obj_flush()

GRN_API grn_rc grn_obj_flush ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_flush_only_opened()

GRN_API grn_rc grn_obj_flush_only_opened ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_flush_recursive()

GRN_API grn_rc grn_obj_flush_recursive ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_flush_recursive_dependent()

GRN_API grn_rc grn_obj_flush_recursive_dependent ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_get_element_info()

GRN_API grn_obj * grn_obj_get_element_info ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  id,
grn_info_type  type,
grn_obj *  valuebuf 
)

Get information on the record with the ID in the object.

Note
This function is not implemented yet.
Parameters
ctxThe context object.
objThe target object.
idThe target ID.
typeThe type of information.
valuebufThe buffer to store the retrieved value (must be prepared by the caller).
Returns
valuebuf.

◆ grn_obj_get_hook()

GRN_API grn_obj * grn_obj_get_hook ( grn_ctx *  ctx,
grn_obj *  obj,
grn_hook_entry  entry,
int  offset,
grn_obj *  data 
)

Get the hook set on the object. If hook data is set, it is stored in data.

Parameters
ctxThe context object.
objThe target object.
entryThe type of hook.
offsetThe offset of execution order.
dataThe buffer to store hook data.
Returns
The procedure object if the hook is set, NULL otherwise.

◆ grn_obj_get_info()

GRN_API grn_obj * grn_obj_get_info ( grn_ctx *  ctx,
grn_obj *  obj,
grn_info_type  type,
grn_obj *  valuebuf 
)

Get information on the object.

Parameters
ctxThe context object.
objThe target object.
typeThe type of information.
valuebufThe buffer to store the retrieved value (must be prepared by the caller).
Returns
valuebuf.

◆ grn_obj_get_nhooks()

GRN_API int grn_obj_get_nhooks ( grn_ctx *  ctx,
grn_obj *  obj,
grn_hook_entry  entry 
)

Get the number of hooks set on the object.

Parameters
ctxThe context object.
objThe target object.
entryThe type of hook.
Returns
The number of hooks set on the object.

◆ grn_obj_get_range()

GRN_API grn_id grn_obj_get_range ( grn_ctx *  ctx,
grn_obj *  obj 
)

Retrieve the value range based on the ID associated with an object. 

   For example, it may return \ref GRN_DB_INT32 from \ref
   grn_builtin_type to indicate that the object operates within the
   integer range.
Parameters
ctxThe context object.
objThe target object whose range ID is to be returned.
Returns
The ID of the range object. Returns GRN_ID_NIL if no range is associated or the object is NULL.

◆ grn_obj_get_value()

GRN_API grn_obj * grn_obj_get_value ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  id,
grn_obj *  value 
)

Retrieve the value of the record corresponding to the given ID in the specified object.

Parameters
ctxThe context object
objThe target object from which to retrieve the value
idThe ID of the target record
valueThe buffer to store the retrieved value (must be prepared by the caller)
Returns
The value of the specified record in the object.

◆ grn_obj_get_values()

GRN_API int grn_obj_get_values ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  offset,
void **  values 
)

Retrieve an array of fixed-size column values starting from a specified record ID.

This function retrieves values from a fixed-size column (obj), starting at the record ID given by offset. The retrieved values are stored in the array pointed to by values, and the number of records that can be retrieved is returned.

Attention
It is not guaranteed that all record IDs within the specified range are valid. For tables where records may have been deleted, you must use functions such as grn_table_at to check the existence of each record.
Note
If an error occurs and the return value is -1, check ctx->rc for the specific error code (e.g., GRN_NO_MEMORY_AVAILABLE, GRN_INVALID_ARGUMENT). Additional details might be available in ctx->errbuf.
Parameters
ctxThe context object
objThe target fixed-size column
offsetThe starting record ID for retrieving values
valuesA pointer to an array where the values will be stored
Returns
The number of records retrieved, or -1 if an error occurred.

◆ grn_obj_id()

GRN_API grn_id grn_obj_id ( grn_ctx *  ctx,
grn_obj *  obj 
)

Return the ID of an object.

Parameters
ctxThe context object.
objThe target object whose ID is to be retrieved.
Returns
The ID of the object, GRN_ID_NIL if the object doesn't belong to any database.

◆ grn_obj_is_locked()

GRN_API unsigned int grn_obj_is_locked ( grn_ctx *  ctx,
grn_obj *  obj 
)

Check if an object is currently locked.

Parameters
ctxThe context object.
objThe target object whose lock status is to be checked.
Returns
0 if there are no locks. Return the number of acquired locks if the object or any of its related sub-objects are currently locked.

◆ grn_obj_lock()

GRN_API grn_rc grn_obj_lock ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  id,
int  timeout 
)

Lock an object with a specified timeout.

Parameters
ctxThe context object.
objThe target object to lock.
idThe ID of the target object.
timeoutThe maximum time to wait for the lock, in seconds.
Attention
You should ensure that every call to grn_obj_lock is paired with a call to grn_obj_unlock to maintain lock balance. Failing to do can lead to deadlocks.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_RESOURCE_DEADLOCK_AVOIDED is returned if the lock could not be acquired within the specified timeout.

◆ grn_obj_name()

GRN_API int grn_obj_name ( grn_ctx *  ctx,
grn_obj *  obj,
char *  namebuf,
int  buf_size 
)

Return an object's name by storing it in namebuf. 

   If the object has a name and `buf_size` is greater than or equal to
   the length of the name, the name is copied into `namebuf`.

   If the length of the name exceeds `buf_size`, the name is not copied
   into `namebuf`, but the length of the name is still returned.

   The maximum possible length of the name is limited by
   \ref GRN_TABLE_MAX_KEY_SIZE.
Parameters
ctxThe context object.
objThe object whose name is to be retrieved.
namebufA buffer allocated by the caller to store the object's name.
buf_sizeThe size of namebuf in bytes.
Returns
The length of the object's name. Returns 0 if the object is unnamed or NULL.

◆ grn_obj_open()

GRN_API grn_obj * grn_obj_open ( grn_ctx *  ctx,
unsigned char  type,
grn_obj_flags  flags,
grn_id  domain 
)

◆ grn_obj_path()

GRN_API const char * grn_obj_path ( grn_ctx *  ctx,
grn_obj *  obj 
)

Return the file path associated with an object.

Parameters
ctxThe context object.
objThe object whose file path is to be retrieved.
Returns
The file path on success, NULL if the object is temporary.

◆ grn_obj_path_by_id()

GRN_API grn_rc grn_obj_path_by_id ( grn_ctx *  ctx,
grn_obj *  db,
grn_id  id,
char *  buffer 
)

Return the pathname of an object ID.

Parameters
ctxThe context object.
dbThe target database object.
idThe ID of the object whose pathname is to be obtained.
bufferA pre-allocated buffer where the resulting pathname will be stored. For example, char buffer[PATH_MAX] can be used.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_INVALID_ARGUMENT is returned if db is not a database object or if buffer is NULL.

◆ grn_obj_refer()

GRN_API grn_rc grn_obj_refer ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_refer_recursive()

GRN_API grn_rc grn_obj_refer_recursive ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_refer_recursive_dependent()

GRN_API grn_rc grn_obj_refer_recursive_dependent ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_reinit()

GRN_API grn_rc grn_obj_reinit ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  domain,
uint8_t  flags 
)

Reinitialize an object. 

   Buffer objects, \ref GRN_BULK, \ref GRN_PTR, \ref GRN_UVECTOR,
   \ref GRN_PVECTOR, and \ref GRN_VECTOR, are only target objects
   of this function. You can't use other objects such as table and
   column for this function.

   This function frees the current data in the specified object
   (`obj`) and initializes the specified `obj` for the specified
   `domain` and `flags`.

   Before calling this function, the object must have been initialized.
   You can use `GRN_XXX_INIT()` macros such as \ref GRN_TEXT_INIT to
   initialize a buffer object.
Parameters
ctxThe context object.
objThe object to be reinitialized. It must be a buffer object.
domainThe new type that the object can hold.
flags0 or GRN_OBJ_VECTOR. If GRN_OBJ_VECTOR is specified, the object will be configured to store a vector of values of the specified domain.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_obj_remove()

GRN_API grn_rc grn_obj_remove ( grn_ctx *  ctx,
grn_obj *  obj 
)

Remove the specified object. 

   This function frees the specified object (`obj`) from memory. If the
   object is a persistent object, it also removes the associated files
   from disk.
Parameters
ctxThe context object.
objThe target object to be removed.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_obj_remove_dependent()

GRN_API grn_rc grn_obj_remove_dependent ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_remove_flags()

GRN_API grn_rc grn_obj_remove_flags ( grn_ctx *  ctx,
grn_obj *  obj,
uint32_t  flags 
)

◆ grn_obj_remove_force()

GRN_API grn_rc grn_obj_remove_force ( grn_ctx *  ctx,
const char *  name,
int  name_size 
)

◆ grn_obj_rename()

GRN_API grn_rc grn_obj_rename ( grn_ctx *  ctx,
grn_obj *  obj,
const char *  name,
unsigned int  name_size 
)

Rename a persistent object in the database used by the context. 

   This function updates the name of the specified object (`obj`) to the
   new name provided. The object must be a persistent object.
Parameters
ctxThe context object.
objThe target object to be renamed.
nameThe new name for the given object.
name_sizeThe size of the name in bytes.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_obj_search()

GRN_API grn_rc grn_obj_search ( grn_ctx *  ctx,
grn_obj *  obj,
grn_obj *  query,
grn_obj *  res,
grn_operator  op,
grn_search_optarg *  optarg 
)

Search for obj in query.

Parameters
ctxThe context object.
objThe object to be searched.
querySearch query.
resThe table to store results.
opLogical operation of the table stored in res and the table of the search result.
optargSearch options. For example, you can specify the search mode in grn_search_optarg::mode. If GRN_OP_EQUAL is specified for grn_search_optarg::mode, it searching for equal record.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_INVALID_ARGUMENT is returned if obj is NULL.

◆ grn_obj_set_element_info()

GRN_API grn_rc grn_obj_set_element_info ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  id,
grn_info_type  type,
grn_obj *  value 
)

Set information on the record with the ID in the object.

Note
This function is not implemented yet.
Parameters
ctxThe context object.
objThe target object.
idThe target ID.
typeThe type of information.
valueThe value to set.
Returns
GRN_SUCCESS.

◆ grn_obj_set_finalizer()

GRN_API grn_rc grn_obj_set_finalizer ( grn_ctx *  ctx,
grn_obj *  obj,
grn_proc_func *  func 
)

Set the callback function when finalizing the object.

Parameters
ctxThe context object.
objTarget object. Table, table cursor, column, procedure, and expression can be specified.
funcCallback function when finalizing.
Returns
GRN_SUCCESS on success, GRN_INVALID_ARGUMENT if obj is not table, table cursor, column, procedure, or expression.

◆ grn_obj_set_info()

GRN_API grn_rc grn_obj_set_info ( grn_ctx *  ctx,
grn_obj *  obj,
grn_info_type  type,
grn_obj *  value 
)

Set information on the object.

Parameters
ctxThe context object.
objThe target object.
typeThe type of information.
valueThe value to set.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_INVALID_ARGUMENT is returned if obj is NULL.

◆ grn_obj_set_value()

GRN_API grn_rc grn_obj_set_value ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  id,
grn_obj *  value,
int  flags 
)

Update the value of a record identified by the given ID in the specified object.

This function updates the value of the record specified by id in the given object (obj). If the corresponding record does not exist, it returns GRN_INVALID_ARGUMENT.

Parameters
ctxThe context object.
objThe target object where the value will be updated.
idThe ID of the record to be updated.
valueThe value to be stored in the record.
flagsOnly one flag can be specified, depending on the type of the object (obj).
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error. For example, GRN_INVALID_ARGUMENT is returned if the record does not exist.

◆ grn_obj_unlink()

GRN_API grn_rc grn_obj_unlink ( grn_ctx *  ctx,
grn_obj *  obj 
)

Unlink an object.

This calls grn_obj_close only when the specified object (obj) can be closed. See the following description for details.

Reference Count Mode:

Reference count mode manages object lifetimes by keeping track of active references. It can be enabled in two ways:

  • Environment Variable: Set GRN_ENABLE_REFERENCE_COUNT to yes before running the program.
  • API: Use grn_set_reference_count_enable to enable it at runtime.

Non reference count mode:

This is the default. You can disable reference count mode explicitly by GRN_ENABLE_REFERENCE_COUNT=no environment variable.

The following objects are closed immediately:

Other objects such as persisted tables and columns are not closed.

Reference count mode:

You need to enable this explicitly by GRN_ENABLE_REFERENCE_COUNT=yes environment variable.

The following objects are closed immediately:

The reference count is decreased for the following objects:

  • GRN_ACCESSOR
  • Column (both persisted and temporary)
  • Table (both persisted and temporary)

If the reference count reaches zero, the object is closed.

Parameters
ctxThe context object.
objThe object to be unlinked and freed from memory.
Returns
GRN_SUCCESS on success, the appropriate grn_rc on error.

◆ grn_obj_unlock()

GRN_API grn_rc grn_obj_unlock ( grn_ctx *  ctx,
grn_obj *  obj,
grn_id  id 
)

Unlock an object.

Unlike grn_obj_clear_lock, which forcefully resets the lock count to zero, this function decrements the lock count of an object by one.

Note
Locks are managed using a counter mechanism where each lock acquisition increments the count by one, and each unlock operation decrements it by one. When the lock count reaches zero, the object is considered unlocked.
Attention
You should ensure that every call to grn_obj_unlock is paired with a call to grn_obj_lock to maintain lock balance. Failing to do can lead to deadlocks.
Parameters
ctxThe context object.
objThe target object to unlock.
idThe ID of the target object.
Returns
GRN_SUCCESS on success.

◆ grn_obj_unref()

GRN_API void grn_obj_unref ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_unref_recursive()

GRN_API void grn_obj_unref_recursive ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_unref_recursive_dependent()

GRN_API void grn_obj_unref_recursive_dependent ( grn_ctx *  ctx,
grn_obj *  obj 
)

◆ grn_obj_user_data()

GRN_API grn_user_data * grn_obj_user_data ( grn_ctx *  ctx,
grn_obj *  obj 
)

Returns a pointer to user data that can be registered in the object.

Parameters
ctxThe context object
objOnly table, column, proc, and expr can be specified
Returns
Pointer to user data

◆ grn_plugin_get_names()

GRN_API grn_rc grn_plugin_get_names ( grn_ctx *  ctx,
grn_obj *  names 
)

◆ grn_plugin_get_ruby_suffix()

GRN_API const char * grn_plugin_get_ruby_suffix ( void  )

◆ grn_plugin_get_suffix()

GRN_API const char * grn_plugin_get_suffix ( void  )

◆ grn_plugin_get_system_plugins_dir()

GRN_API const char * grn_plugin_get_system_plugins_dir ( void  )

◆ grn_plugin_register()

GRN_API grn_rc grn_plugin_register ( grn_ctx *  ctx,
const char *  name 
)

◆ grn_plugin_register_by_path()

GRN_API grn_rc grn_plugin_register_by_path ( grn_ctx *  ctx,
const char *  path 
)

◆ grn_plugin_unregister()

GRN_API grn_rc grn_plugin_unregister ( grn_ctx *  ctx,
const char *  name 
)

◆ grn_plugin_unregister_by_path()

GRN_API grn_rc grn_plugin_unregister_by_path ( grn_ctx *  ctx,
const char *  path 
)

◆ grn_proc_call_next()

GRN_API int grn_proc_call_next ( grn_ctx *  ctx,
grn_obj *  exec_info,
grn_obj *  in,
grn_obj *  out 
)

◆ grn_proc_get_ctx_local_data()

GRN_API void * grn_proc_get_ctx_local_data ( grn_ctx *  ctx,
grn_obj *  exec_info 
)

◆ grn_proc_get_hook_local_data()

GRN_API void * grn_proc_get_hook_local_data ( grn_ctx *  ctx,
grn_obj *  exec_info 
)

◆ grn_proc_is_stable()

GRN_API bool grn_proc_is_stable ( grn_ctx *  ctx,
grn_obj *  proc 
)

◆ grn_proc_set_is_stable()

GRN_API grn_rc grn_proc_set_is_stable ( grn_ctx *  ctx,
grn_obj *  proc,
bool  is_stable 
)

◆ grn_query_log_flags_parse()

GRN_API bool grn_query_log_flags_parse ( const char *  string,
int  string_size,
unsigned int *  flags 
)

◆ grn_query_logger_add_flags()

GRN_API void grn_query_logger_add_flags ( grn_ctx *  ctx,
unsigned int  flags 
)

◆ grn_query_logger_get_flags()

GRN_API unsigned int grn_query_logger_get_flags ( grn_ctx *  ctx)

◆ grn_query_logger_pass()

GRN_API bool grn_query_logger_pass ( grn_ctx *  ctx,
unsigned int  flag 
)

◆ grn_query_logger_put()

GRN_API void grn_query_logger_put ( grn_ctx *  ctx,
unsigned int  flag,
const char *  mark,
const char *  format,
  ... 
)

◆ grn_query_logger_remove_flags()

GRN_API void grn_query_logger_remove_flags ( grn_ctx *  ctx,
unsigned int  flags 
)

◆ grn_query_logger_reopen()

GRN_API void grn_query_logger_reopen ( grn_ctx *  ctx)

◆ grn_query_logger_set()

GRN_API grn_rc grn_query_logger_set ( grn_ctx *  ctx,
const grn_query_logger *  logger 
)

◆ grn_query_logger_set_flags()

GRN_API void grn_query_logger_set_flags ( grn_ctx *  ctx,
unsigned int  flags 
)

◆ grn_set_abrt_handler()

GRN_API grn_rc grn_set_abrt_handler ( void  )

◆ grn_set_back_trace_enable()

GRN_API grn_rc grn_set_back_trace_enable ( bool  enable)

◆ grn_set_default_command_version()

GRN_API grn_rc grn_set_default_command_version ( grn_command_version  version)

Set default command version.

Parameters
versionNew command version
Returns
GRN_SUCCESS on success, GRN_UNSUPPORTED_COMMAND_VERSION on error

◆ grn_set_default_encoding()

GRN_API grn_rc grn_set_default_encoding ( grn_encoding  encoding)

Set the default encoding.

Parameters
encodingNew encoding
Returns
GRN_SUCCESS on success, GRN_INVALID_ARGUMENT on error

◆ grn_set_default_match_escalation_threshold()

GRN_API grn_rc grn_set_default_match_escalation_threshold ( int64_t  threshold)

Set the default threshold to determine whether search strategy escalation is used or not.

Parameters
thresholdNew default threshold.
Returns
GRN_SUCCESS.
See also
https://groonga.org/docs/reference/commands/select.html#match-escalation-threshold

◆ grn_set_default_n_workers()

GRN_API grn_rc grn_set_default_n_workers ( int32_t  n_workers)

◆ grn_set_int_handler()

GRN_API grn_rc grn_set_int_handler ( void  )

◆ grn_set_lock_timeout()

GRN_API grn_rc grn_set_lock_timeout ( int  timeout)

Set the lock timeout used during write operations.

Special cases for the timeout parameter:

  • 0: If timeout is 0, Groonga will attempt to acquire the lock only once. If it fails, it will not retry and the operation will fail immediately without waiting for the lock to be released.
  • Negative value: If timeout is negative value, Groonga will wait forever for retrying to acquire the lock without any timeout until it succeeds.

The default lock timeout is 900,000 milliseconds (15 minutes).

Lock Timeout Configuration:

Lock timeout can be configured in two ways:

  • CMake Option: Use -DGRN_LOCK_TIMEOUT=<milliseconds> when configuring the build with CMake to specify a default lock timeout by milliseconds.
  • API: Use grn_set_lock_timeout to override the default setting at runtime.
Parameters
timeoutThe new lock timeout in milliseconds.
Returns
GRN_SUCCESS on success.

◆ grn_set_reference_count_enable()

GRN_API grn_rc grn_set_reference_count_enable ( bool  enable)

◆ grn_set_segv_handler()

GRN_API grn_rc grn_set_segv_handler ( void  )

◆ grn_set_term_handler()

GRN_API grn_rc grn_set_term_handler ( void  )

◆ grn_slow_log_is_slow()

GRN_API bool grn_slow_log_is_slow ( grn_ctx *  ctx,
double  elapsed_time 
)

◆ grn_slow_log_pop()

GRN_API double grn_slow_log_pop ( grn_ctx *  ctx)

◆ grn_slow_log_push()

GRN_API grn_rc grn_slow_log_push ( grn_ctx *  ctx)

◆ grn_snip_add_cond()

GRN_API grn_rc grn_snip_add_cond ( grn_ctx *  ctx,
grn_obj *  snip,
const char *  keyword,
unsigned int  keyword_len,
const char *  opentag,
unsigned int  opentag_len,
const char *  closetag,
unsigned int  closetag_len 
)

◆ grn_snip_exec()

GRN_API grn_rc grn_snip_exec ( grn_ctx *  ctx,
grn_obj *  snip,
const char *  string,
unsigned int  string_len,
unsigned int *  nresults,
unsigned int *  max_tagged_len 
)

◆ grn_snip_get_delimiter_regexp()

GRN_API const char * grn_snip_get_delimiter_regexp ( grn_ctx *  ctx,
grn_obj *  snip,
size_t *  pattern_length 
)

◆ grn_snip_get_normalizer()

GRN_API grn_obj * grn_snip_get_normalizer ( grn_ctx *  ctx,
grn_obj *  snip 
)

◆ grn_snip_get_normalizers()

GRN_API grn_obj * grn_snip_get_normalizers ( grn_ctx *  ctx,
grn_obj *  snip 
)

◆ grn_snip_get_result()

GRN_API grn_rc grn_snip_get_result ( grn_ctx *  ctx,
grn_obj *  snip,
const unsigned int  index,
char *  result,
unsigned int *  result_len 
)

◆ grn_snip_open()

GRN_API grn_obj * grn_snip_open ( grn_ctx *  ctx,
int  flags,
unsigned int  width,
unsigned int  max_results,
const char *  defaultopentag,
unsigned int  defaultopentag_len,
const char *  defaultclosetag,
unsigned int  defaultclosetag_len,
grn_snip_mapping *  mapping 
)

◆ grn_snip_set_delimiter_regexp()

GRN_API grn_rc grn_snip_set_delimiter_regexp ( grn_ctx *  ctx,
grn_obj *  snip,
const char *  pattern,
int  pattern_length 
)

◆ grn_snip_set_normalizer()

GRN_API grn_rc grn_snip_set_normalizer ( grn_ctx *  ctx,
grn_obj *  snip,
grn_obj *  normalizer 
)

◆ grn_snip_set_normalizers()

GRN_API grn_rc grn_snip_set_normalizers ( grn_ctx *  ctx,
grn_obj *  snip,
grn_obj *  normalizers 
)

◆ grn_text_benc()

GRN_API grn_rc grn_text_benc ( grn_ctx *  ctx,
grn_obj *  bulk,
unsigned int  v 
)

◆ grn_text_code_point()

GRN_API grn_rc grn_text_code_point ( grn_ctx *  ctx,
grn_obj *  buffer,
uint32_t  code_point 
)

◆ grn_text_esc()

GRN_API grn_rc grn_text_esc ( grn_ctx *  ctx,
grn_obj *  bulk,
const char *  s,
size_t  len 
)

◆ grn_text_escape_xml()

GRN_API grn_rc grn_text_escape_xml ( grn_ctx *  ctx,
grn_obj *  buf,
const char *  s,
size_t  len 
)

◆ grn_text_f32toa()

GRN_API grn_rc grn_text_f32toa ( grn_ctx *  ctx,
grn_obj *  bulk,
float  f 
)

◆ grn_text_ftoa()

GRN_API grn_rc grn_text_ftoa ( grn_ctx *  ctx,
grn_obj *  bulk,
double  d 
)

◆ grn_text_itoa()

GRN_API grn_rc grn_text_itoa ( grn_ctx *  ctx,
grn_obj *  bulk,
int  i 
)

◆ grn_text_itoa_padded()

GRN_API grn_rc grn_text_itoa_padded ( grn_ctx *  ctx,
grn_obj *  bulk,
int  i,
char  ch,
size_t  len 
)

◆ grn_text_itob()

GRN_API grn_rc grn_text_itob ( grn_ctx *  ctx,
grn_obj *  bulk,
grn_id  id 
)

◆ grn_text_itoh()

GRN_API grn_rc grn_text_itoh ( grn_ctx *  ctx,
grn_obj *  bulk,
unsigned int  i,
size_t  len 
)

◆ grn_text_lltoa()

GRN_API grn_rc grn_text_lltoa ( grn_ctx *  ctx,
grn_obj *  bulk,
long long int  i 
)

◆ grn_text_lltob32h()

GRN_API grn_rc grn_text_lltob32h ( grn_ctx *  ctx,
grn_obj *  bulk,
long long int  i 
)

◆ grn_text_printf()

GRN_API grn_rc grn_text_printf ( grn_ctx *  ctx,
grn_obj *  bulk,
const char *  format,
  ... 
)

◆ grn_text_printfv()

GRN_API grn_rc grn_text_printfv ( grn_ctx *  ctx,
grn_obj *  bulk,
const char *  format,
va_list  args 
)

◆ grn_text_time2rfc1123()

GRN_API grn_rc grn_text_time2rfc1123 ( grn_ctx *  ctx,
grn_obj *  bulk,
int  sec 
)

◆ grn_text_urldec()

GRN_API const char * grn_text_urldec ( grn_ctx *  ctx,
grn_obj *  buf,
const char *  s,
const char *  e,
char  d 
)

◆ grn_text_urlenc()

GRN_API grn_rc grn_text_urlenc ( grn_ctx *  ctx,
grn_obj *  buf,
const char *  str,
size_t  len 
)

◆ grn_text_vprintf()

GRN_API grn_rc grn_text_vprintf ( grn_ctx *  ctx,
grn_obj *  bulk,
const char *  format,
va_list  args 
)

◆ grn_unset_variable()

GRN_API grn_rc grn_unset_variable ( const char *  name,
int  name_size 
)