mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-02-01 19:41:47 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/storage/mroonga/vendor/groonga/include/groonga.h

2106 lines
82 KiB
C
Raw Blame History

/*
Copyright(C) 2009-2014 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_H
#define GROONGA_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdarg.h>
#ifndef GRN_API
#if defined(_WIN32) || defined(_WIN64)
#define GRN_API __declspec(dllimport)
#else
#define GRN_API
#endif /* defined(_WIN32) || defined(_WIN64) */
#endif /* GRN_API */
typedef unsigned int grn_id;
typedef unsigned char grn_bool;
#define GRN_ID_NIL (0x00)
#define GRN_ID_MAX (0x3fffffff)
#define GRN_TRUE (1)
#define GRN_FALSE (0)
typedef enum {
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_LZO_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_rc;
GRN_API grn_rc grn_init(void);
GRN_API grn_rc grn_fin(void);
typedef enum {
GRN_ENC_DEFAULT = 0,
GRN_ENC_NONE,
GRN_ENC_EUC_JP,
GRN_ENC_UTF8,
GRN_ENC_SJIS,
GRN_ENC_LATIN1,
GRN_ENC_KOI8R
} grn_encoding;
typedef enum {
GRN_COMMAND_VERSION_DEFAULT = 0,
GRN_COMMAND_VERSION_1,
GRN_COMMAND_VERSION_2
} grn_command_version;
#define GRN_COMMAND_VERSION_MIN GRN_COMMAND_VERSION_1
#define GRN_COMMAND_VERSION_STABLE GRN_COMMAND_VERSION_1
#define GRN_COMMAND_VERSION_MAX GRN_COMMAND_VERSION_2
typedef enum {
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
} grn_log_level;
/* query log flags */
#define GRN_QUERY_LOG_NONE (0x00)
#define GRN_QUERY_LOG_COMMAND (0x01<<0)
#define GRN_QUERY_LOG_RESULT_CODE (0x01<<1)
#define GRN_QUERY_LOG_DESTINATION (0x01<<2)
#define GRN_QUERY_LOG_CACHE (0x01<<3)
#define GRN_QUERY_LOG_SIZE (0x01<<4)
#define GRN_QUERY_LOG_SCORE (0x01<<5)
#define GRN_QUERY_LOG_ALL\
(GRN_QUERY_LOG_COMMAND |\
GRN_QUERY_LOG_RESULT_CODE |\
GRN_QUERY_LOG_DESTINATION |\
GRN_QUERY_LOG_CACHE |\
GRN_QUERY_LOG_SIZE |\
GRN_QUERY_LOG_SCORE)
#define GRN_QUERY_LOG_DEFAULT GRN_QUERY_LOG_ALL
typedef enum {
GRN_CONTENT_NONE = 0,
GRN_CONTENT_TSV,
GRN_CONTENT_JSON,
GRN_CONTENT_XML,
GRN_CONTENT_MSGPACK
} grn_content_type;
typedef struct _grn_obj grn_obj;
typedef struct _grn_ctx grn_ctx;
#define GRN_CTX_MSGSIZE (0x80)
#define GRN_CTX_FIN (0xff)
typedef union {
int int_value;
grn_id id;
void *ptr;
} grn_user_data;
typedef grn_obj *grn_proc_func(grn_ctx *ctx, int nargs, grn_obj **args,
grn_user_data *user_data);
struct _grn_ctx {
grn_rc rc;
int flags;
grn_encoding encoding;
unsigned char ntrace;
unsigned char errlvl;
unsigned char stat;
unsigned int seqno;
unsigned int subno;
unsigned int seqno2;
unsigned int errline;
grn_user_data user_data;
grn_ctx *prev;
grn_ctx *next;
const char *errfile;
const char *errfunc;
struct _grn_ctx_impl *impl;
void *trace[16];
char errbuf[GRN_CTX_MSGSIZE];
};
#define GRN_CTX_USER_DATA(ctx) (&((ctx)->user_data))
/* Deprecated since 4.0.3. Don't use it. */
#define GRN_CTX_USE_QL (0x03)
/* Deprecated since 4.0.3. Don't use it. */
#define GRN_CTX_BATCH_MODE (0x04)
#define GRN_CTX_PER_DB (0x08)
GRN_API grn_rc grn_ctx_init(grn_ctx *ctx, int flags);
GRN_API grn_rc grn_ctx_fin(grn_ctx *ctx);
GRN_API grn_ctx *grn_ctx_open(int flags);
GRN_API grn_rc grn_ctx_close(grn_ctx *ctx);
GRN_API grn_rc grn_ctx_set_finalizer(grn_ctx *ctx, grn_proc_func *func);
GRN_API grn_encoding grn_get_default_encoding(void);
GRN_API grn_rc grn_set_default_encoding(grn_encoding encoding);
#define GRN_CTX_GET_ENCODING(ctx) ((ctx)->encoding)
#define GRN_CTX_SET_ENCODING(ctx,enc) \
((ctx)->encoding = (enc == GRN_ENC_DEFAULT) ? grn_get_default_encoding() : enc)
GRN_API const char *grn_get_version(void);
GRN_API const char *grn_get_package(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);
GRN_API grn_command_version grn_ctx_get_command_version(grn_ctx *ctx);
GRN_API grn_rc grn_ctx_set_command_version(grn_ctx *ctx, grn_command_version version);
GRN_API long long int grn_ctx_get_match_escalation_threshold(grn_ctx *ctx);
GRN_API grn_rc grn_ctx_set_match_escalation_threshold(grn_ctx *ctx, long long int threshold);
GRN_API long long int grn_get_default_match_escalation_threshold(void);
GRN_API grn_rc grn_set_default_match_escalation_threshold(long long int threshold);
GRN_API int grn_get_lock_timeout(void);
GRN_API grn_rc grn_set_lock_timeout(int timeout);
/* cache */
#define GRN_CACHE_DEFAULT_MAX_N_ENTRIES 100
typedef struct _grn_cache grn_cache;
GRN_API grn_cache *grn_cache_open(grn_ctx *ctx);
GRN_API grn_rc grn_cache_close(grn_ctx *ctx, grn_cache *cache);
GRN_API grn_rc grn_cache_current_set(grn_ctx *ctx, grn_cache *cache);
GRN_API grn_cache *grn_cache_current_get(grn_ctx *ctx);
GRN_API grn_rc grn_cache_set_max_n_entries(grn_ctx *ctx,
grn_cache *cache,
unsigned int n);
GRN_API unsigned int grn_cache_get_max_n_entries(grn_ctx *ctx,
grn_cache *cache);
/* grn_encoding */
GRN_API const char *grn_encoding_to_string(grn_encoding encoding);
GRN_API grn_encoding grn_encoding_parse(const char *name);
/* obj */
typedef unsigned short int grn_obj_flags;
#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)
#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_LZO (0x02<<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_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)
/* obj types */
#define GRN_VOID (0x00)
#define GRN_BULK (0x02)
#define GRN_PTR (0x03)
#define GRN_UVECTOR (0x04) /* vector of grn_id */
#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_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_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)
typedef struct _grn_section grn_section;
typedef struct _grn_obj_header grn_obj_header;
struct _grn_section {
unsigned int offset;
unsigned int length;
unsigned int weight;
grn_id domain;
};
struct _grn_obj_header {
unsigned char type;
unsigned char impl_flags;
grn_obj_flags flags;
grn_id domain;
};
struct _grn_obj {
grn_obj_header header;
union {
struct {
char *head;
char *curr;
char *tail;
} b;
struct {
grn_obj *body;
grn_section *sections;
int n_sections;
} v;
} u;
};
#define GRN_OBJ_REFER (0x01<<0)
#define GRN_OBJ_OUTPLACE (0x01<<1)
#define GRN_OBJ_INIT(obj,obj_type,obj_flags,obj_domain) 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)
#define GRN_OBJ_FIN(ctx,obj) (grn_obj_close((ctx), (obj)))
typedef struct _grn_db_create_optarg grn_db_create_optarg;
struct _grn_db_create_optarg {
char **builtin_type_names;
int n_builtin_type_names;
};
GRN_API grn_obj *grn_db_create(grn_ctx *ctx, const char *path, grn_db_create_optarg *optarg);
#define GRN_DB_OPEN_OR_CREATE(ctx,path,optarg,db) \
(((db) = grn_db_open((ctx), (path))) || (db = grn_db_create((ctx), (path), (optarg))))
GRN_API grn_obj *grn_db_open(grn_ctx *ctx, const char *path);
GRN_API void grn_db_touch(grn_ctx *ctx, grn_obj *db);
GRN_API grn_rc grn_ctx_use(grn_ctx *ctx, grn_obj *db);
GRN_API grn_obj *grn_ctx_db(grn_ctx *ctx);
GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, int name_size);
typedef enum {
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_builtin_type;
typedef enum {
GRN_DB_MECAB = 64,
GRN_DB_DELIMIT,
GRN_DB_UNIGRAM,
GRN_DB_BIGRAM,
GRN_DB_TRIGRAM
} grn_builtin_tokenizer;
GRN_API grn_obj *grn_ctx_at(grn_ctx *ctx, grn_id id);
GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,
grn_obj_flags flags, unsigned int size);
GRN_API grn_rc grn_plugin_register(grn_ctx *ctx, const char *name);
GRN_API grn_rc grn_plugin_register_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);
typedef struct {
const char *name;
unsigned int name_size;
grn_obj value;
} grn_expr_var;
typedef grn_rc (*grn_plugin_func)(grn_ctx *ctx);
typedef enum {
GRN_PROC_INVALID = 0,
GRN_PROC_TOKENIZER,
GRN_PROC_COMMAND,
GRN_PROC_FUNCTION,
GRN_PROC_HOOK,
GRN_PROC_NORMALIZER,
GRN_PROC_TOKEN_FILTER
} grn_proc_type;
GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
const char *name, int name_size, grn_proc_type type,
grn_proc_func *init, grn_proc_func *next, grn_proc_func *fin,
unsigned int nvars, grn_expr_var *vars);
GRN_API grn_obj *grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
grn_expr_var **vars, unsigned int *nvars, grn_obj **caller);
GRN_API grn_proc_type grn_proc_get_type(grn_ctx *ctx, grn_obj *proc);
/*-------------------------------------------------------------
* API for table
*/
#define GRN_TABLE_MAX_KEY_SIZE (0x1000)
GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
const char *name, unsigned int name_size,
const char *path, grn_obj_flags flags,
grn_obj *key_type, grn_obj *value_type);
#define GRN_TABLE_OPEN_OR_CREATE(ctx,name,name_size,path,flags,key_type,value_type,table) \
(((table) = grn_ctx_get((ctx), (name), (name_size))) ||\
((table) = grn_table_create((ctx), (name), (name_size), (path), (flags), (key_type), (value_type))))
/* TODO: int *added -> grn_bool *added */
GRN_API grn_id grn_table_add(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size, int *added);
GRN_API grn_id grn_table_get(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API grn_id grn_table_at(grn_ctx *ctx, grn_obj *table, grn_id id);
GRN_API grn_id grn_table_lcp_search(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API int grn_table_get_key(grn_ctx *ctx, grn_obj *table,
grn_id id, void *keybuf, int buf_size);
GRN_API grn_rc grn_table_delete(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API grn_rc grn_table_delete_by_id(grn_ctx *ctx, grn_obj *table, grn_id id);
GRN_API grn_rc grn_table_update_by_id(grn_ctx *ctx, grn_obj *table, grn_id id,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_table_update(grn_ctx *ctx, grn_obj *table,
const void *src_key, unsigned int src_key_size,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_table_truncate(grn_ctx *ctx, grn_obj *table);
typedef grn_obj grn_table_cursor;
#define GRN_CURSOR_ASCENDING (0x00<<0)
#define GRN_CURSOR_DESCENDING (0x01<<0)
#define GRN_CURSOR_GE (0x00<<1)
#define GRN_CURSOR_GT (0x01<<1)
#define GRN_CURSOR_LE (0x00<<2)
#define GRN_CURSOR_LT (0x01<<2)
#define GRN_CURSOR_BY_KEY (0x00<<3)
#define GRN_CURSOR_BY_ID (0x01<<3)
#define GRN_CURSOR_PREFIX (0x01<<4)
#define GRN_CURSOR_SIZE_BY_BIT (0x01<<5)
#define GRN_CURSOR_RK (0x01<<6)
GRN_API grn_table_cursor *grn_table_cursor_open(grn_ctx *ctx, grn_obj *table,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_rc grn_table_cursor_close(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API grn_id grn_table_cursor_next(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API int grn_table_cursor_get_key(grn_ctx *ctx, grn_table_cursor *tc, void **key);
GRN_API int grn_table_cursor_get_value(grn_ctx *ctx, grn_table_cursor *tc, void **value);
GRN_API grn_rc grn_table_cursor_set_value(grn_ctx *ctx, grn_table_cursor *tc,
const void *value, int flags);
GRN_API grn_rc grn_table_cursor_delete(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API grn_obj *grn_table_cursor_table(grn_ctx *ctx, grn_table_cursor *tc);
typedef struct {
grn_id rid;
grn_id sid;
unsigned int pos;
unsigned int tf;
unsigned int weight;
unsigned int rest;
} grn_posting;
GRN_API grn_obj *grn_index_cursor_open(grn_ctx *ctx, grn_table_cursor *tc, grn_obj *index,
grn_id rid_min, grn_id rid_max, int flags);
GRN_API grn_posting *grn_index_cursor_next(grn_ctx *ctx, grn_obj *ic, grn_id *tid);
#define GRN_TABLE_EACH(ctx,table,head,tail,id,key,key_size,value,block) do {\
(ctx)->errlvl = GRN_LOG_NOTICE;\
(ctx)->rc = GRN_SUCCESS;\
if ((ctx)->seqno & 1) {\
(ctx)->subno++;\
} else {\
(ctx)->seqno++;\
}\
if (table) {\
switch ((table)->header.type) {\
case GRN_TABLE_PAT_KEY :\
GRN_PAT_EACH((ctx), (grn_pat *)(table), (id), (key), (key_size), (value), block);\
break;\
case GRN_TABLE_DAT_KEY :\
GRN_DAT_EACH((ctx), (grn_dat *)(table), (id), (key), (key_size), block);\
break;\
case GRN_TABLE_HASH_KEY :\
GRN_HASH_EACH((ctx), (grn_hash *)(table), (id), (key), (key_size), (value), block);\
break;\
case GRN_TABLE_NO_KEY :\
GRN_ARRAY_EACH((ctx), (grn_array *)(table), (head), (tail), (id), (value), block);\
break;\
}\
}\
if ((ctx)->subno) {\
(ctx)->subno--;\
} else {\
(ctx)->seqno++;\
}\
} while (0)
typedef struct _grn_table_sort_key grn_table_sort_key;
typedef unsigned char grn_table_sort_flags;
#define GRN_TABLE_SORT_ASC (0x00<<0)
#define GRN_TABLE_SORT_DESC (0x01<<0)
struct _grn_table_sort_key {
grn_obj *key;
grn_table_sort_flags flags;
int offset;
};
GRN_API int grn_table_sort(grn_ctx *ctx, grn_obj *table, int offset, int limit,
grn_obj *result, grn_table_sort_key *keys, int n_keys);
typedef struct _grn_table_group_result grn_table_group_result;
typedef unsigned int grn_table_group_flags;
#define GRN_TABLE_GROUP_CALC_COUNT (0x01<<3)
#define GRN_TABLE_GROUP_CALC_MAX (0x01<<4)
#define GRN_TABLE_GROUP_CALC_MIN (0x01<<5)
#define GRN_TABLE_GROUP_CALC_SUM (0x01<<6)
#define GRN_TABLE_GROUP_CALC_AVG (0x01<<7)
typedef enum {
GRN_OP_PUSH = 0,
GRN_OP_POP,
GRN_OP_NOP,
GRN_OP_CALL,
GRN_OP_INTERN,
GRN_OP_GET_REF,
GRN_OP_GET_VALUE,
GRN_OP_AND,
GRN_OP_AND_NOT,
/* Deprecated. Just for backward compatibility. */
#define GRN_OP_BUT 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_NEAR2,
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_operator;
struct _grn_table_group_result {
grn_obj *table;
unsigned char key_begin;
unsigned char key_end;
int limit;
grn_table_group_flags flags;
grn_operator op;
};
GRN_API grn_rc grn_table_group(grn_ctx *ctx, grn_obj *table,
grn_table_sort_key *keys, int n_keys,
grn_table_group_result *results, int n_results);
GRN_API grn_rc grn_table_setoperation(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
grn_obj *res, grn_operator op);
GRN_API grn_rc grn_table_difference(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
grn_obj *res1, grn_obj *res2);
GRN_API int grn_table_columns(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size,
grn_obj *res);
GRN_API grn_obj *grn_obj_column(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size);
GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
/*-------------------------------------------------------------
* API for column
*/
#define GRN_COLUMN_NAME_ID "_id"
#define GRN_COLUMN_NAME_ID_LEN (sizeof(GRN_COLUMN_NAME_ID) - 1)
#define GRN_COLUMN_NAME_KEY "_key"
#define GRN_COLUMN_NAME_KEY_LEN (sizeof(GRN_COLUMN_NAME_KEY) - 1)
#define GRN_COLUMN_NAME_VALUE "_value"
#define GRN_COLUMN_NAME_VALUE_LEN (sizeof(GRN_COLUMN_NAME_VALUE) - 1)
#define GRN_COLUMN_NAME_SCORE "_score"
#define GRN_COLUMN_NAME_SCORE_LEN (sizeof(GRN_COLUMN_NAME_SCORE) - 1)
#define GRN_COLUMN_NAME_NSUBRECS "_nsubrecs"
#define GRN_COLUMN_NAME_NSUBRECS_LEN (sizeof(GRN_COLUMN_NAME_NSUBRECS) - 1)
GRN_API grn_obj *grn_column_create(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size,
const char *path, grn_obj_flags flags, grn_obj *type);
#define GRN_COLUMN_OPEN_OR_CREATE(ctx,table,name,name_size,path,flags,type,column) \
(((column) = grn_obj_column((ctx), (table), (name), (name_size))) ||\
((column) = grn_column_create((ctx), (table), (name), (name_size), (path), (flags), (type))))
GRN_API grn_rc grn_column_index_update(grn_ctx *ctx, grn_obj *column,
grn_id id, unsigned int section,
grn_obj *oldvalue, grn_obj *newvalue);
GRN_API grn_obj *grn_column_table(grn_ctx *ctx, grn_obj *column);
/*-------------------------------------------------------------
* API for db, table and/or column
*/
typedef enum {
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_VERSION,
GRN_INFO_CONFIGURE_OPTIONS,
GRN_INFO_CONFIG_PATH,
*/
GRN_INFO_PARTIAL_MATCH_THRESHOLD,
GRN_INFO_II_SPLIT_THRESHOLD,
GRN_INFO_SUPPORT_ZLIB,
GRN_INFO_SUPPORT_LZO,
GRN_INFO_NORMALIZER,
GRN_INFO_TOKEN_FILTERS
} grn_info_type;
GRN_API grn_obj *grn_obj_get_info(grn_ctx *ctx, grn_obj *obj, grn_info_type type, grn_obj *valuebuf);
GRN_API grn_rc grn_obj_set_info(grn_ctx *ctx, grn_obj *obj, grn_info_type type, grn_obj *value);
GRN_API grn_obj *grn_obj_get_element_info(grn_ctx *ctx, grn_obj *obj, grn_id id,
grn_info_type type, grn_obj *value);
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);
GRN_API grn_bool grn_obj_is_builtin(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_obj *grn_obj_get_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value);
GRN_API int grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void **values);
#define GRN_COLUMN_EACH(ctx,column,id,value,block) 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)
#define GRN_OBJ_SET_MASK (0x07)
#define GRN_OBJ_SET (0x01)
#define GRN_OBJ_INCR (0x02)
#define GRN_OBJ_DECR (0x03)
#define GRN_OBJ_APPEND (0x04)
#define GRN_OBJ_PREPEND (0x05)
#define GRN_OBJ_GET (0x01<<4)
#define GRN_OBJ_COMPARE (0x01<<5)
#define GRN_OBJ_LOCK (0x01<<6)
#define GRN_OBJ_UNLOCK (0x01<<7)
GRN_API grn_rc grn_obj_set_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value, int flags);
GRN_API grn_rc grn_obj_remove(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_rc grn_obj_rename(grn_ctx *ctx, grn_obj *obj,
const char *name, unsigned int name_size);
GRN_API grn_rc grn_table_rename(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size);
GRN_API grn_rc grn_column_rename(grn_ctx *ctx, grn_obj *column,
const char *name, unsigned int name_size);
GRN_API grn_rc grn_obj_close(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_rc grn_obj_reinit(grn_ctx *ctx, grn_obj *obj, grn_id domain, unsigned char flags);
GRN_API void grn_obj_unlink(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_user_data *grn_obj_user_data(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_rc grn_obj_set_finalizer(grn_ctx *ctx, grn_obj *obj, grn_proc_func *func);
GRN_API const char *grn_obj_path(grn_ctx *ctx, grn_obj *obj);
GRN_API int grn_obj_name(grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size);
GRN_API int grn_column_name(grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size);
GRN_API grn_id grn_obj_get_range(grn_ctx *ctx, grn_obj *obj);
#define GRN_OBJ_GET_DOMAIN(obj) \
((obj)->header.type == GRN_TABLE_NO_KEY ? GRN_ID_NIL : (obj)->header.domain)
GRN_API int grn_obj_expire(grn_ctx *ctx, grn_obj *obj, int threshold);
GRN_API int grn_obj_check(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_rc grn_obj_lock(grn_ctx *ctx, grn_obj *obj, grn_id id, int timeout);
GRN_API grn_rc grn_obj_unlock(grn_ctx *ctx, grn_obj *obj, grn_id id);
GRN_API grn_rc grn_obj_clear_lock(grn_ctx *ctx, grn_obj *obj);
GRN_API unsigned int grn_obj_is_locked(grn_ctx *ctx, grn_obj *obj);
GRN_API int grn_obj_defrag(grn_ctx *ctx, grn_obj *obj, int threshold);
GRN_API grn_obj *grn_obj_db(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_id grn_obj_id(grn_ctx *ctx, grn_obj *obj);
typedef struct _grn_search_optarg grn_search_optarg;
struct _grn_search_optarg {
grn_operator mode;
int similarity_threshold;
int max_interval;
int *weight_vector;
int vector_size;
grn_obj *proc;
int max_size;
};
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);
typedef grn_rc grn_selector_func(grn_ctx *ctx, grn_obj *table, grn_obj *index,
int nargs, grn_obj **args,
grn_obj *res, grn_operator op);
GRN_API grn_rc grn_proc_set_selector(grn_ctx *ctx, grn_obj *proc,
grn_selector_func selector);
/*-------------------------------------------------------------
* grn_vector
*/
GRN_API unsigned int grn_vector_size(grn_ctx *ctx, grn_obj *vector);
GRN_API grn_rc grn_vector_add_element(grn_ctx *ctx, grn_obj *vector,
const char *str, unsigned int str_len,
unsigned int weight, grn_id domain);
GRN_API unsigned int grn_vector_get_element(grn_ctx *ctx, grn_obj *vector,
unsigned int offset, const char **str,
unsigned int *weight, grn_id *domain);
/*-------------------------------------------------------------
* grn_uvector
*/
GRN_API unsigned int grn_uvector_size(grn_ctx *ctx, grn_obj *uvector);
GRN_API grn_rc grn_uvector_add_element(grn_ctx *ctx, grn_obj *vector,
grn_id id, unsigned int weight);
GRN_API grn_id grn_uvector_get_element(grn_ctx *ctx, grn_obj *uvector,
unsigned int offset,
unsigned int *weight);
/*-------------------------------------------------------------
* API for hook
*/
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);
typedef enum {
GRN_HOOK_SET = 0,
GRN_HOOK_GET,
GRN_HOOK_INSERT,
GRN_HOOK_DELETE,
GRN_HOOK_SELECT
} grn_hook_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);
GRN_API int grn_obj_get_nhooks(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry);
GRN_API grn_obj *grn_obj_get_hook(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry,
int offset, grn_obj *data);
GRN_API grn_rc grn_obj_delete_hook(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry, int offset);
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 grn_rc grn_obj_delete_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, grn_bool removep);
GRN_API grn_rc grn_obj_path_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, char *buffer);
/* geo */
typedef struct {
int latitude;
int longitude;
} grn_geo_point;
GRN_API grn_rc grn_geo_select_in_rectangle(grn_ctx *ctx,
grn_obj *index,
grn_obj *top_left_point,
grn_obj *bottom_right_point,
grn_obj *res,
grn_operator op);
GRN_API int grn_geo_estimate_in_rectangle(grn_ctx *ctx,
grn_obj *index,
grn_obj *top_left_point,
grn_obj *bottom_right_point);
GRN_API grn_obj *grn_geo_cursor_open_in_rectangle(grn_ctx *ctx,
grn_obj *index,
grn_obj *top_left_point,
grn_obj *bottom_right_point,
int offset,
int limit);
GRN_API grn_posting *grn_geo_cursor_next(grn_ctx *ctx, grn_obj *cursor);
/* query & snippet */
#ifndef GRN_QUERY_AND
#define GRN_QUERY_AND '+'
#endif /* GRN_QUERY_AND */
#ifndef GRN_QUERY_AND_NOT
# ifdef GRN_QUERY_BUT
/* Deprecated. Just for backward compatibility. */
# define GRN_QUERY_AND_NOT GRN_QUERY_BUT
# else
# define GRN_QUERY_AND_NOT '-'
# endif /* GRN_QUERY_BUT */
#endif /* GRN_QUERY_AND_NOT */
#ifndef GRN_QUERY_ADJ_INC
#define GRN_QUERY_ADJ_INC '>'
#endif /* GRN_QUERY_ADJ_POS2 */
#ifndef GRN_QUERY_ADJ_DEC
#define GRN_QUERY_ADJ_DEC '<'
#endif /* GRN_QUERY_ADJ_POS1 */
#ifndef GRN_QUERY_ADJ_NEG
#define GRN_QUERY_ADJ_NEG '~'
#endif /* GRN_QUERY_ADJ_NEG */
#ifndef GRN_QUERY_PREFIX
#define GRN_QUERY_PREFIX '*'
#endif /* GRN_QUERY_PREFIX */
#ifndef GRN_QUERY_PARENL
#define GRN_QUERY_PARENL '('
#endif /* GRN_QUERY_PARENL */
#ifndef GRN_QUERY_PARENR
#define GRN_QUERY_PARENR ')'
#endif /* GRN_QUERY_PARENR */
#ifndef GRN_QUERY_QUOTEL
#define GRN_QUERY_QUOTEL '"'
#endif /* GRN_QUERY_QUOTEL */
#ifndef GRN_QUERY_QUOTER
#define GRN_QUERY_QUOTER '"'
#endif /* GRN_QUERY_QUOTER */
#ifndef GRN_QUERY_ESCAPE
#define GRN_QUERY_ESCAPE '\\'
#endif /* GRN_QUERY_ESCAPE */
#ifndef GRN_QUERY_COLUMN
#define GRN_QUERY_COLUMN ':'
#endif /* GRN_QUERY_COLUMN */
typedef struct _grn_snip_mapping grn_snip_mapping;
struct _grn_snip_mapping {
void *dummy;
};
#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)
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_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);
/* log */
#define GRN_LOG_TIME (0x01<<0)
#define GRN_LOG_TITLE (0x01<<1)
#define GRN_LOG_MESSAGE (0x01<<2)
#define GRN_LOG_LOCATION (0x01<<3)
/* Deprecated since 2.1.2. Use grn_logger instead. */
typedef struct _grn_logger_info grn_logger_info;
/* Deprecated since 2.1.2. Use grn_logger instead. */
struct _grn_logger_info {
grn_log_level max_level;
int flags;
void (*func)(int, const char *, const char *, const char *, const char *, void *);
void *func_arg;
};
/* Deprecated since 2.1.2. Use grn_logger_set() instead. */
GRN_API grn_rc grn_logger_info_set(grn_ctx *ctx, const grn_logger_info *info);
typedef struct _grn_logger grn_logger;
struct _grn_logger {
grn_log_level max_level;
int flags;
void *user_data;
void (*log)(grn_ctx *ctx, grn_log_level level,
const char *timestamp, const char *title, const char *message,
const char *location, void *user_data);
void (*reopen)(grn_ctx *ctx, void *user_data);
void (*fin)(grn_ctx *ctx, void *user_data);
};
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);
#ifdef __GNUC__
#define GRN_ATTRIBUTE_PRINTF(fmt_pos) \
__attribute__ ((format(printf, fmt_pos, fmt_pos + 1)))
#else
#define GRN_ATTRIBUTE_PRINTF(fmt_pos)
#endif /* __GNUC__ */
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_reopen(grn_ctx *ctx);
GRN_API grn_bool grn_logger_pass(grn_ctx *ctx, grn_log_level level);
#ifndef GRN_LOG_DEFAULT_LEVEL
#define GRN_LOG_DEFAULT_LEVEL GRN_LOG_NOTICE
#endif /* GRN_LOG_DEFAULT_LEVEL */
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_path(const char *path);
GRN_API const char *grn_default_logger_get_path(void);
#define GRN_LOG(ctx,level,...) do {\
if (grn_logger_pass(ctx, level)) {\
grn_logger_put(ctx, (level), __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__); \
}\
} while (0)
typedef struct _grn_query_logger grn_query_logger;
struct _grn_query_logger {
unsigned int flags;
void *user_data;
void (*log)(grn_ctx *ctx, unsigned int flag,
const char *timestamp, const char *info, const char *message,
void *user_data);
void (*reopen)(grn_ctx *ctx, void *user_data);
void (*fin)(grn_ctx *ctx, void *user_data);
};
GRN_API grn_rc grn_query_logger_set(grn_ctx *ctx, const grn_query_logger *logger);
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 grn_bool grn_query_logger_pass(grn_ctx *ctx, unsigned int flag);
GRN_API void grn_default_query_logger_set_flags(unsigned int flags);
GRN_API unsigned int grn_default_query_logger_get_flags(void);
GRN_API void grn_default_query_logger_set_path(const char *path);
GRN_API const char *grn_default_query_logger_get_path(void);
#define GRN_QUERY_LOG(ctx, flag, mark, format, ...) do {\
if (grn_query_logger_pass(ctx, flag)) {\
grn_query_logger_put(ctx, (flag), (mark), format, __VA_ARGS__);\
}\
} while (0)
/* grn_bulk */
#define GRN_BULK_BUFSIZE (sizeof(grn_obj) - sizeof(grn_obj_header))
/* This assumes that GRN_BULK_BUFSIZE is less than 32 (= 0x20). */
#define GRN_BULK_BUFSIZE_MAX 0x1f
#define GRN_BULK_SIZE_IN_FLAGS(flags) ((flags) & GRN_BULK_BUFSIZE_MAX)
#define GRN_BULK_OUTP(bulk) ((bulk)->header.impl_flags & GRN_OBJ_OUTPLACE)
#define GRN_BULK_REWIND(bulk) 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_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_BULK_BUFSIZE_MAX;\
}\
}\
} while (0)
#define GRN_BULK_WSIZE(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.tail - (bulk)->u.b.head)\
: GRN_BULK_BUFSIZE)
#define GRN_BULK_REST(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.tail - (bulk)->u.b.curr)\
: GRN_BULK_BUFSIZE - (bulk)->header.flags)
#define GRN_BULK_VSIZE(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.curr - (bulk)->u.b.head)\
: GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))
#define GRN_BULK_EMPTYP(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.curr == (bulk)->u.b.head)\
: !(GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags)))
#define GRN_BULK_HEAD(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.head)\
: (char *)&((bulk)->u.b.head))
#define GRN_BULK_CURR(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.curr)\
: (char *)&((bulk)->u.b.head) + GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))
#define GRN_BULK_TAIL(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.tail)\
: (char *)&((bulk)[1]))
GRN_API grn_rc grn_bulk_reinit(grn_ctx *ctx, grn_obj *bulk, unsigned int size);
GRN_API grn_rc grn_bulk_resize(grn_ctx *ctx, grn_obj *bulk, unsigned int newsize);
GRN_API grn_rc grn_bulk_write(grn_ctx *ctx, grn_obj *bulk,
const char *str, unsigned int len);
GRN_API grn_rc grn_bulk_write_from(grn_ctx *ctx, grn_obj *bulk,
const char *str, unsigned int from, unsigned int len);
GRN_API grn_rc grn_bulk_reserve(grn_ctx *ctx, grn_obj *bulk, unsigned int len);
GRN_API grn_rc grn_bulk_space(grn_ctx *ctx, grn_obj *bulk, unsigned int len);
GRN_API grn_rc grn_bulk_truncate(grn_ctx *ctx, grn_obj *bulk, unsigned int len);
GRN_API grn_rc grn_bulk_fin(grn_ctx *ctx, grn_obj *bulk);
/* grn_text */
GRN_API grn_rc grn_text_itoa(grn_ctx *ctx, grn_obj *bulk, int i);
GRN_API grn_rc grn_text_itoa_padded(grn_ctx *ctx, grn_obj *bulk, int i, char ch, unsigned int len);
GRN_API grn_rc grn_text_lltoa(grn_ctx *ctx, grn_obj *bulk, long long int i);
GRN_API grn_rc grn_text_ftoa(grn_ctx *ctx, grn_obj *bulk, double d);
GRN_API grn_rc grn_text_itoh(grn_ctx *ctx, grn_obj *bulk, int i, unsigned int len);
GRN_API grn_rc grn_text_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, unsigned int len);
GRN_API grn_rc grn_text_urlenc(grn_ctx *ctx, grn_obj *buf,
const char *str, unsigned int 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, unsigned int 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_vprintf(grn_ctx *ctx, grn_obj *bulk,
const char *format, va_list args);
typedef struct _grn_obj_format grn_obj_format;
#define GRN_OBJ_FORMAT_WITH_COLUMN_NAMES (0x01<<0)
#define GRN_OBJ_FORMAT_AS_ARRAY (0x01<<3)
/* Deprecated since 4.0.1. It will be removed at 5.0.0.
Use GRN_OBJ_FORMAT_AS_ARRAY instead.*/
#define GRN_OBJ_FORMAT_ASARRAY GRN_OBJ_FORMAT_AS_ARRAY
#define GRN_OBJ_FORMAT_WITH_WEIGHT (0x01<<4)
struct _grn_obj_format {
grn_obj columns;
const void *min;
const void *max;
unsigned int min_size;
unsigned int max_size;
int nhits;
int offset;
int limit;
int hits_offset;
int flags;
grn_obj *expression;
};
#define GRN_OBJ_FORMAT_INIT(format,format_nhits,format_offset,format_limit,format_hits_offset) do { \
GRN_PTR_INIT(&(format)->columns, GRN_OBJ_VECTOR, GRN_ID_NIL);\
(format)->nhits = (format_nhits);\
(format)->offset = (format_offset);\
(format)->limit = (format_limit);\
(format)->hits_offset = (format_hits_offset);\
(format)->flags = 0;\
(format)->expression = NULL;\
} while (0)
#define GRN_OBJ_FORMAT_FIN(ctx,format) do {\
int ncolumns = GRN_BULK_VSIZE(&(format)->columns) / sizeof(grn_obj *);\
grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&(format)->columns);\
while (ncolumns--) { grn_obj_unlink((ctx), *columns++); }\
GRN_OBJ_FIN((ctx), &(format)->columns);\
if ((format)->expression) { GRN_OBJ_FIN((ctx), (format)->expression); } \
} while (0)
GRN_API void grn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
grn_obj *obj, grn_obj_format *format);
GRN_API void grn_output_envelope(grn_ctx *ctx, grn_rc rc,
grn_obj *head, grn_obj *body, grn_obj *foot,
const char *file, int line);
GRN_API void grn_ctx_output_array_open(grn_ctx *ctx,
const char *name, int nelements);
GRN_API void grn_ctx_output_array_close(grn_ctx *ctx);
GRN_API void grn_ctx_output_map_open(grn_ctx *ctx,
const char *name, int nelements);
GRN_API void grn_ctx_output_map_close(grn_ctx *ctx);
GRN_API void grn_ctx_output_int32(grn_ctx *ctx, int value);
GRN_API void grn_ctx_output_int64(grn_ctx *ctx, long long int value);
GRN_API void grn_ctx_output_float(grn_ctx *ctx, double value);
GRN_API void grn_ctx_output_cstr(grn_ctx *ctx, const char *value);
GRN_API void grn_ctx_output_str(grn_ctx *ctx,
const char *value, unsigned int value_len);
GRN_API void grn_ctx_output_bool(grn_ctx *ctx, grn_bool value);
GRN_API void grn_ctx_output_obj(grn_ctx *ctx,
grn_obj *value, grn_obj_format *format);
GRN_API const char *grn_ctx_get_mime_type(grn_ctx *ctx);
GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
void (*func)(grn_ctx *, int, void *),
void *func_arg);
/* obsolete */
GRN_API grn_rc grn_text_otoj(grn_ctx *ctx, grn_obj *bulk, grn_obj *obj,
grn_obj_format *format);
/* various values exchanged via grn_obj */
#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)\
GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_UVECTOR : GRN_BULK,\
((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain))
#define GRN_VALUE_VAR_SIZE_INIT(obj,flags,domain)\
GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_VECTOR : GRN_BULK,\
((flags) & GRN_OBJ_DO_SHALLOW_COPY), (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) do {\
(obj)->u.b.head = (char *)(str);\
(obj)->u.b.curr = (char *)(str) + (len);\
} while (0)
#define GRN_TEXT_SET(ctx,obj,str,len) 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)
#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) do {\
char _c = (c); grn_bulk_write((ctx), (obj), &_c, 1);\
} while (0)
#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_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_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)\
GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_PVECTOR : GRN_PTR,\
((flags) & GRN_OBJ_DO_SHALLOW_COPY), (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) do {\
unsigned char _val = (unsigned char)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned char));\
} while (0)
#define GRN_INT8_SET(ctx,obj,val) do {\
signed char _val = (signed char)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(signed char));\
} while (0)
#define GRN_UINT8_SET(ctx,obj,val) do {\
unsigned char _val = (unsigned char)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned char));\
} while (0)
#define GRN_INT16_SET(ctx,obj,val) do {\
signed short _val = (signed short)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(signed short));\
} while (0)
#define GRN_UINT16_SET(ctx,obj,val) do {\
unsigned short _val = (unsigned short)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned short));\
} while (0)
#define GRN_INT32_SET(ctx,obj,val) do {\
int _val = (int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int));\
} while (0)
#define GRN_UINT32_SET(ctx,obj,val) do {\
unsigned int _val = (unsigned int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned int));\
} while (0)
#define GRN_INT64_SET(ctx,obj,val) do {\
long long int _val = (long long int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(long long int));\
} while (0)
#define GRN_UINT64_SET(ctx,obj,val) do {\
long long unsigned int _val = (long long unsigned int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(long long unsigned int));\
} while (0)
#define GRN_FLOAT_SET(ctx,obj,val) do {\
double _val = (double)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(double));\
} while (0)
#define GRN_TIME_SET GRN_INT64_SET
#define GRN_RECORD_SET(ctx,obj,val) do {\
grn_id _val = (grn_id)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_id));\
} while (0)
#define GRN_PTR_SET(ctx,obj,val) do {\
grn_obj *_val = (grn_obj *)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_obj *));\
} while (0)
#define GRN_GEO_DEGREE2MSEC(degree)\
((int)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))
#define GRN_GEO_MSEC2DEGREE(msec)\
((((int)(msec)) / 3600.0) * 0.001)
#define GRN_GEO_POINT_SET(ctx,obj,_latitude,_longitude) 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)
#define GRN_BOOL_SET_AT(ctx,obj,offset,val) do {\
unsigned char _val = (unsigned char)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset), sizeof(unsigned char));\
} while (0)
#define GRN_INT8_SET_AT(ctx,obj,offset,val) do {\
signed char _val = (signed char)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(signed char), sizeof(signed char));\
} while (0)
#define GRN_UINT8_SET_AT(ctx,obj,offset,val) do { \
unsigned char _val = (unsigned char)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(unsigned char), sizeof(unsigned char));\
} while (0)
#define GRN_INT16_SET_AT(ctx,obj,offset,val) do {\
signed short _val = (signed short)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(signed short), sizeof(signed short));\
} while (0)
#define GRN_UINT16_SET_AT(ctx,obj,offset,val) do { \
unsigned short _val = (unsigned short)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(unsigned short), sizeof(unsigned short));\
} while (0)
#define GRN_INT32_SET_AT(ctx,obj,offset,val) do {\
int _val = (int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(int), sizeof(int));\
} while (0)
#define GRN_UINT32_SET_AT(ctx,obj,offset,val) do { \
unsigned int _val = (unsigned int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(unsigned int), sizeof(unsigned int));\
} while (0)
#define GRN_INT64_SET_AT(ctx,obj,offset,val) do {\
long long int _val = (long long int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(long long int), sizeof(long long int));\
} while (0)
#define GRN_UINT64_SET_AT(ctx,obj,offset,val) do {\
long long unsigned int _val = (long long unsigned int)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(long long unsigned int),\
sizeof(long long unsigned int));\
} while (0)
#define GRN_FLOAT_SET_AT(ctx,obj,offset,val) do {\
double _val = (double)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(double), sizeof(double));\
} while (0)
#define GRN_TIME_SET_AT GRN_INT64_SET_AT
#define GRN_RECORD_SET_AT(ctx,obj,offset,val) do {\
grn_id _val = (grn_id)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(grn_id), sizeof(grn_id));\
} while (0)
#define GRN_PTR_SET_AT(ctx,obj,offset,val) do {\
grn_obj *_val = (grn_obj *)(val);\
grn_bulk_write_from((ctx), (obj), (char *)&_val,\
(offset) * sizeof(grn_obj *), sizeof(grn_obj *));\
} while (0)
#define GRN_TIME_USEC_PER_SEC 1000000
#define GRN_TIME_PACK(sec, usec) ((long long int)(sec) * GRN_TIME_USEC_PER_SEC + (usec))
#define GRN_TIME_UNPACK(time_value, sec, usec) do {\
sec = (time_value) / GRN_TIME_USEC_PER_SEC;\
usec = (time_value) % GRN_TIME_USEC_PER_SEC;\
} while (0)
GRN_API void grn_time_now(grn_ctx *ctx, grn_obj *obj);
#define GRN_TIME_NOW(ctx,obj) (grn_time_now((ctx), (obj)))
#define GRN_BOOL_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
#define GRN_INT8_VALUE(obj) (*((signed char *)GRN_BULK_HEAD(obj)))
#define GRN_UINT8_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
#define GRN_INT16_VALUE(obj) (*((signed short *)GRN_BULK_HEAD(obj)))
#define GRN_UINT16_VALUE(obj) (*((unsigned short *)GRN_BULK_HEAD(obj)))
#define GRN_INT32_VALUE(obj) (*((int *)GRN_BULK_HEAD(obj)))
#define GRN_UINT32_VALUE(obj) (*((unsigned int *)GRN_BULK_HEAD(obj)))
#define GRN_INT64_VALUE(obj) (*((long long int *)GRN_BULK_HEAD(obj)))
#define GRN_UINT64_VALUE(obj) (*((long long unsigned int *)GRN_BULK_HEAD(obj)))
#define GRN_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(obj,_latitude,_longitude) do {\
grn_geo_point *_val = (grn_geo_point *)GRN_BULK_HEAD(obj);\
_latitude = _val->latitude;\
_longitude = _val->longitude;\
} while (0)
#define GRN_BOOL_VALUE_AT(obj,offset) (((unsigned char *)GRN_BULK_HEAD(obj))[offset])
#define GRN_INT8_VALUE_AT(obj,offset) (((signed char *)GRN_BULK_HEAD(obj))[offset])
#define GRN_UINT8_VALUE_AT(obj,offset) (((unsigned char *)GRN_BULK_HEAD(obj))[offset])
#define GRN_INT16_VALUE_AT(obj,offset) (((signed short *)GRN_BULK_HEAD(obj))[offset])
#define GRN_UINT16_VALUE_AT(obj,offset) (((unsigned short *)GRN_BULK_HEAD(obj))[offset])
#define GRN_INT32_VALUE_AT(obj,offset) (((int *)GRN_BULK_HEAD(obj))[offset])
#define GRN_UINT32_VALUE_AT(obj,offset) (((unsigned int *)GRN_BULK_HEAD(obj))[offset])
#define GRN_INT64_VALUE_AT(obj,offset) (((long long int *)GRN_BULK_HEAD(obj))[offset])
#define GRN_UINT64_VALUE_AT(obj,offset) (((long long unsigned int *)GRN_BULK_HEAD(obj))[offset])
#define GRN_FLOAT_VALUE_AT(obj,offset) (((double *)GRN_BULK_HEAD(obj))[offset])
#define GRN_TIME_VALUE_AT GRN_INT64_VALUE_AT
#define GRN_RECORD_VALUE_AT(obj,offset) (((grn_id *)GRN_BULK_HEAD(obj))[offset])
#define GRN_PTR_VALUE_AT(obj,offset) (((grn_obj **)GRN_BULK_HEAD(obj))[offset])
#define GRN_BOOL_PUT(ctx,obj,val) do {\
unsigned char _val = (unsigned char)(val);\
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned char));\
} while (0)
#define GRN_INT8_PUT(ctx,obj,val) do {\
signed char _val = (signed char)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(signed char));\
} while (0)
#define GRN_UINT8_PUT(ctx,obj,val) do {\
unsigned char _val = (unsigned char)(val);\
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned char));\
} while (0)
#define GRN_INT16_PUT(ctx,obj,val) do {\
signed short _val = (signed short)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(signed short));\
} while (0)
#define GRN_UINT16_PUT(ctx,obj,val) do {\
unsigned short _val = (unsigned short)(val);\
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned short));\
} while (0)
#define GRN_INT32_PUT(ctx,obj,val) do {\
int _val = (int)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int));\
} while (0)
#define GRN_UINT32_PUT(ctx,obj,val) do {\
unsigned int _val = (unsigned int)(val);\
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int));\
} while (0)
#define GRN_INT64_PUT(ctx,obj,val) do {\
long long int _val = (long long int)(val);\
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(long long int));\
} while (0)
#define GRN_UINT64_PUT(ctx,obj,val) do {\
long long unsigned int _val = (long long unsigned int)(val);\
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(long long unsigned int));\
} while (0)
#define GRN_FLOAT_PUT(ctx,obj,val) do {\
double _val = (double)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(double));\
} while (0)
#define GRN_TIME_PUT GRN_INT64_PUT
#define GRN_RECORD_PUT(ctx,obj,val) do {\
grn_id _val = (grn_id)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_id));\
} while (0)
#define GRN_PTR_PUT(ctx,obj,val) do {\
grn_obj *_val = (grn_obj *)(val);\
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_obj *));\
} while (0)
/* grn_str: deprecated. use grn_string instead. */
typedef struct {
const char *orig;
char *norm;
short *checks;
unsigned char *ctypes;
int flags;
unsigned int orig_blen;
unsigned int norm_blen;
unsigned int length;
grn_encoding encoding;
} grn_str;
#define GRN_STR_REMOVEBLANK (0x01<<0)
#define GRN_STR_WITH_CTYPES (0x01<<1)
#define GRN_STR_WITH_CHECKS (0x01<<2)
#define GRN_STR_NORMALIZE GRN_OBJ_KEY_NORMALIZE
GRN_API grn_str *grn_str_open(grn_ctx *ctx, const char *str, unsigned int str_len,
int flags);
GRN_API grn_rc grn_str_close(grn_ctx *ctx, grn_str *nstr);
/* grn_string */
#define GRN_STRING_REMOVE_BLANK (0x01<<0)
#define GRN_STRING_WITH_TYPES (0x01<<1)
#define GRN_STRING_WITH_CHECKS (0x01<<2)
#define GRN_STRING_REMOVE_TOKENIZED_DELIMITER (0x01<<3)
#define GRN_NORMALIZER_AUTO ((grn_obj *)1)
#define GRN_CHAR_BLANK 0x80
#define GRN_CHAR_IS_BLANK(c) ((c) & (GRN_CHAR_BLANK))
#define GRN_CHAR_TYPE(c) ((c) & 0x7f)
typedef enum {
GRN_CHAR_NULL = 0,
GRN_CHAR_ALPHA,
GRN_CHAR_DIGIT,
GRN_CHAR_SYMBOL,
GRN_CHAR_HIRAGANA,
GRN_CHAR_KATAKANA,
GRN_CHAR_KANJI,
GRN_CHAR_OTHERS
} grn_char_type;
GRN_API grn_obj *grn_string_open(grn_ctx *ctx,
const char *string,
unsigned int length_in_bytes,
grn_obj *normalizer, int flags);
GRN_API grn_rc grn_string_get_original(grn_ctx *ctx, grn_obj *string,
const char **original,
unsigned int *length_in_bytes);
GRN_API int grn_string_get_flags(grn_ctx *ctx, grn_obj *string);
GRN_API grn_rc grn_string_get_normalized(grn_ctx *ctx, grn_obj *string,
const char **normalized,
unsigned int *length_in_bytes,
unsigned int *n_characters);
GRN_API grn_rc grn_string_set_normalized(grn_ctx *ctx, grn_obj *string,
char *normalized,
unsigned int length_in_bytes,
unsigned int n_characters);
GRN_API const short *grn_string_get_checks(grn_ctx *ctx, grn_obj *string);
GRN_API grn_rc grn_string_set_checks(grn_ctx *ctx,
grn_obj *string,
short *checks);
GRN_API const unsigned char *grn_string_get_types(grn_ctx *ctx, grn_obj *string);
GRN_API grn_rc grn_string_set_types(grn_ctx *ctx,
grn_obj *string,
unsigned char *types);
GRN_API grn_encoding grn_string_get_encoding(grn_ctx *ctx, grn_obj *string);
GRN_API int grn_charlen(grn_ctx *ctx, const char *str, const char *end);
/* expr */
GRN_API grn_obj *grn_expr_create(grn_ctx *ctx, const char *name, unsigned int name_size);
GRN_API grn_rc grn_expr_close(grn_ctx *ctx, grn_obj *expr);
GRN_API grn_obj *grn_expr_add_var(grn_ctx *ctx, grn_obj *expr,
const char *name, unsigned int name_size);
GRN_API grn_obj *grn_expr_get_var(grn_ctx *ctx, grn_obj *expr,
const char *name, unsigned int name_size);
GRN_API grn_obj *grn_expr_get_var_by_offset(grn_ctx *ctx, grn_obj *expr, unsigned int offset);
GRN_API grn_obj *grn_expr_append_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
grn_operator op, int nargs);
GRN_API grn_obj *grn_expr_append_const(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
grn_operator op, int nargs);
GRN_API grn_obj *grn_expr_append_const_str(grn_ctx *ctx, grn_obj *expr,
const char *str, unsigned int str_size,
grn_operator op, int nargs);
GRN_API grn_obj *grn_expr_append_const_int(grn_ctx *ctx, grn_obj *expr, int i,
grn_operator op, int nargs);
GRN_API grn_rc grn_expr_append_op(grn_ctx *ctx, grn_obj *expr, grn_operator op, int nargs);
GRN_API grn_rc grn_expr_get_keywords(grn_ctx *ctx, grn_obj *expr, grn_obj *keywords);
GRN_API grn_rc grn_expr_syntax_escape(grn_ctx *ctx,
const char *query, int query_size,
const char *target_characters,
char escape_character,
grn_obj *escaped_query);
GRN_API grn_rc grn_expr_syntax_escape_query(grn_ctx *ctx,
const char *query, int query_size,
grn_obj *escaped_query);
GRN_API grn_rc grn_expr_compile(grn_ctx *ctx, grn_obj *expr);
GRN_API grn_obj *grn_expr_exec(grn_ctx *ctx, grn_obj *expr, int nargs);
GRN_API grn_rc grn_ctx_push(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_obj *grn_ctx_pop(grn_ctx *ctx);
GRN_API grn_obj *grn_expr_alloc(grn_ctx *ctx, grn_obj *expr,
grn_id domain, grn_obj_flags flags);
GRN_API grn_obj *grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
grn_obj *res, grn_operator op);
GRN_API int grn_obj_columns(grn_ctx *ctx, grn_obj *table,
const char *str, unsigned int str_size, grn_obj *res);
#define GRN_EXPR_CREATE_FOR_QUERY(ctx,table,expr,var) do {\
if (((expr) = grn_expr_create((ctx), NULL, 0)) &&\
((var) = grn_expr_add_var((ctx), (expr), NULL, 0))) {\
GRN_RECORD_INIT((var), 0, grn_obj_id((ctx), (table)));\
} else {\
(var) = NULL;\
}\
} while (0)
typedef unsigned int grn_expr_flags;
#define GRN_EXPR_SYNTAX_QUERY (0x00)
#define GRN_EXPR_SYNTAX_SCRIPT (0x01)
#define GRN_EXPR_SYNTAX_OUTPUT_COLUMNS (0x20)
#define GRN_EXPR_SYNTAX_ADJUSTER (0x40)
#define GRN_EXPR_ALLOW_PRAGMA (0x02)
#define GRN_EXPR_ALLOW_COLUMN (0x04)
#define GRN_EXPR_ALLOW_UPDATE (0x08)
#define GRN_EXPR_ALLOW_LEADING_NOT (0x10)
GRN_API grn_rc grn_expr_parse(grn_ctx *ctx, grn_obj *expr,
const char *str, unsigned int str_size,
grn_obj *default_column, grn_operator default_mode,
grn_operator default_op, grn_expr_flags flags);
GRN_API grn_obj *grn_expr_snip(grn_ctx *ctx, grn_obj *expr, int flags,
unsigned int width, unsigned int max_results,
unsigned int n_tags,
const char **opentags, unsigned int *opentag_lens,
const char **closetags, unsigned int *closetag_lens,
grn_snip_mapping *mapping);
GRN_API grn_rc grn_expr_snip_add_conditions(grn_ctx *ctx,
grn_obj *expr,
grn_obj *snip,
unsigned int n_tags,
const char **opentags,
unsigned int *opentag_lens,
const char **closetags,
unsigned int *closetag_lens);
GRN_API grn_table_sort_key *grn_table_sort_key_from_str(grn_ctx *ctx,
const char *str, unsigned int str_size,
grn_obj *table, unsigned int *nkeys);
GRN_API grn_rc grn_table_sort_key_close(grn_ctx *ctx,
grn_table_sort_key *keys, unsigned int nkeys);
GRN_API grn_bool grn_table_is_grouped(grn_ctx *ctx, grn_obj *table);
GRN_API unsigned int grn_table_max_n_subrecs(grn_ctx *ctx, grn_obj *table);
GRN_API grn_obj *grn_table_create_for_group(grn_ctx *ctx,
const char *name,
unsigned int name_size,
const char *path,
grn_obj *group_key,
grn_obj *value_type,
unsigned int max_n_subrecs);
GRN_API unsigned int grn_table_get_subrecs(grn_ctx *ctx, grn_obj *table,
grn_id id, grn_id *subrecbuf,
int *scorebuf, int buf_size);
GRN_API grn_obj *grn_table_tokenize(grn_ctx *ctx, grn_obj *table,
const char *str, unsigned int str_len,
grn_obj *buf, grn_bool addp);
GRN_API grn_rc grn_load(grn_ctx *ctx, grn_content_type input_type,
const char *table, unsigned int table_len,
const char *columns, unsigned int columns_len,
const char *values, unsigned int values_len,
const char *ifexists, unsigned int ifexists_len,
const char *each, unsigned int each_len);
#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)
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 unsigned int grn_ctx_recv(grn_ctx *ctx, char **str, unsigned int *str_len, int *flags);
typedef struct _grn_ctx_info grn_ctx_info;
struct _grn_ctx_info {
int fd;
unsigned int com_status;
grn_obj *outbuf;
unsigned char stat;
};
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_int_handler(void);
GRN_API grn_rc grn_set_term_handler(void);
/* hash */
typedef struct _grn_hash grn_hash;
typedef struct _grn_hash_cursor grn_hash_cursor;
GRN_API grn_hash *grn_hash_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_hash *grn_hash_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_hash_close(grn_ctx *ctx, grn_hash *hash);
GRN_API grn_id grn_hash_add(grn_ctx *ctx, grn_hash *hash, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API grn_id grn_hash_get(grn_ctx *ctx, grn_hash *hash, const void *key,
unsigned int key_size, void **value);
GRN_API int grn_hash_get_key(grn_ctx *ctx, grn_hash *hash, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_hash_get_key2(grn_ctx *ctx, grn_hash *hash, grn_id id, grn_obj *bulk);
GRN_API int grn_hash_get_value(grn_ctx *ctx, grn_hash *hash, grn_id id, void *valuebuf);
GRN_API grn_rc grn_hash_set_value(grn_ctx *ctx, grn_hash *hash, grn_id id,
const void *value, int flags);
typedef struct _grn_table_delete_optarg grn_table_delete_optarg;
struct _grn_table_delete_optarg {
int flags;
int (*func)(grn_ctx *ctx, grn_obj *, grn_id, void *);
void *func_arg;
};
GRN_API grn_rc grn_hash_delete_by_id(grn_ctx *ctx, grn_hash *hash, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_hash_delete(grn_ctx *ctx, grn_hash *hash,
const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API grn_hash_cursor *grn_hash_cursor_open(grn_ctx *ctx, grn_hash *hash,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_hash_cursor_next(grn_ctx *ctx, grn_hash_cursor *c);
GRN_API void grn_hash_cursor_close(grn_ctx *ctx, grn_hash_cursor *c);
GRN_API int grn_hash_cursor_get_key(grn_ctx *ctx, grn_hash_cursor *c, void **key);
GRN_API int grn_hash_cursor_get_value(grn_ctx *ctx, grn_hash_cursor *c, void **value);
GRN_API grn_rc grn_hash_cursor_set_value(grn_ctx *ctx, grn_hash_cursor *c,
const void *value, int flags);
GRN_API int grn_hash_cursor_get_key_value(grn_ctx *ctx, grn_hash_cursor *c,
void **key, unsigned int *key_size, void **value);
GRN_API grn_rc grn_hash_cursor_delete(grn_ctx *ctx, grn_hash_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_HASH_EACH(ctx,hash,id,key,key_size,value,block) do {\
grn_hash_cursor *_sc = grn_hash_cursor_open(ctx, hash, NULL, 0, NULL, 0, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_hash_cursor_next(ctx, _sc))) {\
grn_hash_cursor_get_key_value(ctx, _sc, (void **)(key),\
(key_size), (void **)(value));\
block\
}\
grn_hash_cursor_close(ctx, _sc);\
}\
} while (0)
/* array */
typedef struct _grn_array grn_array;
typedef struct _grn_array_cursor grn_array_cursor;
GRN_API grn_array *grn_array_create(grn_ctx *ctx, const char *path,
unsigned int value_size, unsigned int flags);
GRN_API grn_array *grn_array_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_array_close(grn_ctx *ctx, grn_array *array);
GRN_API grn_id grn_array_add(grn_ctx *ctx, grn_array *array, void **value);
GRN_API grn_id grn_array_push(grn_ctx *ctx, grn_array *array,
void (*func)(grn_ctx *ctx, grn_array *array,
grn_id id, void *func_arg),
void *func_arg);
GRN_API grn_id grn_array_pull(grn_ctx *ctx, grn_array *array, grn_bool blockp,
void (*func)(grn_ctx *ctx, grn_array *array,
grn_id id, void *func_arg),
void *func_arg);
GRN_API void grn_array_unblock(grn_ctx *ctx, grn_array *array);
GRN_API int grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id, void *valuebuf);
GRN_API grn_rc grn_array_set_value(grn_ctx *ctx, grn_array *array, grn_id id,
const void *value, int flags);
GRN_API grn_array_cursor *grn_array_cursor_open(grn_ctx *ctx, grn_array *array,
grn_id min, grn_id max,
int offset, int limit, int flags);
GRN_API grn_id grn_array_cursor_next(grn_ctx *ctx, grn_array_cursor *cursor);
GRN_API int grn_array_cursor_get_value(grn_ctx *ctx, grn_array_cursor *cursor, void **value);
GRN_API grn_rc grn_array_cursor_set_value(grn_ctx *ctx, grn_array_cursor *cursor,
const void *value, int flags);
GRN_API grn_rc grn_array_cursor_delete(grn_ctx *ctx, grn_array_cursor *cursor,
grn_table_delete_optarg *optarg);
GRN_API void grn_array_cursor_close(grn_ctx *ctx, grn_array_cursor *cursor);
GRN_API grn_rc grn_array_delete_by_id(grn_ctx *ctx, grn_array *array, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_id grn_array_next(grn_ctx *ctx, grn_array *array, grn_id id);
GRN_API void *_grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id);
#define GRN_ARRAY_EACH(ctx,array,head,tail,id,value,block) do {\
grn_array_cursor *_sc = grn_array_cursor_open(ctx, array, head, tail, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_array_cursor_next(ctx, _sc))) {\
grn_array_cursor_get_value(ctx, _sc, (void **)(value));\
block\
}\
grn_array_cursor_close(ctx, _sc); \
}\
} while (0)
/* pat */
typedef struct _grn_pat grn_pat;
typedef struct _grn_pat_cursor grn_pat_cursor;
GRN_API grn_pat *grn_pat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_pat *grn_pat_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_pat_close(grn_ctx *ctx, grn_pat *pat);
GRN_API grn_rc grn_pat_remove(grn_ctx *ctx, const char *path);
GRN_API grn_id grn_pat_get(grn_ctx *ctx, grn_pat *pat, const void *key,
unsigned int key_size, void **value);
GRN_API grn_id grn_pat_add(grn_ctx *ctx, grn_pat *pat, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API int grn_pat_get_key(grn_ctx *ctx, grn_pat *pat, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_pat_get_key2(grn_ctx *ctx, grn_pat *pat, grn_id id, grn_obj *bulk);
GRN_API int grn_pat_get_value(grn_ctx *ctx, grn_pat *pat, grn_id id, void *valuebuf);
GRN_API grn_rc grn_pat_set_value(grn_ctx *ctx, grn_pat *pat, grn_id id,
const void *value, int flags);
GRN_API grn_rc grn_pat_delete_by_id(grn_ctx *ctx, grn_pat *pat, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_pat_delete(grn_ctx *ctx, grn_pat *pat, const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API int grn_pat_delete_with_sis(grn_ctx *ctx, grn_pat *pat, grn_id id,
grn_table_delete_optarg *optarg);
typedef struct _grn_pat_scan_hit grn_pat_scan_hit;
struct _grn_pat_scan_hit {
grn_id id;
unsigned int offset;
unsigned int length;
};
GRN_API int grn_pat_scan(grn_ctx *ctx, grn_pat *pat, const char *str, unsigned int str_len,
grn_pat_scan_hit *sh, unsigned int sh_size, const char **rest);
GRN_API grn_rc grn_pat_prefix_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size, grn_hash *h);
GRN_API grn_rc grn_pat_suffix_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size, grn_hash *h);
GRN_API grn_id grn_pat_lcp_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size);
GRN_API unsigned int grn_pat_size(grn_ctx *ctx, grn_pat *pat);
GRN_API grn_pat_cursor *grn_pat_cursor_open(grn_ctx *ctx, grn_pat *pat,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_pat_cursor_next(grn_ctx *ctx, grn_pat_cursor *c);
GRN_API void grn_pat_cursor_close(grn_ctx *ctx, grn_pat_cursor *c);
GRN_API int grn_pat_cursor_get_key(grn_ctx *ctx, grn_pat_cursor *c, void **key);
GRN_API int grn_pat_cursor_get_value(grn_ctx *ctx, grn_pat_cursor *c, void **value);
GRN_API int grn_pat_cursor_get_key_value(grn_ctx *ctx, grn_pat_cursor *c,
void **key, unsigned int *key_size, void **value);
GRN_API grn_rc grn_pat_cursor_set_value(grn_ctx *ctx, grn_pat_cursor *c,
const void *value, int flags);
GRN_API grn_rc grn_pat_cursor_delete(grn_ctx *ctx, grn_pat_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_PAT_EACH(ctx,pat,id,key,key_size,value,block) do { \
grn_pat_cursor *_sc = grn_pat_cursor_open(ctx, pat, NULL, 0, NULL, 0, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_pat_cursor_next(ctx, _sc))) {\
grn_pat_cursor_get_key_value(ctx, _sc, (void **)(key),\
(key_size), (void **)(value));\
block\
}\
grn_pat_cursor_close(ctx, _sc);\
}\
} while (0)
/* dat */
typedef struct _grn_dat grn_dat;
typedef struct _grn_dat_cursor grn_dat_cursor;
GRN_API grn_dat *grn_dat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_dat *grn_dat_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_dat_close(grn_ctx *ctx, grn_dat *dat);
GRN_API grn_rc grn_dat_remove(grn_ctx *ctx, const char *path);
GRN_API grn_id grn_dat_get(grn_ctx *ctx, grn_dat *dat, const void *key,
unsigned int key_size, void **value);
GRN_API grn_id grn_dat_add(grn_ctx *ctx, grn_dat *dat, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API int grn_dat_get_key(grn_ctx *ctx, grn_dat *dat, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_dat_get_key2(grn_ctx *ctx, grn_dat *dat, grn_id id, grn_obj *bulk);
GRN_API grn_rc grn_dat_delete_by_id(grn_ctx *ctx, grn_dat *dat, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_dat_delete(grn_ctx *ctx, grn_dat *dat, const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_dat_update_by_id(grn_ctx *ctx, grn_dat *dat, grn_id src_key_id,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_dat_update(grn_ctx *ctx, grn_dat *dat,
const void *src_key, unsigned int src_key_size,
const void *dest_key, unsigned int dest_key_size);
GRN_API unsigned int grn_dat_size(grn_ctx *ctx, grn_dat *dat);
GRN_API grn_dat_cursor *grn_dat_cursor_open(grn_ctx *ctx, grn_dat *dat,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_dat_cursor_next(grn_ctx *ctx, grn_dat_cursor *c);
GRN_API void grn_dat_cursor_close(grn_ctx *ctx, grn_dat_cursor *c);
GRN_API int grn_dat_cursor_get_key(grn_ctx *ctx, grn_dat_cursor *c, const void **key);
GRN_API grn_rc grn_dat_cursor_delete(grn_ctx *ctx, grn_dat_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_DAT_EACH(ctx,dat,id,key,key_size,block) do {\
grn_dat_cursor *_sc = grn_dat_cursor_open(ctx, dat, NULL, 0, NULL, 0, 0, -1, 0);\
if (_sc) {\
grn_id id;\
unsigned int *_ks = (key_size);\
if (_ks) {\
while ((id = grn_dat_cursor_next(ctx, _sc))) {\
int _ks_raw = grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
*(_ks) = (unsigned int)_ks_raw;\
block\
}\
} else {\
while ((id = grn_dat_cursor_next(ctx, _sc))) {\
grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
block\
}\
}\
grn_dat_cursor_close(ctx, _sc);\
}\
} while (0)
/* buffered index builder */
typedef struct _grn_ii grn_ii;
typedef struct _grn_ii_buffer grn_ii_buffer;
grn_ii_buffer *grn_ii_buffer_open(grn_ctx *ctx, grn_ii *ii,
long long unsigned int update_buffer_size);
grn_rc grn_ii_buffer_append(grn_ctx *ctx, grn_ii_buffer *ii_buffer,
grn_id rid, unsigned int section, grn_obj *value);
grn_rc grn_ii_buffer_commit(grn_ctx *ctx, grn_ii_buffer *ii_buffer);
grn_rc grn_ii_buffer_close(grn_ctx *ctx, grn_ii_buffer *ii_buffer);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_H */
Reference in a new issue View git blame Copy permalink