Groonga
Loading...
Searching...
No Matches
groonga.h
Go to the documentation of this file.
1/*
2 Copyright (C) 2009-2018 Brazil
3 Copyright (C) 2018-2026 Sutou Kouhei <kou@clear-code.com>
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18*/
19
20#pragma once
21
22#include <stdarg.h>
23#include <stdbool.h>
24#include <stdint.h>
25#include <string.h>
26#include <sys/types.h>
27
28#ifdef __cplusplus
29extern "C" {
30#endif
31
32#ifndef GRN_API
33# ifdef GRN_STATIC
34# define GRN_API
35# else
36# if defined(_WIN32) || defined(_WIN64)
37# define GRN_API __declspec(dllimport)
38# else
39# define GRN_API
40# endif /* defined(_WIN32) || defined(_WIN64) */
41# endif
42#endif /* GRN_API */
43
44typedef uint32_t grn_id;
45/* Deprecated since 9.0.2. Use bool directly. */
46typedef bool grn_bool;
47
48#ifdef GRN_HAVE_BFLOAT16
49typedef __bf16 grn_bfloat16;
50#endif
51
55#define GRN_ID_NIL (0x00)
56#define GRN_ID_MAX (0x3fffffff)
57
58#define GRN_TRUE true
59#define GRN_FALSE false
60
61typedef enum {
63 GRN_SUCCESS = 0,
64 GRN_END_OF_DATA = 1,
65 GRN_UNKNOWN_ERROR = -1,
66 GRN_OPERATION_NOT_PERMITTED = -2,
67 GRN_NO_SUCH_FILE_OR_DIRECTORY = -3,
68 GRN_NO_SUCH_PROCESS = -4,
69 GRN_INTERRUPTED_FUNCTION_CALL = -5,
70 GRN_INPUT_OUTPUT_ERROR = -6,
71 GRN_NO_SUCH_DEVICE_OR_ADDRESS = -7,
72 GRN_ARG_LIST_TOO_LONG = -8,
73 GRN_EXEC_FORMAT_ERROR = -9,
74 GRN_BAD_FILE_DESCRIPTOR = -10,
75 GRN_NO_CHILD_PROCESSES = -11,
76 GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = -12,
77 GRN_NOT_ENOUGH_SPACE = -13,
78 GRN_PERMISSION_DENIED = -14,
79 GRN_BAD_ADDRESS = -15,
80 GRN_RESOURCE_BUSY = -16,
81 GRN_FILE_EXISTS = -17,
82 GRN_IMPROPER_LINK = -18,
83 GRN_NO_SUCH_DEVICE = -19,
84 GRN_NOT_A_DIRECTORY = -20,
85 GRN_IS_A_DIRECTORY = -21,
87 GRN_INVALID_ARGUMENT = -22,
88 GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = -23,
89 GRN_TOO_MANY_OPEN_FILES = -24,
90 GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = -25,
91 GRN_FILE_TOO_LARGE = -26,
92 GRN_NO_SPACE_LEFT_ON_DEVICE = -27,
93 GRN_INVALID_SEEK = -28,
94 GRN_READ_ONLY_FILE_SYSTEM = -29,
95 GRN_TOO_MANY_LINKS = -30,
96 GRN_BROKEN_PIPE = -31,
97 GRN_DOMAIN_ERROR = -32,
98 GRN_RESULT_TOO_LARGE = -33,
99 GRN_RESOURCE_DEADLOCK_AVOIDED = -34,
101 GRN_NO_MEMORY_AVAILABLE = -35,
102 GRN_FILENAME_TOO_LONG = -36,
103 GRN_NO_LOCKS_AVAILABLE = -37,
104 GRN_FUNCTION_NOT_IMPLEMENTED = -38,
105 GRN_DIRECTORY_NOT_EMPTY = -39,
106 GRN_ILLEGAL_BYTE_SEQUENCE = -40,
107 GRN_SOCKET_NOT_INITIALIZED = -41,
108 GRN_OPERATION_WOULD_BLOCK = -42,
109 GRN_ADDRESS_IS_NOT_AVAILABLE = -43,
110 GRN_NETWORK_IS_DOWN = -44,
111 GRN_NO_BUFFER = -45,
112 GRN_SOCKET_IS_ALREADY_CONNECTED = -46,
113 GRN_SOCKET_IS_NOT_CONNECTED = -47,
114 GRN_SOCKET_IS_ALREADY_SHUTDOWNED = -48,
115 GRN_OPERATION_TIMEOUT = -49,
116 GRN_CONNECTION_REFUSED = -50,
117 GRN_RANGE_ERROR = -51,
118 GRN_TOKENIZER_ERROR = -52,
119 GRN_FILE_CORRUPT = -53,
120 GRN_INVALID_FORMAT = -54,
121 GRN_OBJECT_CORRUPT = -55,
122 GRN_TOO_MANY_SYMBOLIC_LINKS = -56,
123 GRN_NOT_SOCKET = -57,
124 GRN_OPERATION_NOT_SUPPORTED = -58,
125 GRN_ADDRESS_IS_IN_USE = -59,
126 GRN_ZLIB_ERROR = -60,
127 GRN_LZ4_ERROR = -61,
128/* Just for backward compatibility. We'll remove it at 5.0.0. */
129#define GRN_LZO_ERROR GRN_LZ4_ERROR
130 GRN_STACK_OVER_FLOW = -62,
131 GRN_SYNTAX_ERROR = -63,
132 GRN_RETRY_MAX = -64,
133 GRN_INCOMPATIBLE_FILE_FORMAT = -65,
134 GRN_UPDATE_NOT_ALLOWED = -66,
135 GRN_TOO_SMALL_OFFSET = -67,
136 GRN_TOO_LARGE_OFFSET = -68,
137 GRN_TOO_SMALL_LIMIT = -69,
138 GRN_CAS_ERROR = -70,
140 GRN_UNSUPPORTED_COMMAND_VERSION = -71,
141 GRN_NORMALIZER_ERROR = -72,
142 GRN_TOKEN_FILTER_ERROR = -73,
143 GRN_COMMAND_ERROR = -74,
144 GRN_PLUGIN_ERROR = -75,
145 GRN_SCORER_ERROR = -76,
146 GRN_CANCEL = -77,
147 GRN_WINDOW_FUNCTION_ERROR = -78,
148 GRN_ZSTD_ERROR = -79,
149 GRN_CONNECTION_RESET = -80,
150 GRN_BLOSC_ERROR = -81,
151 GRN_OPENZL_ERROR = -82,
152 GRN_EXTRACTOR_ERROR = -83,
153} grn_rc;
154
155GRN_API grn_rc
156grn_init(void);
157GRN_API grn_rc
158grn_fin(void);
159
160GRN_API const char *
161grn_get_global_error_message(void);
162
180
187
188#define GRN_COMMAND_VERSION_MIN GRN_COMMAND_VERSION_1
189#define GRN_COMMAND_VERSION_STABLE GRN_COMMAND_VERSION_1
190#define GRN_COMMAND_VERSION_MAX GRN_COMMAND_VERSION_3
191
204
205GRN_API const char *
206grn_log_level_to_string(grn_log_level level);
207GRN_API bool
208grn_log_level_parse(const char *string, grn_log_level *level);
209
210/* query log flags */
211#define GRN_QUERY_LOG_NONE (0x00)
212#define GRN_QUERY_LOG_COMMAND (0x01 << 0)
213#define GRN_QUERY_LOG_RESULT_CODE (0x01 << 1)
214#define GRN_QUERY_LOG_DESTINATION (0x01 << 2)
215#define GRN_QUERY_LOG_CACHE (0x01 << 3)
216#define GRN_QUERY_LOG_SIZE (0x01 << 4)
217#define GRN_QUERY_LOG_SCORE (0x01 << 5)
218#define GRN_QUERY_LOG_ALL \
219 (GRN_QUERY_LOG_COMMAND | GRN_QUERY_LOG_RESULT_CODE | \
220 GRN_QUERY_LOG_DESTINATION | GRN_QUERY_LOG_CACHE | GRN_QUERY_LOG_SIZE | \
221 GRN_QUERY_LOG_SCORE)
222#define GRN_QUERY_LOG_DEFAULT GRN_QUERY_LOG_ALL
223
254
310typedef struct _grn_obj grn_obj;
332typedef struct _grn_ctx grn_ctx;
333
334#define GRN_CTX_MSGSIZE (0x80)
335#define GRN_CTX_FIN (0xff)
336
337typedef void (*grn_close_func)(grn_ctx *ctx, void *data);
338
339typedef union {
340 int int_value;
341 grn_id id;
342 void *ptr;
343} grn_user_data;
344
345typedef grn_obj *
346grn_proc_func(grn_ctx *ctx,
347 int nargs,
348 grn_obj **args,
349 grn_user_data *user_data);
350
351struct _grn_ctx {
352 grn_rc rc;
353 int flags;
354 grn_encoding encoding;
355 unsigned char ntrace;
356 unsigned char errlvl;
357 unsigned char stat;
358 unsigned int seqno;
359 unsigned int subno;
360 unsigned int seqno2;
361 unsigned int errline;
362 grn_user_data user_data;
363 grn_ctx *prev;
364 grn_ctx *next;
365 const char *errfile;
366 const char *errfunc;
367 struct _grn_ctx_impl *impl;
368 void *trace[16];
369 char errbuf[GRN_CTX_MSGSIZE];
370};
371
372#define GRN_CTX_USER_DATA(ctx) (&((ctx)->user_data))
373
374/* Deprecated since 4.0.3. Don't use it. */
375#define GRN_CTX_USE_QL (0x03)
376/* Deprecated since 4.0.3. Don't use it. */
377#define GRN_CTX_BATCH_MODE (0x04)
378#define GRN_CTX_PER_DB (0x08)
379
388GRN_API grn_rc
389grn_ctx_init(grn_ctx *ctx, int flags);
403GRN_API grn_rc
404grn_ctx_fin(grn_ctx *ctx);
418GRN_API grn_ctx *
419grn_ctx_open(int flags);
434GRN_API grn_rc
435grn_ctx_close(grn_ctx *ctx);
444GRN_API grn_rc
445grn_ctx_set_finalizer(grn_ctx *ctx, grn_proc_func *func);
446
447GRN_API grn_rc
448grn_ctx_push_temporary_open_space(grn_ctx *ctx);
449GRN_API grn_rc
450grn_ctx_pop_temporary_open_space(grn_ctx *ctx);
451GRN_API grn_rc
452grn_ctx_merge_temporary_open_space(grn_ctx *ctx);
453
457GRN_API grn_encoding
458grn_get_default_encoding(void);
467GRN_API grn_rc
468grn_set_default_encoding(grn_encoding encoding);
469
470#define GRN_CTX_GET_ENCODING(ctx) ((ctx)->encoding)
471#define GRN_CTX_SET_ENCODING(ctx, enc) \
472 ((ctx)->encoding = \
473 (enc == GRN_ENC_DEFAULT) ? grn_get_default_encoding() : enc)
474
475GRN_API const char *
476grn_get_version(void);
477GRN_API uint32_t
478grn_get_version_major(void);
479GRN_API uint32_t
480grn_get_version_minor(void);
481GRN_API uint32_t
482grn_get_version_micro(void);
483GRN_API const char *
484grn_get_package(void);
485GRN_API const char *
486grn_get_package_label(void);
487
491GRN_API grn_command_version
492grn_get_default_command_version(void);
501GRN_API grn_rc
502grn_set_default_command_version(grn_command_version version);
508GRN_API grn_command_version
509grn_ctx_get_command_version(grn_ctx *ctx);
522GRN_API grn_rc
523grn_ctx_get_rc(grn_ctx *ctx);
537GRN_API const char *
538grn_ctx_get_error_message(grn_ctx *ctx);
548GRN_API bool
549grn_ctx_is_quitting(grn_ctx *ctx);
559GRN_API grn_rc
560grn_ctx_set_command_version(grn_ctx *ctx, grn_command_version version);
570GRN_API int64_t
571grn_ctx_get_match_escalation_threshold(grn_ctx *ctx);
584GRN_API grn_rc
585grn_ctx_set_match_escalation_threshold(grn_ctx *ctx, int64_t threshold);
586GRN_API bool
587grn_ctx_get_force_match_escalation(grn_ctx *ctx);
588GRN_API grn_rc
589grn_ctx_set_force_match_escalation(grn_ctx *ctx, bool force);
590GRN_API int32_t
591grn_ctx_get_n_workers(grn_ctx *ctx);
592GRN_API grn_rc
593grn_ctx_set_n_workers(grn_ctx *ctx, int32_t n_workers);
601GRN_API int64_t
602grn_get_default_match_escalation_threshold(void);
614GRN_API grn_rc
615grn_set_default_match_escalation_threshold(int64_t threshold);
616GRN_API int32_t
617grn_get_default_n_workers(void);
618GRN_API grn_rc
619grn_set_default_n_workers(int32_t n_workers);
620GRN_API bool
621grn_is_back_trace_enable(void);
622GRN_API grn_rc
623grn_set_back_trace_enable(bool enable);
624GRN_API bool
625grn_is_reference_count_enable(void);
626GRN_API grn_rc
627grn_set_reference_count_enable(bool enable);
628
629GRN_API grn_rc
630grn_ctx_set_variable(grn_ctx *ctx,
631 const char *name,
632 int name_size,
633 void *data,
634 grn_close_func close_func);
635GRN_API void *
636grn_ctx_get_variable(grn_ctx *ctx, const char *name, int name_size);
637GRN_API grn_rc
638grn_unset_variable(const char *name, int name_size);
639
660GRN_API int
661grn_get_lock_timeout(void);
687GRN_API grn_rc
688grn_set_lock_timeout(int timeout);
689
690GRN_API size_t
691grn_get_memory_map_size(void);
692
693/* grn_encoding */
703GRN_API const char *
704grn_encoding_to_string(grn_encoding encoding);
714GRN_API grn_encoding
715grn_encoding_parse(const char *name);
716
717/* obj */
718
719typedef uint16_t grn_obj_flags;
720typedef uint32_t grn_table_flags;
721typedef uint32_t grn_column_flags;
722
723/* flags for grn_obj_flags and grn_table_flags */
724
725#define GRN_OBJ_FLAGS_MASK (0xffff)
726
727#define GRN_OBJ_TABLE_TYPE_MASK (0x07)
728#define GRN_OBJ_TABLE_HASH_KEY (0x00)
729#define GRN_OBJ_TABLE_PAT_KEY (0x01)
730#define GRN_OBJ_TABLE_DAT_KEY (0x02)
731#define GRN_OBJ_TABLE_NO_KEY (0x03)
732
734#define GRN_OBJ_KEY_MASK (0x07 << 3)
737#define GRN_OBJ_KEY_UINT (0x00 << 3)
740#define GRN_OBJ_KEY_INT (0x01 << 3)
743#define GRN_OBJ_KEY_FLOAT (0x02 << 3)
746#define GRN_OBJ_KEY_GEO_POINT (0x03 << 3)
752#define GRN_OBJ_KEY_WITH_SIS (0x01 << 6)
758#define GRN_OBJ_KEY_NORMALIZE (0x01 << 7)
759
760/* flags for grn_obj_flags and grn_column_flags */
761
766#define GRN_OBJ_COLUMN_TYPE_MASK (0x07)
771#define GRN_OBJ_COLUMN_SCALAR (0x00)
776#define GRN_OBJ_COLUMN_VECTOR (0x01)
781#define GRN_OBJ_COLUMN_INDEX (0x02)
782
783#define GRN_OBJ_COMPRESS_MASK (0x07 << 4)
784#define GRN_OBJ_COMPRESS_NONE (0x00 << 4)
789#define GRN_OBJ_COMPRESS_ZLIB (0x01 << 4)
794#define GRN_OBJ_COMPRESS_LZ4 (0x02 << 4)
795/* Just for backward compatibility. We'll remove it at 5.0.0. */
796#define GRN_OBJ_COMPRESS_LZO GRN_OBJ_COMPRESS_LZ4
801#define GRN_OBJ_COMPRESS_ZSTD (0x03 << 4)
808#define GRN_OBJ_COMPRESS_OPENZL (0x04 << 4)
809
817#define GRN_OBJ_WITH_SECTION (0x01 << 7)
825#define GRN_OBJ_WITH_WEIGHT (0x01 << 8)
834#define GRN_OBJ_WITH_POSITION (0x01 << 9)
835#define GRN_OBJ_RING_BUFFER (0x01 << 10)
836#define GRN_OBJ_WEIGHT_BFLOAT16 (0x01 << 11)
837
838#define GRN_OBJ_UNIT_MASK (0x0f << 8)
839#define GRN_OBJ_UNIT_DOCUMENT_NONE (0x00 << 8)
840#define GRN_OBJ_UNIT_DOCUMENT_SECTION (0x01 << 8)
841#define GRN_OBJ_UNIT_DOCUMENT_POSITION (0x02 << 8)
842#define GRN_OBJ_UNIT_SECTION_NONE (0x03 << 8)
843#define GRN_OBJ_UNIT_SECTION_POSITION (0x04 << 8)
844#define GRN_OBJ_UNIT_POSITION_NONE (0x05 << 8)
845#define GRN_OBJ_UNIT_USERDEF_DOCUMENT (0x06 << 8)
846#define GRN_OBJ_UNIT_USERDEF_SECTION (0x07 << 8)
847#define GRN_OBJ_UNIT_USERDEF_POSITION (0x08 << 8)
848
849/* Don't use (0x01<<12) because it's used internally. */
850
851#define GRN_OBJ_NO_SUBREC (0x00 << 13)
852#define GRN_OBJ_WITH_SUBREC (0x01 << 13)
853
860#define GRN_OBJ_KEY_VAR_SIZE (0x01 << 14)
861
862#define GRN_OBJ_TEMPORARY (0x00 << 15)
867#define GRN_OBJ_PERSISTENT (0x01 << 15)
868
869/* flags only for grn_table_flags */
870
871#define GRN_OBJ_KEY_LARGE (0x01 << 16)
872
873/* flags only for grn_column_flags */
874
875#define GRN_OBJ_INDEX_SMALL (0x01 << 16)
876#define GRN_OBJ_INDEX_MEDIUM (0x01 << 17)
877#define GRN_OBJ_COLUMN_LARGE (0x01 << 18)
878#define GRN_OBJ_INDEX_LARGE GRN_OBJ_COLUMN_LARGE
879#define GRN_OBJ_WEIGHT_FLOAT32 (0x01 << 19)
880
881#define GRN_OBJ_MISSING_MASK (0x03 << 20)
882#define GRN_OBJ_MISSING_ADD (0x00 << 20)
883#define GRN_OBJ_MISSING_IGNORE (0x01 << 20)
884#define GRN_OBJ_MISSING_NIL (0x02 << 20)
885
886#define GRN_OBJ_INVALID_MASK (0x03 << 22)
887#define GRN_OBJ_INVALID_ERROR (0x00 << 22)
888#define GRN_OBJ_INVALID_WARN (0x01 << 22)
889#define GRN_OBJ_INVALID_IGNORE (0x02 << 22)
890
891#define GRN_OBJ_COMPRESS_FILTER_SHUFFLE (0x01 << 24)
892#define GRN_OBJ_COMPRESS_FILTER_BYTE_DELTA (0x01 << 25)
893#define GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_1BYTE (0x01 << 26)
894#define GRN_OBJ_COMPRESS_FILTER_TRUNCATE_PRECISION_2BYTES (0x01 << 27)
895
896/* flags only for grn_table_flags and grn_column_flags */
897
898/* GRN_COLUMN_INDEX only uses this for now */
899#define GRN_OBJ_VISIBLE ((uint32_t)(0x00 << 31))
900#define GRN_OBJ_INVISIBLE ((uint32_t)(0x01 << 31))
901
902/* obj types */
903
904#define GRN_VOID (0x00)
909#define GRN_BULK (0x02)
914#define GRN_PTR (0x03)
915/* vector of fixed size (uniform) data especially grn_id */
916#define GRN_UVECTOR (0x04)
917#define GRN_PVECTOR (0x05) /* vector of grn_obj* */
918#define GRN_VECTOR (0x06) /* vector of arbitrary data */
919#define GRN_MSG (0x07)
920#define GRN_QUERY (0x08)
921#define GRN_ACCESSOR (0x09)
922#define GRN_SNIP (0x0b)
923#define GRN_PATSNIP (0x0c)
924#define GRN_STRING (0x0d)
925#define GRN_HIGHLIGHTER (0x0e)
926#define GRN_CURSOR_TABLE_HASH_KEY (0x10)
927#define GRN_CURSOR_TABLE_PAT_KEY (0x11)
928#define GRN_CURSOR_TABLE_DAT_KEY (0x12)
929#define GRN_CURSOR_TABLE_NO_KEY (0x13)
930#define GRN_CURSOR_COLUMN_INDEX (0x18)
931#define GRN_CURSOR_COLUMN_GEO_INDEX (0x1a)
932#define GRN_CURSOR_CONFIG (0x1f)
933#define GRN_TYPE (0x20)
934#define GRN_PROC (0x21)
935#define GRN_EXPR (0x22)
936#define GRN_TABLE_HASH_KEY (0x30)
937#define GRN_TABLE_PAT_KEY (0x31)
938#define GRN_TABLE_DAT_KEY (0x32)
939#define GRN_TABLE_NO_KEY (0x33)
940#define GRN_DB (0x37)
941#define GRN_COLUMN_FIX_SIZE (0x40)
942#define GRN_COLUMN_VAR_SIZE (0x41)
943#define GRN_COLUMN_INDEX (0x48)
944#define GRN_HTTP_CLIENT (0x50)
945
946typedef struct _grn_section {
947 uint32_t offset;
948 uint32_t length;
949 float weight;
950 grn_id domain;
951} grn_section;
952
959
960struct _grn_obj {
961 grn_obj_header header;
962 union {
963 struct {
964 char *head;
965 char *curr;
966 char *tail;
967 } b;
968 struct {
969 grn_obj *body;
970 grn_section *sections;
971 uint32_t n_sections;
972 } v;
973 } u;
974};
975
976#define GRN_OBJ_REFER (0x01 << 0)
977#define GRN_OBJ_OUTPLACE (0x01 << 1)
986#define GRN_OBJ_OWN (0x01 << 5)
987
988#define GRN_OBJ_INIT(obj, obj_type, obj_flags, obj_domain) \
989 do { \
990 (obj)->header.type = (obj_type); \
991 (obj)->header.impl_flags = (obj_flags); \
992 (obj)->header.flags = 0; \
993 (obj)->header.domain = (obj_domain); \
994 (obj)->u.b.head = NULL; \
995 (obj)->u.b.curr = NULL; \
996 (obj)->u.b.tail = NULL; \
997 } while (0)
998
999#define GRN_OBJ_FIN(ctx, obj) (grn_obj_close((ctx), (obj)))
1000
1013GRN_API grn_rc
1014grn_ctx_use(grn_ctx *ctx, grn_obj *db);
1022GRN_API grn_obj *
1023grn_ctx_db(grn_ctx *ctx);
1035GRN_API grn_obj *
1036grn_ctx_get(grn_ctx *ctx, const char *name, int name_size);
1093GRN_API grn_rc
1094grn_ctx_get_all_tables(grn_ctx *ctx, grn_obj *tables_buffer);
1095GRN_API grn_rc
1096grn_ctx_get_all_types(grn_ctx *ctx, grn_obj *types_buffer);
1097GRN_API grn_rc
1098grn_ctx_get_all_tokenizers(grn_ctx *ctx, grn_obj *tokenizers_buffer);
1099GRN_API grn_rc
1100grn_ctx_get_all_normalizers(grn_ctx *ctx, grn_obj *normalizers_buffer);
1101GRN_API grn_rc
1102grn_ctx_get_all_token_filters(grn_ctx *ctx, grn_obj *token_filters_buffer);
1103
1131
1139
1150GRN_API grn_obj *
1151grn_ctx_at(grn_ctx *ctx, grn_id id);
1152/*
1153 * \brief Check whether object with the ID is opened or not.
1154 *
1155 * \param ctx The context object.
1156 * \param id The object ID to be checked.
1157 *
1158 * \return `true` if object with the ID is opened, `false` otherwise.
1159 */
1160GRN_API bool
1161grn_ctx_is_opened(grn_ctx *ctx, grn_id id);
1162
1163GRN_API grn_rc
1164grn_plugin_register(grn_ctx *ctx, const char *name);
1165GRN_API grn_rc
1166grn_plugin_unregister(grn_ctx *ctx, const char *name);
1167GRN_API grn_rc
1168grn_plugin_register_by_path(grn_ctx *ctx, const char *path);
1169GRN_API grn_rc
1170grn_plugin_unregister_by_path(grn_ctx *ctx, const char *path);
1171GRN_API const char *
1172grn_plugin_get_system_plugins_dir(void);
1173GRN_API const char *
1174grn_plugin_get_suffix(void);
1175GRN_API const char *
1176grn_plugin_get_ruby_suffix(void);
1177GRN_API grn_rc
1178grn_plugin_get_names(grn_ctx *ctx, grn_obj *names);
1179
1180typedef struct {
1181 const char *name;
1182 unsigned int name_size;
1183 grn_obj value;
1184} grn_expr_var;
1185
1186typedef grn_rc (*grn_plugin_func)(grn_ctx *ctx);
1187
1188typedef grn_obj grn_table_cursor;
1189
1190typedef enum {
1191 GRN_OP_PUSH = 0,
1192 GRN_OP_POP,
1193 GRN_OP_NOP,
1194 GRN_OP_CALL,
1195 GRN_OP_INTERN,
1196 GRN_OP_GET_REF,
1197 GRN_OP_GET_VALUE,
1198 GRN_OP_AND,
1199 GRN_OP_AND_NOT,
1200 /* Deprecated. Just for backward compatibility. */
1201#define GRN_OP_BUT GRN_OP_AND_NOT
1202 GRN_OP_OR,
1203 GRN_OP_ASSIGN,
1204 GRN_OP_STAR_ASSIGN,
1205 GRN_OP_SLASH_ASSIGN,
1206 GRN_OP_MOD_ASSIGN,
1207 GRN_OP_PLUS_ASSIGN,
1208 GRN_OP_MINUS_ASSIGN,
1209 GRN_OP_SHIFTL_ASSIGN,
1210 GRN_OP_SHIFTR_ASSIGN,
1211 GRN_OP_SHIFTRR_ASSIGN,
1212 GRN_OP_AND_ASSIGN,
1213 GRN_OP_XOR_ASSIGN,
1214 GRN_OP_OR_ASSIGN,
1215 GRN_OP_JUMP,
1216 GRN_OP_CJUMP,
1217 GRN_OP_COMMA,
1218 GRN_OP_BITWISE_OR,
1219 GRN_OP_BITWISE_XOR,
1220 GRN_OP_BITWISE_AND,
1221 GRN_OP_BITWISE_NOT,
1222 GRN_OP_EQUAL,
1223 GRN_OP_NOT_EQUAL,
1224 GRN_OP_LESS,
1225 GRN_OP_GREATER,
1226 GRN_OP_LESS_EQUAL,
1227 GRN_OP_GREATER_EQUAL,
1228 GRN_OP_IN,
1229 GRN_OP_MATCH,
1230 GRN_OP_NEAR,
1231 GRN_OP_NEAR_NO_OFFSET,
1232 /* Deprecated. Just for backward compatibility. */
1233#define GRN_OP_NEAR2 GRN_OP_NEAR_NO_OFFSET
1234 GRN_OP_SIMILAR,
1235 GRN_OP_TERM_EXTRACT,
1236 GRN_OP_SHIFTL,
1237 GRN_OP_SHIFTR,
1238 GRN_OP_SHIFTRR,
1239 GRN_OP_PLUS,
1240 GRN_OP_MINUS,
1241 GRN_OP_STAR,
1242 GRN_OP_SLASH,
1243 GRN_OP_MOD,
1244 GRN_OP_DELETE,
1245 GRN_OP_INCR,
1246 GRN_OP_DECR,
1247 GRN_OP_INCR_POST,
1248 GRN_OP_DECR_POST,
1249 GRN_OP_NOT,
1250 GRN_OP_ADJUST,
1251 GRN_OP_EXACT,
1252 GRN_OP_LCP,
1253 GRN_OP_PARTIAL,
1254 GRN_OP_UNSPLIT,
1255 GRN_OP_PREFIX,
1256 GRN_OP_SUFFIX,
1257 GRN_OP_GEO_DISTANCE1,
1258 GRN_OP_GEO_DISTANCE2,
1259 GRN_OP_GEO_DISTANCE3,
1260 GRN_OP_GEO_DISTANCE4,
1261 GRN_OP_GEO_WITHINP5,
1262 GRN_OP_GEO_WITHINP6,
1263 GRN_OP_GEO_WITHINP8,
1264 GRN_OP_OBJ_SEARCH,
1265 GRN_OP_EXPR_GET_VAR,
1266 GRN_OP_TABLE_CREATE,
1267 GRN_OP_TABLE_SELECT,
1268 GRN_OP_TABLE_SORT,
1269 GRN_OP_TABLE_GROUP,
1270 GRN_OP_JSON_PUT,
1271 GRN_OP_GET_MEMBER,
1272 GRN_OP_REGEXP,
1273 GRN_OP_FUZZY,
1274 GRN_OP_QUORUM,
1275 GRN_OP_NEAR_PHRASE,
1276 GRN_OP_ORDERED_NEAR_PHRASE,
1277 GRN_OP_NEAR_PHRASE_PRODUCT,
1278 GRN_OP_ORDERED_NEAR_PHRASE_PRODUCT,
1279} grn_operator;
1280
1325GRN_API grn_obj *
1326grn_obj_column(grn_ctx *ctx,
1327 grn_obj *table,
1328 const char *name,
1329 uint32_t name_size);
1330
1331/*-------------------------------------------------------------
1332 * API for db, table and/or column
1333 */
1334
1381
1393GRN_API grn_obj *
1394grn_obj_get_info(grn_ctx *ctx,
1395 grn_obj *obj,
1396 grn_info_type type,
1397 grn_obj *valuebuf);
1410GRN_API grn_rc
1411grn_obj_set_info(grn_ctx *ctx,
1412 grn_obj *obj,
1413 grn_info_type type,
1414 grn_obj *value);
1429GRN_API grn_obj *
1430grn_obj_get_element_info(
1431 grn_ctx *ctx, grn_obj *obj, grn_id id, grn_info_type type, grn_obj *valuebuf);
1445GRN_API grn_rc
1446grn_obj_set_element_info(
1447 grn_ctx *ctx, grn_obj *obj, grn_id id, grn_info_type type, grn_obj *value);
1448
1461GRN_API grn_obj *
1462grn_obj_get_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value);
1489GRN_API int
1490grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void **values);
1491
1492#define GRN_COLUMN_EACH(ctx, column, id, value, block) \
1493 do { \
1494 int _n; \
1495 grn_id id = 1; \
1496 while ((_n = grn_obj_get_values(ctx, column, id, (void **)&value)) > 0) { \
1497 for (; _n; _n--, id++, value++) { \
1498 block \
1499 } \
1500 } \
1501 } while (0)
1502
1503#define GRN_OBJ_SET_MASK (0x07)
1507#define GRN_OBJ_SET (0x01)
1511#define GRN_OBJ_INCR (0x02)
1515#define GRN_OBJ_DECR (0x03)
1519#define GRN_OBJ_APPEND (0x04)
1523#define GRN_OBJ_PREPEND (0x05)
1524#define GRN_OBJ_GET (0x01 << 4)
1525#define GRN_OBJ_COMPARE (0x01 << 5)
1526#define GRN_OBJ_LOCK (0x01 << 6)
1527#define GRN_OBJ_UNLOCK (0x01 << 7)
1528
1553GRN_API grn_rc
1554grn_obj_set_value(
1555 grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value, int flags);
1556
1557#define GRN_OBJ_REMOVE_DEPENDENT (0x01 << 0)
1558#define GRN_OBJ_REMOVE_ENSURE (0x01 << 1)
1559
1572GRN_API grn_rc
1573grn_obj_remove(grn_ctx *ctx, grn_obj *obj);
1574GRN_API grn_rc
1575grn_obj_remove_dependent(grn_ctx *ctx, grn_obj *obj);
1576GRN_API grn_rc
1577grn_obj_remove_flags(grn_ctx *ctx, grn_obj *obj, uint32_t flags);
1578/* Deprecated since 14.0.5. Use grn_ctx_remove(...,
1579 * GRN_OBJ_REMOVE_ENSURE) instead. */
1580GRN_API grn_rc
1581grn_obj_remove_force(grn_ctx *ctx, const char *name, int name_size);
1582GRN_API grn_rc
1583grn_ctx_remove(grn_ctx *ctx, const char *name, int name_size, uint32_t flags);
1584GRN_API grn_rc
1585grn_ctx_remove_by_id(grn_ctx *ctx, grn_id id, uint32_t flags);
1586
1600GRN_API grn_rc
1601grn_obj_rename(grn_ctx *ctx,
1602 grn_obj *obj,
1603 const char *name,
1604 unsigned int name_size);
1605
1620GRN_API grn_rc
1621grn_column_rename(grn_ctx *ctx,
1622 grn_obj *column,
1623 const char *name,
1624 unsigned int name_size);
1625
1650GRN_API grn_rc
1651grn_obj_close(grn_ctx *ctx, grn_obj *obj);
1677GRN_API grn_rc
1678grn_obj_reinit(grn_ctx *ctx, grn_obj *obj, grn_id domain, uint8_t flags);
1728GRN_API grn_rc
1729grn_obj_unlink(grn_ctx *ctx, grn_obj *obj);
1730GRN_API grn_rc
1731grn_obj_refer(grn_ctx *ctx, grn_obj *obj);
1732GRN_API grn_rc
1733grn_obj_refer_recursive(grn_ctx *ctx, grn_obj *obj);
1734GRN_API grn_rc
1735grn_obj_refer_recursive_dependent(grn_ctx *ctx, grn_obj *obj);
1736/* This calls grn_obj_unlink() only on reference count mode
1737 * (GRN_ENABLE_REFERENCE_COUNT=yes) */
1738GRN_API void
1739grn_obj_unref(grn_ctx *ctx, grn_obj *obj);
1740GRN_API void
1741grn_obj_unref_recursive(grn_ctx *ctx, grn_obj *obj);
1742GRN_API void
1743grn_obj_unref_recursive_dependent(grn_ctx *ctx, grn_obj *obj);
1744
1752GRN_API grn_user_data *
1753grn_obj_user_data(grn_ctx *ctx, grn_obj *obj);
1754
1766GRN_API grn_rc
1767grn_obj_set_finalizer(grn_ctx *ctx, grn_obj *obj, grn_proc_func *func);
1776GRN_API const char *
1777grn_obj_path(grn_ctx *ctx, grn_obj *obj);
1798GRN_API int
1799grn_obj_name(grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size);
1800
1825GRN_API int
1826grn_column_name(grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size);
1827
1841GRN_API grn_id
1842grn_obj_get_range(grn_ctx *ctx, grn_obj *obj);
1843
1844#define GRN_OBJ_GET_DOMAIN(obj) \
1845 ((obj)->header.type == GRN_TABLE_NO_KEY ? GRN_ID_NIL : (obj)->header.domain)
1846
1861GRN_API int
1862grn_obj_expire(grn_ctx *ctx, grn_obj *obj, int threshold);
1873GRN_API int
1874grn_obj_check(grn_ctx *ctx, grn_obj *obj);
1891GRN_API grn_rc
1892grn_obj_lock(grn_ctx *ctx, grn_obj *obj, grn_id id, int timeout);
1914GRN_API grn_rc
1915grn_obj_unlock(grn_ctx *ctx, grn_obj *obj, grn_id id);
1934GRN_API grn_rc
1935grn_obj_clear_lock(grn_ctx *ctx, grn_obj *obj);
1945GRN_API unsigned int
1946grn_obj_is_locked(grn_ctx *ctx, grn_obj *obj);
1947GRN_API grn_rc
1948grn_obj_flush(grn_ctx *ctx, grn_obj *obj);
1949GRN_API grn_rc
1950grn_obj_flush_recursive(grn_ctx *ctx, grn_obj *obj);
1951GRN_API grn_rc
1952grn_obj_flush_recursive_dependent(grn_ctx *ctx, grn_obj *obj);
1953GRN_API grn_rc
1954grn_obj_flush_only_opened(grn_ctx *ctx, grn_obj *obj);
1971GRN_API uint64_t
1972grn_obj_defrag(grn_ctx *ctx, grn_obj *obj, int threshold);
1973
1983GRN_API grn_obj *
1984grn_obj_db(grn_ctx *ctx, grn_obj *obj);
1985
1995GRN_API grn_id
1996grn_obj_id(grn_ctx *ctx, grn_obj *obj);
1997
1998/* Flags for grn_fuzzy_search_optarg::flags. */
1999#define GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION (0x01 << 0)
2000#define GRN_TABLE_FUZZY_SEARCH_USE_PREFIX_LENGTH (0x01 << 1)
2001#define GRN_TABLE_FUZZY_SEARCH_USE_MAX_DISTANCE_RATIO (0x01 << 2)
2002/* We want to use GRN_TABLE_FUZZY_SEARCH_TOKENIZE but it breaks
2003 * backward compatibility. So we use this inverted name. */
2004#define GRN_TABLE_FUZZY_SEARCH_SKIP_TOKENIZE (0x01 << 3)
2005
2006typedef struct _grn_fuzzy_search_optarg grn_fuzzy_search_optarg;
2007
2008struct _grn_fuzzy_search_optarg {
2009 uint32_t max_distance;
2010 /* We want to name this max_expansions but can't change it to keep
2011 * backward compatibility. */
2012 uint32_t max_expansion;
2013 /* Unit is byte. */
2014 uint32_t prefix_match_size;
2015 uint32_t flags;
2016 /* Unit is character. This is used only when
2017 * GRN_TABLE_FUZZY_SEARCH_USE_PREFIX_LENGTH flag is set. */
2018 uint32_t prefix_length;
2019 /* This is used only when
2020 * GRN_TABLE_FUZZY_SEARCH_USE_MAX_DISTANCE_RATIO flag is set. */
2021 float max_distance_ratio;
2022};
2023
2024#define GRN_MATCH_INFO_GET_MIN_RECORD_ID (0x01)
2025#define GRN_MATCH_INFO_ONLY_SKIP_TOKEN (0x02)
2026
2027typedef struct _grn_match_info grn_match_info;
2028
2033
2034typedef struct _grn_search_optarg grn_search_optarg;
2035
2059
2082GRN_API grn_rc
2083grn_obj_search(grn_ctx *ctx,
2084 grn_obj *obj,
2085 grn_obj *query,
2086 grn_obj *res,
2087 grn_operator op,
2088 grn_search_optarg *optarg);
2089
2090GRN_API grn_rc
2091grn_proc_set_is_stable(grn_ctx *ctx, grn_obj *proc, bool is_stable);
2092GRN_API bool
2093grn_proc_is_stable(grn_ctx *ctx, grn_obj *proc);
2094
2095/*-------------------------------------------------------------
2096 * API for hook
2097 */
2098
2099GRN_API int
2100grn_proc_call_next(grn_ctx *ctx, grn_obj *exec_info, grn_obj *in, grn_obj *out);
2101GRN_API void *
2102grn_proc_get_ctx_local_data(grn_ctx *ctx, grn_obj *exec_info);
2103GRN_API void *
2104grn_proc_get_hook_local_data(grn_ctx *ctx, grn_obj *exec_info);
2105
2119
2120#define GRN_N_HOOK_ENTRIES 5 /* (GRN_HOOK_SELECT + 1) */
2121
2122GRN_API const char *
2123grn_hook_entry_to_string(grn_hook_entry entry);
2124
2139GRN_API grn_rc
2140grn_obj_add_hook(grn_ctx *ctx,
2141 grn_obj *obj,
2142 grn_hook_entry entry,
2143 int offset,
2144 grn_obj *proc,
2145 grn_obj *data);
2155GRN_API int
2156grn_obj_get_nhooks(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry);
2169GRN_API grn_obj *
2170grn_obj_get_hook(
2171 grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry, int offset, grn_obj *data);
2184GRN_API grn_rc
2185grn_obj_delete_hook(grn_ctx *ctx,
2186 grn_obj *obj,
2187 grn_hook_entry entry,
2188 int offset);
2189
2190GRN_API grn_obj *
2191grn_obj_open(grn_ctx *ctx,
2192 unsigned char type,
2193 grn_obj_flags flags,
2194 grn_id domain);
2195
2199GRN_API int
2200grn_column_index(grn_ctx *ctx,
2201 grn_obj *column,
2202 grn_operator op,
2203 grn_obj **indexbuf,
2204 int buf_size,
2205 int *section);
2206
2207/* @since 5.0.1. */
2212
2236GRN_API unsigned int
2237grn_column_find_index_data(grn_ctx *ctx,
2238 grn_obj *column,
2239 grn_operator op,
2240 grn_index_datum *index_data,
2241 unsigned int n_index_data);
2242/* @since 5.1.2. */
2243GRN_API uint32_t
2244grn_column_get_all_index_data(grn_ctx *ctx,
2245 grn_obj *column,
2246 grn_index_datum *index_data,
2247 uint32_t n_index_data);
2248/* @since 9.1.2. */
2249GRN_API grn_rc
2250grn_column_get_all_index_columns(grn_ctx *ctx,
2251 grn_obj *column,
2252 grn_obj *index_columns);
2253
2277GRN_API grn_rc
2278grn_obj_delete_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, bool remove_p);
2292GRN_API grn_rc
2293grn_obj_path_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, char *buffer);
2294
2295/* query & snippet */
2296
2297#ifndef GRN_QUERY_AND
2298# define GRN_QUERY_AND '+'
2299#endif /* GRN_QUERY_AND */
2300#ifndef GRN_QUERY_AND_NOT
2301# ifdef GRN_QUERY_BUT
2302/* Deprecated. Just for backward compatibility. */
2303# define GRN_QUERY_AND_NOT GRN_QUERY_BUT
2304# else
2305# define GRN_QUERY_AND_NOT '-'
2306# endif /* GRN_QUERY_BUT */
2307#endif /* GRN_QUERY_AND_NOT */
2308#ifndef GRN_QUERY_ADJ_INC
2309# define GRN_QUERY_ADJ_INC '>'
2310#endif /* GRN_QUERY_ADJ_POS2 */
2311#ifndef GRN_QUERY_ADJ_DEC
2312# define GRN_QUERY_ADJ_DEC '<'
2313#endif /* GRN_QUERY_ADJ_POS1 */
2314#ifndef GRN_QUERY_ADJ_NEG
2315# define GRN_QUERY_ADJ_NEG '~'
2316#endif /* GRN_QUERY_ADJ_NEG */
2317#ifndef GRN_QUERY_PREFIX
2318# define GRN_QUERY_PREFIX '*'
2319#endif /* GRN_QUERY_PREFIX */
2320#ifndef GRN_QUERY_PARENL
2321# define GRN_QUERY_PARENL '('
2322#endif /* GRN_QUERY_PARENL */
2323#ifndef GRN_QUERY_PARENR
2324# define GRN_QUERY_PARENR ')'
2325#endif /* GRN_QUERY_PARENR */
2326#ifndef GRN_QUERY_QUOTEL
2327# define GRN_QUERY_QUOTEL '"'
2328#endif /* GRN_QUERY_QUOTEL */
2329#ifndef GRN_QUERY_QUOTER
2330# define GRN_QUERY_QUOTER '"'
2331#endif /* GRN_QUERY_QUOTER */
2332#ifndef GRN_QUERY_ESCAPE
2333# define GRN_QUERY_ESCAPE '\\'
2334#endif /* GRN_QUERY_ESCAPE */
2335#ifndef GRN_QUERY_COLUMN
2336# define GRN_QUERY_COLUMN ':'
2337#endif /* GRN_QUERY_COLUMN */
2338
2339typedef struct _grn_snip_mapping grn_snip_mapping;
2340
2341struct _grn_snip_mapping {
2342 void *dummy;
2343};
2344
2345#define GRN_SNIP_NORMALIZE (0x01 << 0)
2346#define GRN_SNIP_COPY_TAG (0x01 << 1)
2347#define GRN_SNIP_SKIP_LEADING_SPACES (0x01 << 2)
2348
2349#define GRN_SNIP_MAPPING_HTML_ESCAPE ((grn_snip_mapping *)-1)
2350
2351GRN_API grn_obj *
2352grn_snip_open(grn_ctx *ctx,
2353 int flags,
2354 unsigned int width,
2355 unsigned int max_results,
2356 const char *defaultopentag,
2357 unsigned int defaultopentag_len,
2358 const char *defaultclosetag,
2359 unsigned int defaultclosetag_len,
2360 grn_snip_mapping *mapping);
2361GRN_API grn_rc
2362grn_snip_add_cond(grn_ctx *ctx,
2363 grn_obj *snip,
2364 const char *keyword,
2365 unsigned int keyword_len,
2366 const char *opentag,
2367 unsigned int opentag_len,
2368 const char *closetag,
2369 unsigned int closetag_len);
2370GRN_API grn_rc
2371grn_snip_set_normalizer(grn_ctx *ctx, grn_obj *snip, grn_obj *normalizer);
2372GRN_API grn_obj *
2373grn_snip_get_normalizer(grn_ctx *ctx, grn_obj *snip);
2374GRN_API grn_rc
2375grn_snip_set_normalizers(grn_ctx *ctx, grn_obj *snip, grn_obj *normalizers);
2376GRN_API grn_obj *
2377grn_snip_get_normalizers(grn_ctx *ctx, grn_obj *snip);
2378GRN_API grn_rc
2379grn_snip_set_delimiter_regexp(grn_ctx *ctx,
2380 grn_obj *snip,
2381 const char *pattern,
2382 int pattern_length);
2383GRN_API const char *
2384grn_snip_get_delimiter_regexp(grn_ctx *ctx,
2385 grn_obj *snip,
2386 size_t *pattern_length);
2387GRN_API grn_rc
2388grn_snip_exec(grn_ctx *ctx,
2389 grn_obj *snip,
2390 const char *string,
2391 unsigned int string_len,
2392 unsigned int *nresults,
2393 unsigned int *max_tagged_len);
2394GRN_API grn_rc
2395grn_snip_get_result(grn_ctx *ctx,
2396 grn_obj *snip,
2397 const unsigned int index,
2398 char *result,
2399 unsigned int *result_len);
2400
2401/* log */
2402
2403#define GRN_LOG_NONE (0x00 << 0)
2404#define GRN_LOG_TIME (0x01 << 0)
2405#define GRN_LOG_TITLE (0x01 << 1)
2406#define GRN_LOG_MESSAGE (0x01 << 2)
2407#define GRN_LOG_LOCATION (0x01 << 3)
2408#define GRN_LOG_PID (0x01 << 4)
2409#define GRN_LOG_PROCESS_ID GRN_LOG_PID
2410#define GRN_LOG_THREAD_ID (0x01 << 5)
2411#define GRN_LOG_CONTEXT_ID (0x01 << 6)
2412/* It's an alias of GRN_LOG_CONTEXT_ID because we have grn_ctx. */
2413#define GRN_LOG_CTX_ID GRN_LOG_CONTEXT_ID
2414#define GRN_LOG_ALL \
2415 (GRN_LOG_TIME | GRN_LOG_TITLE | GRN_LOG_MESSAGE | GRN_LOG_LOCATION | \
2416 GRN_LOG_PROCESS_ID | GRN_LOG_THREAD_ID | GRN_LOG_CONTEXT_ID)
2417#define GRN_LOG_DEFAULT (GRN_LOG_TIME | GRN_LOG_MESSAGE)
2418
2419/* Deprecated since 2.1.2. Use grn_logger instead. */
2420typedef struct _grn_logger_info grn_logger_info;
2421
2422/* Deprecated since 2.1.2. Use grn_logger instead. */
2423struct _grn_logger_info {
2424 grn_log_level max_level;
2425 int flags;
2426 void (*func)(
2427 int, const char *, const char *, const char *, const char *, void *);
2428 void *func_arg;
2429};
2430
2431/* Deprecated since 2.1.2. Use grn_logger_set() instead. */
2432GRN_API grn_rc
2433grn_logger_info_set(grn_ctx *ctx, const grn_logger_info *info);
2434
2435typedef struct _grn_logger grn_logger;
2436
2437struct _grn_logger {
2438 grn_log_level max_level;
2439 int flags;
2440 void *user_data;
2441 void (*log)(grn_ctx *ctx,
2442 grn_log_level level,
2443 const char *timestamp,
2444 const char *title,
2445 const char *message,
2446 const char *location,
2447 void *user_data);
2448 void (*reopen)(grn_ctx *ctx, void *user_data);
2449 void (*fin)(grn_ctx *ctx, void *user_data);
2450};
2451
2452GRN_API bool
2453grn_log_flags_parse(const char *string, int string_size, int *flags);
2454
2455GRN_API grn_rc
2456grn_logger_set(grn_ctx *ctx, const grn_logger *logger);
2457
2458GRN_API void
2459grn_logger_set_max_level(grn_ctx *ctx, grn_log_level max_level);
2460GRN_API grn_log_level
2461grn_logger_get_max_level(grn_ctx *ctx);
2462
2463#ifdef __GNUC__
2464# define GRN_ATTRIBUTE_PRINTF(fmt_pos) \
2465 __attribute__((format(printf, fmt_pos, fmt_pos + 1)))
2466#else
2467# define GRN_ATTRIBUTE_PRINTF(fmt_pos)
2468#endif /* __GNUC__ */
2469
2470#if defined(__clang__)
2471# if __has_attribute(__alloc_size__)
2472# define HAVE_ALLOC_SIZE_ATTRIBUTE
2473# endif /* __has_attribute(__alloc_size__) */
2474#elif defined(__GNUC__) && \
2475 ((__GNUC__ >= 5) || (__GNUC__ > 4 && __GNUC_MINOR__ >= 3))
2476# define HAVE_ALLOC_SIZE_ATTRIBUTE
2477#endif /* __clang__ */
2478
2479#ifdef HAVE_ALLOC_SIZE_ATTRIBUTE
2480# define GRN_ATTRIBUTE_ALLOC_SIZE(size) __attribute__((alloc_size(size)))
2481# define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size) \
2482 __attribute__((alloc_size(n, size)))
2483#else
2484# define GRN_ATTRIBUTE_ALLOC_SIZE(size)
2485# define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size)
2486#endif /* HAVE_ALLOC_SIZE_ATTRIBUTE */
2487
2488GRN_API void
2489grn_logger_put(grn_ctx *ctx,
2490 grn_log_level level,
2491 const char *file,
2492 int line,
2493 const char *func,
2494 const char *fmt,
2495 ...) GRN_ATTRIBUTE_PRINTF(6);
2496GRN_API void
2497grn_logger_putv(grn_ctx *ctx,
2498 grn_log_level level,
2499 const char *file,
2500 int line,
2501 const char *func,
2502 const char *fmt,
2503 va_list ap);
2504GRN_API void
2505grn_logger_reopen(grn_ctx *ctx);
2506
2507GRN_API bool
2508grn_logger_pass(grn_ctx *ctx, grn_log_level level);
2509
2510GRN_API bool
2511grn_logger_is_default_logger(grn_ctx *ctx);
2512
2513#ifndef GRN_LOG_DEFAULT_LEVEL
2514# define GRN_LOG_DEFAULT_LEVEL GRN_LOG_NOTICE
2515#endif /* GRN_LOG_DEFAULT_LEVEL */
2516
2517GRN_API void
2518grn_default_logger_set_max_level(grn_log_level level);
2519GRN_API grn_log_level
2520grn_default_logger_get_max_level(void);
2521GRN_API void
2522grn_default_logger_set_flags(int flags);
2523GRN_API int
2524grn_default_logger_get_flags(void);
2525GRN_API void
2526grn_default_logger_set_path(const char *path);
2527GRN_API const char *
2528grn_default_logger_get_path(void);
2529GRN_API void
2530grn_default_logger_set_rotate_threshold_size(off_t threshold);
2531GRN_API off_t
2532grn_default_logger_get_rotate_threshold_size(void);
2533
2534#define GRN_LOG(ctx, level, ...) \
2535 do { \
2536 if (grn_logger_pass(ctx, level)) { \
2537 grn_logger_put(ctx, \
2538 (level), \
2539 __FILE__, \
2540 __LINE__, \
2541 __FUNCTION__, \
2542 __VA_ARGS__); \
2543 } \
2544 } while (0)
2545
2546GRN_API grn_rc
2547grn_slow_log_push(grn_ctx *ctx);
2548GRN_API double
2549grn_slow_log_pop(grn_ctx *ctx);
2550GRN_API bool
2551grn_slow_log_is_slow(grn_ctx *ctx, double elapsed_time);
2552
2553#define GRN_SLOW_LOG_PUSH(ctx, level) \
2554 do { \
2555 if (grn_logger_pass(ctx, level)) { \
2556 grn_slow_log_push(ctx); \
2557 } \
2558 } while (false)
2559
2560#define GRN_SLOW_LOG_POP_BEGIN(ctx, level, elapsed_time) \
2561 do { \
2562 if (grn_logger_pass(ctx, level)) { \
2563 double elapsed_time = grn_slow_log_pop(ctx); \
2564 if (grn_slow_log_is_slow(ctx, elapsed_time)) {
2565
2566#define GRN_SLOW_LOG_POP_END(ctx) \
2567 } \
2568 } \
2569 } \
2570 while (false)
2571
2572typedef struct _grn_query_logger grn_query_logger;
2573
2574struct _grn_query_logger {
2575 unsigned int flags;
2576 void *user_data;
2577 void (*log)(grn_ctx *ctx,
2578 unsigned int flag,
2579 const char *timestamp,
2580 const char *info,
2581 const char *message,
2582 void *user_data);
2583 void (*reopen)(grn_ctx *ctx, void *user_data);
2584 void (*fin)(grn_ctx *ctx, void *user_data);
2585};
2586
2587GRN_API bool
2588grn_query_log_flags_parse(const char *string,
2589 int string_size,
2590 unsigned int *flags);
2591
2592GRN_API grn_rc
2593grn_query_logger_set(grn_ctx *ctx, const grn_query_logger *logger);
2594GRN_API void
2595grn_query_logger_set_flags(grn_ctx *ctx, unsigned int flags);
2596GRN_API void
2597grn_query_logger_add_flags(grn_ctx *ctx, unsigned int flags);
2598GRN_API void
2599grn_query_logger_remove_flags(grn_ctx *ctx, unsigned int flags);
2600GRN_API unsigned int
2601grn_query_logger_get_flags(grn_ctx *ctx);
2602
2603GRN_API void
2604grn_query_logger_put(
2605 grn_ctx *ctx, unsigned int flag, const char *mark, const char *format, ...)
2606 GRN_ATTRIBUTE_PRINTF(4);
2607GRN_API void
2608grn_query_logger_reopen(grn_ctx *ctx);
2609
2610GRN_API bool
2611grn_query_logger_pass(grn_ctx *ctx, unsigned int flag);
2612
2613GRN_API void
2614grn_default_query_logger_set_flags(unsigned int flags);
2615GRN_API unsigned int
2616grn_default_query_logger_get_flags(void);
2617GRN_API void
2618grn_default_query_logger_set_path(const char *path);
2619GRN_API const char *
2620grn_default_query_logger_get_path(void);
2621GRN_API void
2622grn_default_query_logger_set_rotate_threshold_size(off_t threshold);
2623GRN_API off_t
2624grn_default_query_logger_get_rotate_threshold_size(void);
2625
2626#define GRN_QUERY_LOG(ctx, flag, mark, format, ...) \
2627 do { \
2628 if (grn_query_logger_pass(ctx, flag)) { \
2629 grn_query_logger_put(ctx, (flag), (mark), format, __VA_ARGS__); \
2630 } \
2631 } while (0)
2632
2633/* grn_bulk */
2634
2635#define GRN_BULK_BUFSIZE (sizeof(grn_obj) - sizeof(grn_obj_header))
2636/* This assumes that GRN_BULK_BUFSIZE is less than 32 (= 0x20). */
2637#define GRN_BULK_BUFSIZE_MAX 0x1f
2638#define GRN_BULK_SIZE_IN_FLAGS(flags) (size_t)((flags) & GRN_BULK_BUFSIZE_MAX)
2639#define GRN_BULK_OUTP(bulk) ((bulk)->header.impl_flags & GRN_OBJ_OUTPLACE)
2640#define GRN_BULK_REWIND(bulk) \
2641 do { \
2642 if ((bulk)->header.type == GRN_VECTOR) { \
2643 grn_obj *_body = (bulk)->u.v.body; \
2644 if (_body) { \
2645 if (GRN_BULK_OUTP(_body)) { \
2646 (_body)->u.b.curr = (_body)->u.b.head; \
2647 } else { \
2648 (_body)->header.flags &= (grn_obj_flags)(~GRN_BULK_BUFSIZE_MAX); \
2649 } \
2650 } \
2651 (bulk)->u.v.n_sections = 0; \
2652 } else { \
2653 if (GRN_BULK_OUTP(bulk)) { \
2654 (bulk)->u.b.curr = (bulk)->u.b.head; \
2655 } else { \
2656 (bulk)->header.flags &= (grn_obj_flags)(~GRN_BULK_BUFSIZE_MAX); \
2657 } \
2658 } \
2659 } while (0)
2660#define GRN_BULK_SET_CURR(buf, p) \
2661 do { \
2662 if (GRN_BULK_OUTP(buf)) { \
2663 (buf)->u.b.curr = (char *)(p); \
2664 } else { \
2665 (buf)->header.flags = (grn_obj_flags)((char *)(p) - GRN_BULK_HEAD(buf)); \
2666 } \
2667 } while (0)
2668#define GRN_BULK_INCR_LEN(bulk, len) \
2669 do { \
2670 if (GRN_BULK_OUTP(bulk)) { \
2671 (bulk)->u.b.curr += (len); \
2672 } else { \
2673 (bulk)->header.flags += (grn_obj_flags)(len); \
2674 } \
2675 } while (0)
2676#define GRN_BULK_WSIZE(bulk) \
2677 (GRN_BULK_OUTP(bulk) ? (size_t)((bulk)->u.b.tail - (bulk)->u.b.head) \
2678 : GRN_BULK_BUFSIZE)
2679#define GRN_BULK_REST(bulk) \
2680 (GRN_BULK_OUTP(bulk) \
2681 ? (size_t)((bulk)->u.b.tail - (bulk)->u.b.curr) \
2682 : GRN_BULK_BUFSIZE - GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))
2683#define GRN_BULK_VSIZE(bulk) \
2684 (GRN_BULK_OUTP(bulk) ? (size_t)((bulk)->u.b.curr - (bulk)->u.b.head) \
2685 : GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))
2686#define GRN_BULK_EMPTYP(bulk) \
2687 (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.curr == (bulk)->u.b.head) \
2688 : !(GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags)))
2689#define GRN_BULK_HEAD(bulk) \
2690 (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.head) : (char *)&((bulk)->u.b.head))
2691#define GRN_BULK_CURR(bulk) \
2692 (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.curr) \
2693 : (char *)&((bulk)->u.b.head) + \
2694 GRN_BULK_SIZE_IN_FLAGS((bulk)->header.flags))
2695#define GRN_BULK_TAIL(bulk) \
2696 (GRN_BULK_OUTP(bulk) ? ((bulk)->u.b.tail) : (char *)&((bulk)[1]))
2697
2698GRN_API grn_rc
2699grn_bulk_reinit(grn_ctx *ctx, grn_obj *bulk, size_t size);
2700GRN_API grn_rc
2701grn_bulk_resize(grn_ctx *ctx, grn_obj *bulk, size_t new_size);
2702GRN_API grn_rc
2703grn_bulk_write(grn_ctx *ctx, grn_obj *bulk, const char *str, size_t len);
2704GRN_API grn_rc
2705grn_bulk_write_from(
2706 grn_ctx *ctx, grn_obj *bulk, const char *str, size_t from, size_t len);
2707GRN_API grn_rc
2708grn_bulk_reserve(grn_ctx *ctx, grn_obj *bulk, size_t len);
2709GRN_API grn_rc
2710grn_bulk_space(grn_ctx *ctx, grn_obj *bulk, size_t len);
2711GRN_API grn_rc
2712grn_bulk_truncate(grn_ctx *ctx, grn_obj *bulk, size_t len);
2713GRN_API char *
2714grn_bulk_detach(grn_ctx *ctx, grn_obj *bulk);
2731GRN_API void
2732grn_bulk_set(grn_ctx *ctx, grn_obj *bulk, const char *content, size_t size);
2744GRN_API void
2745grn_bulk_rewind(grn_ctx *ctx, grn_obj *bulk);
2760GRN_API const char *
2761grn_bulk_get_head(grn_ctx *ctx, grn_obj *bulk);
2775GRN_API size_t
2776grn_bulk_get_size(grn_ctx *ctx, grn_obj *bulk);
2777GRN_API grn_rc
2778grn_bulk_fin(grn_ctx *ctx, grn_obj *bulk);
2779
2780/* grn_text */
2781
2782GRN_API grn_rc
2783grn_text_itoa(grn_ctx *ctx, grn_obj *bulk, int i);
2784GRN_API grn_rc
2785grn_text_itoa_padded(grn_ctx *ctx, grn_obj *bulk, int i, char ch, size_t len);
2786GRN_API grn_rc
2787grn_text_lltoa(grn_ctx *ctx, grn_obj *bulk, long long int i);
2788#ifdef GRN_HAVE_BFLOAT16
2789GRN_API grn_rc
2790grn_text_bf16toa(grn_ctx *ctx, grn_obj *bulk, grn_bfloat16 value);
2791#endif
2792GRN_API grn_rc
2793grn_text_f32toa(grn_ctx *ctx, grn_obj *bulk, float f);
2794GRN_API grn_rc
2795grn_text_ftoa(grn_ctx *ctx, grn_obj *bulk, double d);
2796GRN_API grn_rc
2797grn_text_itoh(grn_ctx *ctx, grn_obj *bulk, unsigned int i, size_t len);
2798GRN_API grn_rc
2799grn_text_itob(grn_ctx *ctx, grn_obj *bulk, grn_id id);
2800GRN_API grn_rc
2801grn_text_lltob32h(grn_ctx *ctx, grn_obj *bulk, long long int i);
2802GRN_API grn_rc
2803grn_text_benc(grn_ctx *ctx, grn_obj *bulk, unsigned int v);
2804GRN_API grn_rc
2805grn_text_esc(grn_ctx *ctx, grn_obj *bulk, const char *s, size_t len);
2806GRN_API grn_rc
2807grn_text_code_point(grn_ctx *ctx, grn_obj *buffer, uint32_t code_point);
2808GRN_API grn_rc
2809grn_text_urlenc(grn_ctx *ctx, grn_obj *buf, const char *str, size_t len);
2810GRN_API const char *
2811grn_text_urldec(
2812 grn_ctx *ctx, grn_obj *buf, const char *s, const char *e, char d);
2813GRN_API grn_rc
2814grn_text_escape_xml(grn_ctx *ctx, grn_obj *buf, const char *s, size_t len);
2815GRN_API grn_rc
2816grn_text_time2rfc1123(grn_ctx *ctx, grn_obj *bulk, int sec);
2817GRN_API grn_rc
2818grn_text_printf(grn_ctx *ctx, grn_obj *bulk, const char *format, ...)
2819 GRN_ATTRIBUTE_PRINTF(3);
2820GRN_API grn_rc
2821grn_text_printfv(grn_ctx *ctx, grn_obj *bulk, const char *format, va_list args);
2822/* Deprecated since 10.0.3. Use grn_text_printfv() instead. */
2823GRN_API grn_rc
2824grn_text_vprintf(grn_ctx *ctx, grn_obj *bulk, const char *format, va_list args);
2825
2826typedef void (*grn_recv_handler_func)(grn_ctx *ctx, int flags, void *user_data);
2827
2828GRN_API void
2829grn_ctx_recv_handler_set(grn_ctx *,
2830 grn_recv_handler_func func,
2831 void *user_data);
2832
2833/* various values exchanged via grn_obj */
2834
2835#define GRN_OBJ_DO_SHALLOW_COPY (GRN_OBJ_REFER | GRN_OBJ_OUTPLACE)
2836/* A flag to initialize a vector object. */
2837#define GRN_OBJ_VECTOR (0x01 << 7)
2838
2839#define GRN_OBJ_MUTABLE(obj) ((obj) && (obj)->header.type <= GRN_VECTOR)
2840
2841#define GRN_VALUE_FIX_SIZE_INIT(obj, flags, domain) \
2842 GRN_OBJ_INIT((obj), \
2843 ((flags) & GRN_OBJ_VECTOR) ? GRN_UVECTOR : GRN_BULK, \
2844 ((flags) & GRN_OBJ_DO_SHALLOW_COPY), \
2845 (domain))
2846#define GRN_VALUE_VAR_SIZE_INIT(obj, flags, domain) \
2847 GRN_OBJ_INIT((obj), \
2848 ((flags) & GRN_OBJ_VECTOR) ? GRN_VECTOR : GRN_BULK, \
2849 ((flags) & GRN_OBJ_DO_SHALLOW_COPY), \
2850 (domain))
2851
2852#define GRN_VOID_INIT(obj) GRN_OBJ_INIT((obj), GRN_VOID, 0, GRN_DB_VOID)
2853#define GRN_TEXT_INIT(obj, flags) \
2854 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_TEXT)
2855#define GRN_SHORT_TEXT_INIT(obj, flags) \
2856 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_TEXT)
2857#define GRN_LONG_TEXT_INIT(obj, flags) \
2858 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_TEXT)
2859#define GRN_BULK_SET_REF(obj, value, len) \
2860 do { \
2861 (obj)->u.b.head = (char *)(value); \
2862 (obj)->u.b.curr = (char *)(value) + (len); \
2863 } while (0)
2864#define GRN_TEXT_SET_REF(obj, str, len) GRN_BULK_SET_REF((obj), (str), (len))
2865#define GRN_TEXT_SET(ctx, obj, str, len) \
2866 do { \
2867 if ((obj)->header.impl_flags & GRN_OBJ_REFER) { \
2868 GRN_TEXT_SET_REF((obj), (str), (len)); \
2869 } else { \
2870 grn_bulk_write_from((ctx), \
2871 (obj), \
2872 (const char *)(str), \
2873 0, \
2874 (unsigned int)(len)); \
2875 } \
2876 } while (0)
2877#define GRN_TEXT_PUT(ctx, obj, str, len) \
2878 grn_bulk_write((ctx), (obj), (const char *)(str), (unsigned int)(len))
2879#define GRN_TEXT_PUTC(ctx, obj, c) \
2880 do { \
2881 char _c = (c); \
2882 grn_bulk_write((ctx), (obj), &_c, 1); \
2883 } while (0)
2884
2885#define GRN_TEXT_PUTS(ctx, obj, str) \
2886 GRN_TEXT_PUT((ctx), (obj), (str), strlen(str))
2887#define GRN_TEXT_SETS(ctx, obj, str) \
2888 GRN_TEXT_SET((ctx), (obj), (str), strlen(str))
2889#define GRN_TEXT_VALUE(obj) GRN_BULK_HEAD(obj)
2890#define GRN_TEXT_LEN(obj) GRN_BULK_VSIZE(obj)
2891
2892#define GRN_TEXT_EQUAL_CSTRING(bulk, string) \
2893 (GRN_TEXT_LEN(bulk) == strlen(string) && \
2894 memcmp(GRN_TEXT_VALUE(bulk), string, GRN_TEXT_LEN(bulk)) == 0)
2895
2896#define GRN_BINARY_INIT(obj, flags) \
2897 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_BINARY)
2898#define GRN_SHORT_BINARY_INIT(obj, flags) \
2899 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_BINARY)
2900#define GRN_LONG_BINARY_INIT(obj, flags) \
2901 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_BINARY)
2902#define GRN_BINARY_SET_REF(obj, data, len) \
2903 do { \
2904 (obj)->u.b.head = (char *)(data); \
2905 (obj)->u.b.curr = (char *)(data) + (len); \
2906 } while (0)
2907#define GRN_BINARY_SET(ctx, obj, data, len) \
2908 do { \
2909 if ((obj)->header.impl_flags & GRN_OBJ_REFER) { \
2910 GRN_BINARY_SET_REF((obj), (data), (len)); \
2911 } else { \
2912 grn_bulk_write_from((ctx), \
2913 (obj), \
2914 (const char *)(data), \
2915 0, \
2916 (unsigned int)(len)); \
2917 } \
2918 } while (0)
2919#define GRN_BINARY_PUT(ctx, obj, data, len) \
2920 grn_bulk_write((ctx), (obj), (const char *)(data), (unsigned int)(len))
2921#define GRN_BINARY_VALUE(obj) ((const uint8_t *)GRN_BULK_HEAD(obj))
2922#define GRN_BINARY_LEN(obj) GRN_BULK_VSIZE(obj)
2923
2924#define GRN_JSON_INIT(obj, flags) \
2925 GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_JSON)
2926#define GRN_JSON_SET_REF(obj, data, len) \
2927 do { \
2928 (obj)->u.b.head = (char *)(data); \
2929 (obj)->u.b.curr = (char *)(data) + (len); \
2930 } while (0)
2931#define GRN_JSON_SET(ctx, obj, data, len) \
2932 do { \
2933 if ((obj)->header.impl_flags & GRN_OBJ_REFER) { \
2934 GRN_JSON_SET_REF((obj), (data), (len)); \
2935 } else { \
2936 grn_bulk_write_from((ctx), \
2937 (obj), \
2938 (const char *)(data), \
2939 0, \
2940 (unsigned int)(len)); \
2941 } \
2942 } while (0)
2943#define GRN_JSON_VALUE(obj) ((const uint8_t *)GRN_BULK_HEAD(obj))
2944#define GRN_JSON_LEN(obj) GRN_BULK_VSIZE(obj)
2945
2946#define GRN_BOOL_INIT(obj, flags) \
2947 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BOOL)
2948#define GRN_INT8_INIT(obj, flags) \
2949 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT8)
2950#define GRN_UINT8_INIT(obj, flags) \
2951 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT8)
2952#define GRN_INT16_INIT(obj, flags) \
2953 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT16)
2954#define GRN_UINT16_INIT(obj, flags) \
2955 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT16)
2956#define GRN_INT32_INIT(obj, flags) \
2957 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT32)
2958#define GRN_UINT32_INIT(obj, flags) \
2959 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT32)
2960#define GRN_INT64_INIT(obj, flags) \
2961 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT64)
2962#define GRN_UINT64_INIT(obj, flags) \
2963 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT64)
2964#define GRN_BFLOAT16_INIT(obj, flags) \
2965 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BFLOAT16)
2966#define GRN_FLOAT32_INIT(obj, flags) \
2967 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT32)
2968#define GRN_FLOAT_INIT(obj, flags) \
2969 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT)
2970#define GRN_TIME_INIT(obj, flags) \
2971 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TIME)
2972#define GRN_RECORD_INIT GRN_VALUE_FIX_SIZE_INIT
2973#define GRN_PTR_INIT(obj, flags, domain) \
2974 GRN_OBJ_INIT((obj), \
2975 ((flags) & GRN_OBJ_VECTOR) ? GRN_PVECTOR : GRN_PTR, \
2976 ((flags) & (GRN_OBJ_DO_SHALLOW_COPY | GRN_OBJ_OWN)), \
2977 (domain))
2978#define GRN_TOKYO_GEO_POINT_INIT(obj, flags) \
2979 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TOKYO_GEO_POINT)
2980#define GRN_WGS84_GEO_POINT_INIT(obj, flags) \
2981 GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_WGS84_GEO_POINT)
2982
2983#define GRN_BOOL_SET_REF(obj, ref) GRN_BULK_SET_REF((obj), (ref), sizeof(bool))
2984#define GRN_BOOL_SET(ctx, obj, val) \
2985 do { \
2986 bool _val = (bool)(val); \
2987 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(bool)); \
2988 } while (0)
2989#define GRN_INT8_SET(ctx, obj, val) \
2990 do { \
2991 int8_t _val = (int8_t)(val); \
2992 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int8_t)); \
2993 } while (0)
2994#define GRN_UINT8_SET(ctx, obj, val) \
2995 do { \
2996 uint8_t _val = (uint8_t)(val); \
2997 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint8_t)); \
2998 } while (0)
2999#define GRN_INT16_SET(ctx, obj, val) \
3000 do { \
3001 int16_t _val = (int16_t)(val); \
3002 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int16_t)); \
3003 } while (0)
3004#define GRN_UINT16_SET(ctx, obj, val) \
3005 do { \
3006 uint16_t _val = (uint16_t)(val); \
3007 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint16_t)); \
3008 } while (0)
3009#define GRN_INT32_SET(ctx, obj, val) \
3010 do { \
3011 int32_t _val = (int32_t)(val); \
3012 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int32_t)); \
3013 } while (0)
3014#define GRN_UINT32_SET(ctx, obj, val) \
3015 do { \
3016 uint32_t _val = (uint32_t)(val); \
3017 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint32_t)); \
3018 } while (0)
3019#define GRN_INT64_SET(ctx, obj, val) \
3020 do { \
3021 int64_t _val = (int64_t)(val); \
3022 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int64_t)); \
3023 } while (0)
3024#define GRN_UINT64_SET(ctx, obj, val) \
3025 do { \
3026 uint64_t _val = (uint64_t)(val); \
3027 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(uint64_t)); \
3028 } while (0)
3029#define GRN_BFLOAT16_SET(ctx, obj, val) \
3030 do { \
3031 grn_bfloat16 _val = (grn_bfloat16)(val); \
3032 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_bfloat16)); \
3033 } while (0)
3034#define GRN_FLOAT32_SET(ctx, obj, val) \
3035 do { \
3036 float _val = (float)(val); \
3037 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(float)); \
3038 } while (0)
3039#define GRN_FLOAT_SET(ctx, obj, val) \
3040 do { \
3041 double _val = (double)(val); \
3042 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(double)); \
3043 } while (0)
3044#define GRN_TIME_SET GRN_INT64_SET
3045#define GRN_RECORD_SET(ctx, obj, val) \
3046 do { \
3047 grn_id _val = (grn_id)(val); \
3048 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_id)); \
3049 } while (0)
3050#define GRN_PTR_SET(ctx, obj, val) \
3051 do { \
3052 grn_obj *_val = (grn_obj *)(val); \
3053 grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_obj *)); \
3054 } while (0)
3055
3056#define GRN_GEO_DEGREE2MSEC(degree) \
3057 ((int32_t)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))
3058#define GRN_GEO_MSEC2DEGREE(msec) ((((int32_t)(msec)) / 3600.0) * 0.001)
3059#define GRN_GEO_RESOLUTION 3600000
3060#define GRN_GEO_M_PI 3.14159265358979323846
3061#define GRN_GEO_RADIAN2MSEC(radian) \
3062 ((int32_t)(((GRN_GEO_RESOLUTION * 180) / GRN_GEO_M_PI) * (radian)))
3063#define GRN_GEO_MSEC2RADIAN(msec) \
3064 ((GRN_GEO_M_PI / (GRN_GEO_RESOLUTION * 180)) * (msec))
3065
3066#define GRN_GEO_POINT_SET(ctx, obj, _latitude, _longitude) \
3067 do { \
3068 grn_geo_point _val; \
3069 _val.latitude = (int)(_latitude); \
3070 _val.longitude = (int)(_longitude); \
3071 grn_bulk_write_from((ctx), \
3072 (obj), \
3073 (char *)&_val, \
3074 0, \
3075 sizeof(grn_geo_point)); \
3076 } while (0)
3077
3078#define GRN_BOOL_SET_AT(ctx, obj, offset, val) \
3079 do { \
3080 bool _val = (bool)(val); \
3081 grn_bulk_write_from((ctx), (obj), (char *)&_val, (offset), sizeof(bool)); \
3082 } while (0)
3083#define GRN_INT8_SET_AT(ctx, obj, offset, val) \
3084 do { \
3085 int8_t _val = (int8_t)(val); \
3086 grn_bulk_write_from((ctx), \
3087 (obj), \
3088 (char *)&_val, \
3089 (offset) * sizeof(int8_t), \
3090 sizeof(int8_t)); \
3091 } while (0)
3092#define GRN_UINT8_SET_AT(ctx, obj, offset, val) \
3093 do { \
3094 uint8_t _val = (uint8_t)(val); \
3095 grn_bulk_write_from((ctx), \
3096 (obj), \
3097 (char *)&_val, \
3098 (offset) * sizeof(uint8_t), \
3099 sizeof(uint8_t)); \
3100 } while (0)
3101#define GRN_INT16_SET_AT(ctx, obj, offset, val) \
3102 do { \
3103 int16_t _val = (int16_t)(val); \
3104 grn_bulk_write_from((ctx), \
3105 (obj), \
3106 (char *)&_val, \
3107 (offset) * sizeof(int16_t), \
3108 sizeof(int16_t)); \
3109 } while (0)
3110#define GRN_UINT16_SET_AT(ctx, obj, offset, val) \
3111 do { \
3112 uint16_t _val = (uint16_t)(val); \
3113 grn_bulk_write_from((ctx), \
3114 (obj), \
3115 (char *)&_val, \
3116 (offset) * sizeof(uint16_t), \
3117 sizeof(uint16_t)); \
3118 } while (0)
3119#define GRN_INT32_SET_AT(ctx, obj, offset, val) \
3120 do { \
3121 int32_t _val = (int32_t)(val); \
3122 grn_bulk_write_from((ctx), \
3123 (obj), \
3124 (char *)&_val, \
3125 (offset) * sizeof(int32_t), \
3126 sizeof(int32_t)); \
3127 } while (0)
3128#define GRN_UINT32_SET_AT(ctx, obj, offset, val) \
3129 do { \
3130 uint32_t _val = (uint32_t)(val); \
3131 grn_bulk_write_from((ctx), \
3132 (obj), \
3133 (char *)&_val, \
3134 (offset) * sizeof(uint32_t), \
3135 sizeof(uint32_t)); \
3136 } while (0)
3137#define GRN_INT64_SET_AT(ctx, obj, offset, val) \
3138 do { \
3139 int64_t _val = (int64_t)(val); \
3140 grn_bulk_write_from((ctx), \
3141 (obj), \
3142 (char *)&_val, \
3143 (offset) * sizeof(int64_t), \
3144 sizeof(int64_t)); \
3145 } while (0)
3146#define GRN_UINT64_SET_AT(ctx, obj, offset, val) \
3147 do { \
3148 uint64_t _val = (uint64_t)(val); \
3149 grn_bulk_write_from((ctx), \
3150 (obj), \
3151 (char *)&_val, \
3152 (offset) * sizeof(uint64_t), \
3153 sizeof(uint64_t)); \
3154 } while (0)
3155#define GRN_BFLOAT16_SET_AT(ctx, obj, offset, val) \
3156 do { \
3157 grn_bfloat16 _val = (grn_bfloat16)(val); \
3158 grn_bulk_write_from((ctx), \
3159 (obj), \
3160 (char *)&_val, \
3161 (offset) * sizeof(grn_bfloat16), \
3162 sizeof(grn_bfloat16)); \
3163 } while (0)
3164#define GRN_FLOAT32_SET_AT(ctx, obj, offset, val) \
3165 do { \
3166 float _val = (float)(val); \
3167 grn_bulk_write_from((ctx), \
3168 (obj), \
3169 (char *)&_val, \
3170 (offset) * sizeof(float), \
3171 sizeof(float)); \
3172 } while (0)
3173#define GRN_FLOAT_SET_AT(ctx, obj, offset, val) \
3174 do { \
3175 double _val = (double)(val); \
3176 grn_bulk_write_from((ctx), \
3177 (obj), \
3178 (char *)&_val, \
3179 (offset) * sizeof(double), \
3180 sizeof(double)); \
3181 } while (0)
3182#define GRN_TIME_SET_AT GRN_INT64_SET_AT
3183#define GRN_RECORD_SET_AT(ctx, obj, offset, val) \
3184 do { \
3185 grn_id _val = (grn_id)(val); \
3186 grn_bulk_write_from((ctx), \
3187 (obj), \
3188 (char *)&_val, \
3189 (offset) * sizeof(grn_id), \
3190 sizeof(grn_id)); \
3191 } while (0)
3192#define GRN_PTR_SET_AT(ctx, obj, offset, val) \
3193 do { \
3194 grn_obj *_val = (grn_obj *)(val); \
3195 grn_bulk_write_from((ctx), \
3196 (obj), \
3197 (char *)&_val, \
3198 (offset) * sizeof(grn_obj *), \
3199 sizeof(grn_obj *)); \
3200 } while (0)
3201
3202#define GRN_BOOL_VALUE(obj) (*((bool *)GRN_BULK_HEAD(obj)))
3203#define GRN_INT8_VALUE(obj) (*((int8_t *)GRN_BULK_HEAD(obj)))
3204#define GRN_UINT8_VALUE(obj) (*((uint8_t *)GRN_BULK_HEAD(obj)))
3205#define GRN_INT16_VALUE(obj) (*((int16_t *)GRN_BULK_HEAD(obj)))
3206#define GRN_UINT16_VALUE(obj) (*((uint16_t *)GRN_BULK_HEAD(obj)))
3207#define GRN_INT32_VALUE(obj) (*((int32_t *)GRN_BULK_HEAD(obj)))
3208#define GRN_UINT32_VALUE(obj) (*((uint32_t *)GRN_BULK_HEAD(obj)))
3209#define GRN_INT64_VALUE(obj) (*((int64_t *)GRN_BULK_HEAD(obj)))
3210#define GRN_UINT64_VALUE(obj) (*((uint64_t *)GRN_BULK_HEAD(obj)))
3211#define GRN_BFLOAT16_VALUE(obj) (*((grn_bfloat16 *)GRN_BULK_HEAD(obj)))
3212#define GRN_FLOAT32_VALUE(obj) (*((float *)GRN_BULK_HEAD(obj)))
3213#define GRN_FLOAT_VALUE(obj) (*((double *)GRN_BULK_HEAD(obj)))
3214#define GRN_TIME_VALUE GRN_INT64_VALUE
3215#define GRN_RECORD_VALUE(obj) (*((grn_id *)GRN_BULK_HEAD(obj)))
3216#define GRN_PTR_VALUE(obj) (*((grn_obj **)GRN_BULK_HEAD(obj)))
3217#define GRN_GEO_POINT_VALUE_RAW(obj) (grn_geo_point *)GRN_BULK_HEAD(obj)
3218#define GRN_GEO_POINT_VALUE(obj, _latitude, _longitude) \
3219 do { \
3220 grn_geo_point *_val = GRN_GEO_POINT_VALUE_RAW(obj); \
3221 _latitude = _val->latitude; \
3222 _longitude = _val->longitude; \
3223 } while (0)
3224#define GRN_GEO_POINT_VALUE_RADIAN(obj, _latitude, _longitude) \
3225 do { \
3226 grn_geo_point *_val = GRN_GEO_POINT_VALUE_RAW(obj); \
3227 _latitude = GRN_GEO_MSEC2RADIAN(_val->latitude); \
3228 _longitude = GRN_GEO_MSEC2RADIAN(_val->longitude); \
3229 } while (0)
3230
3231#define GRN_BOOL_VALUE_AT(obj, offset) (((bool *)GRN_BULK_HEAD(obj))[offset])
3232#define GRN_INT8_VALUE_AT(obj, offset) (((int8_t *)GRN_BULK_HEAD(obj))[offset])
3233#define GRN_UINT8_VALUE_AT(obj, offset) \
3234 (((uint8_t *)GRN_BULK_HEAD(obj))[offset])
3235#define GRN_INT16_VALUE_AT(obj, offset) \
3236 (((int16_t *)GRN_BULK_HEAD(obj))[offset])
3237#define GRN_UINT16_VALUE_AT(obj, offset) \
3238 (((uint16_t *)GRN_BULK_HEAD(obj))[offset])
3239#define GRN_INT32_VALUE_AT(obj, offset) \
3240 (((int32_t *)GRN_BULK_HEAD(obj))[offset])
3241#define GRN_UINT32_VALUE_AT(obj, offset) \
3242 (((uint32_t *)GRN_BULK_HEAD(obj))[offset])
3243#define GRN_INT64_VALUE_AT(obj, offset) \
3244 (((int64_t *)GRN_BULK_HEAD(obj))[offset])
3245#define GRN_UINT64_VALUE_AT(obj, offset) \
3246 (((uint64_t *)GRN_BULK_HEAD(obj))[offset])
3247#define GRN_BFLOAT16_VALUE_AT(obj, offset) \
3248 (((grn_bfloat16 *)GRN_BULK_HEAD(obj))[offset])
3249#define GRN_FLOAT32_VALUE_AT(obj, offset) \
3250 (((float *)GRN_BULK_HEAD(obj))[offset])
3251#define GRN_FLOAT_VALUE_AT(obj, offset) (((double *)GRN_BULK_HEAD(obj))[offset])
3252#define GRN_TIME_VALUE_AT GRN_INT64_VALUE_AT
3253#define GRN_RECORD_VALUE_AT(obj, offset) \
3254 (((grn_id *)GRN_BULK_HEAD(obj))[offset])
3255#define GRN_PTR_VALUE_AT(obj, offset) (((grn_obj **)GRN_BULK_HEAD(obj))[offset])
3256
3257#define GRN_BOOL_PUT(ctx, obj, val) \
3258 do { \
3259 bool _val = (bool)(val); \
3260 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(bool)); \
3261 } while (0)
3262#define GRN_INT8_PUT(ctx, obj, val) \
3263 do { \
3264 int8_t _val = (int8_t)(val); \
3265 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int8_t)); \
3266 } while (0)
3267#define GRN_UINT8_PUT(ctx, obj, val) \
3268 do { \
3269 uint8_t _val = (uint8_t)(val); \
3270 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint8_t)); \
3271 } while (0)
3272#define GRN_INT16_PUT(ctx, obj, val) \
3273 do { \
3274 int16_t _val = (int16_t)(val); \
3275 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int16_t)); \
3276 } while (0)
3277#define GRN_UINT16_PUT(ctx, obj, val) \
3278 do { \
3279 uint16_t _val = (uint16_t)(val); \
3280 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint16_t)); \
3281 } while (0)
3282#define GRN_INT32_PUT(ctx, obj, val) \
3283 do { \
3284 int32_t _val = (int32_t)(val); \
3285 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int32_t)); \
3286 } while (0)
3287#define GRN_UINT32_PUT(ctx, obj, val) \
3288 do { \
3289 uint32_t _val = (uint32_t)(val); \
3290 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int)); \
3291 } while (0)
3292#define GRN_INT64_PUT(ctx, obj, val) \
3293 do { \
3294 int64_t _val = (int64_t)(val); \
3295 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int64_t)); \
3296 } while (0)
3297#define GRN_UINT64_PUT(ctx, obj, val) \
3298 do { \
3299 uint64_t _val = (uint64_t)(val); \
3300 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(uint64_t)); \
3301 } while (0)
3302#define GRN_BFLOAT16_PUT(ctx, obj, val) \
3303 do { \
3304 grn_bfloat16 _val = (grn_bfloat16)(val); \
3305 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_bfloat16)); \
3306 } while (0)
3307#define GRN_FLOAT32_PUT(ctx, obj, val) \
3308 do { \
3309 float _val = (float)(val); \
3310 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(float)); \
3311 } while (0)
3312#define GRN_FLOAT_PUT(ctx, obj, val) \
3313 do { \
3314 double _val = (double)(val); \
3315 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(double)); \
3316 } while (0)
3317#define GRN_TIME_PUT GRN_INT64_PUT
3318#define GRN_RECORD_PUT(ctx, obj, val) \
3319 do { \
3320 grn_id _val = (grn_id)(val); \
3321 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_id)); \
3322 } while (0)
3323#define GRN_PTR_PUT(ctx, obj, val) \
3324 do { \
3325 grn_obj *_val = (grn_obj *)(val); \
3326 grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_obj *)); \
3327 } while (0)
3328
3329#define GRN_BULK_POP(obj, value, type, default) \
3330 do { \
3331 if (GRN_BULK_VSIZE(obj) >= sizeof(type)) { \
3332 ssize_t value_size = (ssize_t)(sizeof(type)); \
3333 GRN_BULK_INCR_LEN((obj), -value_size); \
3334 value = *(type *)(GRN_BULK_CURR(obj)); \
3335 } else { \
3336 value = default; \
3337 } \
3338 } while (0)
3339#define GRN_BOOL_POP(obj, value) GRN_BULK_POP(obj, value, bool, 0)
3340#define GRN_INT8_POP(obj, value) GRN_BULK_POP(obj, value, int8_t, 0)
3341#define GRN_UINT8_POP(obj, value) GRN_BULK_POP(obj, value, uint8_t, 0)
3342#define GRN_INT16_POP(obj, value) GRN_BULK_POP(obj, value, int16_t, 0)
3343#define GRN_UINT16_POP(obj, value) GRN_BULK_POP(obj, value, uint16_t, 0)
3344#define GRN_INT32_POP(obj, value) GRN_BULK_POP(obj, value, int32_t, 0)
3345#define GRN_UINT32_POP(obj, value) GRN_BULK_POP(obj, value, uint32_t, 0)
3346#define GRN_INT64_POP(obj, value) GRN_BULK_POP(obj, value, int64_t, 0)
3347#define GRN_UINT64_POP(obj, value) GRN_BULK_POP(obj, value, uint64_t, 0)
3348#define GRN_BFLOAT16_POP(obj, value) GRN_BULK_POP(obj, value, grn_bfloat16, 0.0)
3349#define GRN_FLOAT32_POP(obj, value) GRN_BULK_POP(obj, value, float, 0.0)
3350#define GRN_FLOAT_POP(obj, value) GRN_BULK_POP(obj, value, double, 0.0)
3351#define GRN_TIME_POP GRN_INT64_POP
3352#define GRN_RECORD_POP(obj, value) GRN_BULK_POP(obj, value, grn_id, GRN_ID_NIL)
3353#define GRN_PTR_POP(obj, value) GRN_BULK_POP(obj, value, grn_obj *, NULL)
3354
3355#define GRN_BULK_VECTOR_SIZE(obj, type) (GRN_BULK_VSIZE(obj) / sizeof(type))
3356#define GRN_BOOL_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, bool)
3357#define GRN_INT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int8_t)
3358#define GRN_UINT8_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint8_t)
3359#define GRN_INT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int16_t)
3360#define GRN_UINT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint16_t)
3361#define GRN_INT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int32_t)
3362#define GRN_UINT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint32_t)
3363#define GRN_INT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, int64_t)
3364#define GRN_UINT64_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, uint64_t)
3365#define GRN_BFLOAT16_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_bfloat16)
3366#define GRN_FLOAT32_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, float)
3367#define GRN_FLOAT_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, double)
3368#define GRN_TIME_VECTOR_SIZE GRN_INT64_VECTOR_SIZE
3369#define GRN_RECORD_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_id)
3370#define GRN_PTR_VECTOR_SIZE(obj) GRN_BULK_VECTOR_SIZE(obj, grn_obj *)
3371
3372GRN_API grn_rc
3373grn_ctx_push(grn_ctx *ctx, grn_obj *obj);
3374GRN_API grn_obj *
3375grn_ctx_pop(grn_ctx *ctx);
3376
3377GRN_API grn_rc
3378grn_obj_columns(grn_ctx *ctx,
3379 grn_obj *table,
3380 const char *str,
3381 unsigned int str_size,
3382 grn_obj *res);
3383
3384GRN_API grn_rc
3385grn_load(grn_ctx *ctx,
3386 grn_content_type input_type,
3387 const char *table,
3388 unsigned int table_len,
3389 const char *columns,
3390 unsigned int columns_len,
3391 const char *values,
3392 unsigned int values_len,
3393 const char *ifexists,
3394 unsigned int ifexists_len,
3395 const char *each,
3396 unsigned int each_len);
3397
3398#define GRN_CTX_MORE (0x01 << 0)
3399#define GRN_CTX_TAIL (0x01 << 1)
3400#define GRN_CTX_HEAD (0x01 << 2)
3401#define GRN_CTX_QUIET (0x01 << 3)
3402#define GRN_CTX_QUIT (0x01 << 4)
3403
3404GRN_API grn_rc
3405grn_ctx_connect(grn_ctx *ctx, const char *host, int port, int flags);
3406GRN_API unsigned int
3407grn_ctx_send(grn_ctx *ctx, const char *str, unsigned int str_len, int flags);
3408GRN_API grn_rc
3409grn_ctx_recv(grn_ctx *ctx, char **str, unsigned int *str_len, int *flags);
3410
3411typedef struct _grn_ctx_info grn_ctx_info;
3412
3413struct _grn_ctx_info {
3414 int fd;
3415 unsigned int com_status;
3416 grn_obj *outbuf;
3417 unsigned char stat;
3418};
3419
3420GRN_API grn_rc
3421grn_ctx_info_get(grn_ctx *ctx, grn_ctx_info *info);
3422
3423GRN_API grn_rc
3424grn_set_segv_handler(void);
3425GRN_API grn_rc
3426grn_set_abrt_handler(void);
3427GRN_API grn_rc
3428grn_set_int_handler(void);
3429GRN_API grn_rc
3430grn_set_term_handler(void);
3431
3432typedef struct _grn_table_delete_optarg grn_table_delete_optarg;
3433
3434struct _grn_table_delete_optarg {
3435 int flags;
3436 int (*func)(grn_ctx *ctx, grn_obj *, grn_id, void *);
3437 void *func_arg;
3438};
3439
3440struct _grn_table_scan_hit {
3441 grn_id id;
3442 unsigned int offset;
3443 unsigned int length;
3444};
3445
3446typedef struct {
3447 int64_t tv_sec;
3448 int32_t tv_nsec;
3449} grn_timeval;
3450
3451#ifdef __cplusplus
3452}
3453#endif
grn_default_logger_set_max_level
GRN_API void grn_default_logger_set_max_level(grn_log_level level)
grn_command_version
grn_command_version
Definition groonga.h:181
GRN_COMMAND_VERSION_3
@ GRN_COMMAND_VERSION_3
Definition groonga.h:185
GRN_COMMAND_VERSION_1
@ GRN_COMMAND_VERSION_1
Definition groonga.h:183
GRN_COMMAND_VERSION_2
@ GRN_COMMAND_VERSION_2
Definition groonga.h:184
GRN_COMMAND_VERSION_DEFAULT
@ GRN_COMMAND_VERSION_DEFAULT
Definition groonga.h:182
grn_log_flags_parse
GRN_API bool grn_log_flags_parse(const char *string, int string_size, int *flags)
grn_logger_is_default_logger
GRN_API bool grn_logger_is_default_logger(grn_ctx *ctx)
grn_ctx_connect
GRN_API grn_rc grn_ctx_connect(grn_ctx *ctx, const char *host, int port, int flags)
grn_obj_flags
uint16_t grn_obj_flags
Definition groonga.h:719
grn_ctx_set_force_match_escalation
GRN_API grn_rc grn_ctx_set_force_match_escalation(grn_ctx *ctx, bool force)
grn_obj_unref_recursive
GRN_API void grn_obj_unref_recursive(grn_ctx *ctx, grn_obj *obj)
grn_get_global_error_message
GRN_API const char * grn_get_global_error_message(void)
grn_bulk_fin
GRN_API grn_rc grn_bulk_fin(grn_ctx *ctx, grn_obj *bulk)
grn_obj_db
GRN_API grn_obj * grn_obj_db(grn_ctx *ctx, grn_obj *obj)
Return the database to which obj belongs.
grn_logger_set_max_level
GRN_API void grn_logger_set_max_level(grn_ctx *ctx, grn_log_level max_level)
grn_set_term_handler
GRN_API grn_rc grn_set_term_handler(void)
grn_ctx_recv_handler_set
GRN_API void grn_ctx_recv_handler_set(grn_ctx *, grn_recv_handler_func func, void *user_data)
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.
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.
grn_info_type
grn_info_type
Definition groonga.h:1335
GRN_INFO_PARTIAL_MATCH_THRESHOLD
@ GRN_INFO_PARTIAL_MATCH_THRESHOLD
Definition groonga.h:1363
GRN_INFO_ENCODING
@ GRN_INFO_ENCODING
Definition groonga.h:1336
GRN_INFO_NORMALIZER
@ GRN_INFO_NORMALIZER
Definition groonga.h:1369
GRN_INFO_ELEMENT_SIZE_IN_BUFFER
@ GRN_INFO_ELEMENT_SIZE_IN_BUFFER
Definition groonga.h:1354
GRN_INFO_ELEMENT_SIZE
@ GRN_INFO_ELEMENT_SIZE
Definition groonga.h:1339
GRN_INFO_HOOK_LOCAL_DATA
@ GRN_INFO_HOOK_LOCAL_DATA
Definition groonga.h:1345
GRN_INFO_II_SPLIT_THRESHOLD
@ GRN_INFO_II_SPLIT_THRESHOLD
Definition groonga.h:1364
GRN_INFO_ELEMENT_POS_IN_CHUNK
@ GRN_INFO_ELEMENT_POS_IN_CHUNK
Definition groonga.h:1353
GRN_INFO_GENERATOR
@ GRN_INFO_GENERATOR
Definition groonga.h:1376
GRN_INFO_TOKEN_FILTERS
@ GRN_INFO_TOKEN_FILTERS
Definition groonga.h:1370
GRN_INFO_SUPPORT_ZSTD
@ GRN_INFO_SUPPORT_ZSTD
Definition groonga.h:1371
GRN_INFO_SUPPORT_FAISS
@ GRN_INFO_SUPPORT_FAISS
Definition groonga.h:1378
GRN_INFO_CHUNK_SIZE
@ GRN_INFO_CHUNK_SIZE
Definition groonga.h:1343
GRN_INFO_SUPPORT_APACHE_ARROW
@ GRN_INFO_SUPPORT_APACHE_ARROW
Definition groonga.h:1374
GRN_INFO_ELEMENT_A
@ GRN_INFO_ELEMENT_A
Definition groonga.h:1346
GRN_INFO_ELEMENT_SIZE_IN_CHUNK
@ GRN_INFO_ELEMENT_SIZE_IN_CHUNK
Definition groonga.h:1352
GRN_INFO_DEFAULT_TOKENIZER
@ GRN_INFO_DEFAULT_TOKENIZER
Definition groonga.h:1338
GRN_INFO_ELEMENT_POS_IN_BUFFER
@ GRN_INFO_ELEMENT_POS_IN_BUFFER
Definition groonga.h:1355
GRN_INFO_NGRAM_UNIT_SIZE
@ GRN_INFO_NGRAM_UNIT_SIZE
Definition groonga.h:1357
GRN_INFO_SUPPORT_LLAMA_CPP
@ GRN_INFO_SUPPORT_LLAMA_CPP
Definition groonga.h:1377
GRN_INFO_NORMALIZERS
@ GRN_INFO_NORMALIZERS
Definition groonga.h:1375
GRN_INFO_ELEMENT_CHUNK_SIZE
@ GRN_INFO_ELEMENT_CHUNK_SIZE
Definition groonga.h:1348
GRN_INFO_ELEMENT_BUFFER_FREE
@ GRN_INFO_ELEMENT_BUFFER_FREE
Definition groonga.h:1349
GRN_INFO_ELEMENT_NTERMS_VOID
@ GRN_INFO_ELEMENT_NTERMS_VOID
Definition groonga.h:1351
GRN_INFO_CURR_MAX
@ GRN_INFO_CURR_MAX
Definition groonga.h:1340
GRN_INFO_SEG_SIZE
@ GRN_INFO_SEG_SIZE
Definition groonga.h:1342
GRN_INFO_MAX_ELEMENT_SIZE
@ GRN_INFO_MAX_ELEMENT_SIZE
Definition groonga.h:1341
GRN_INFO_SOURCE
@ GRN_INFO_SOURCE
Definition groonga.h:1337
GRN_INFO_ELEMENT_CHUNK
@ GRN_INFO_ELEMENT_CHUNK
Definition groonga.h:1347
GRN_INFO_EXTRACTORS
@ GRN_INFO_EXTRACTORS
Definition groonga.h:1379
GRN_INFO_ELEMENT_ESTIMATE_SIZE
@ GRN_INFO_ELEMENT_ESTIMATE_SIZE
Definition groonga.h:1356
GRN_INFO_SUPPORT_LZ4
@ GRN_INFO_SUPPORT_LZ4
Definition groonga.h:1366
GRN_INFO_MAX_SECTION
@ GRN_INFO_MAX_SECTION
Definition groonga.h:1344
GRN_INFO_SUPPORT_ZLIB
@ GRN_INFO_SUPPORT_ZLIB
Definition groonga.h:1365
GRN_INFO_ELEMENT_NTERMS
@ GRN_INFO_ELEMENT_NTERMS
Definition groonga.h:1350
grn_obj_unlock
GRN_API grn_rc grn_obj_unlock(grn_ctx *ctx, grn_obj *obj, grn_id id)
Unlock an object.
grn_search_optarg
struct _grn_search_optarg grn_search_optarg
Definition groonga.h:2034
grn_bulk_resize
GRN_API grn_rc grn_bulk_resize(grn_ctx *ctx, grn_obj *bulk, size_t new_size)
grn_ctx_merge_temporary_open_space
GRN_API grn_rc grn_ctx_merge_temporary_open_space(grn_ctx *ctx)
grn_default_query_logger_get_path
GRN_API const char * grn_default_query_logger_get_path(void)
grn_query_logger
struct _grn_query_logger grn_query_logger
Definition groonga.h:2572
grn_text_itoh
GRN_API grn_rc grn_text_itoh(grn_ctx *ctx, grn_obj *bulk, unsigned int i, size_t len)
grn_plugin_register_by_path
GRN_API grn_rc grn_plugin_register_by_path(grn_ctx *ctx, const char *path)
grn_default_query_logger_get_rotate_threshold_size
GRN_API off_t grn_default_query_logger_get_rotate_threshold_size(void)
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.
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.
grn_text_itob
GRN_API grn_rc grn_text_itob(grn_ctx *ctx, grn_obj *bulk, grn_id id)
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) retu...
grn_logger_get_max_level
GRN_API grn_log_level grn_logger_get_max_level(grn_ctx *ctx)
grn_ctx_get_match_escalation_threshold
GRN_API int64_t grn_ctx_get_match_escalation_threshold(grn_ctx *ctx)
grn_obj_unref_recursive_dependent
GRN_API void grn_obj_unref_recursive_dependent(grn_ctx *ctx, grn_obj *obj)
grn_snip_mapping
struct _grn_snip_mapping grn_snip_mapping
Definition groonga.h:2339
grn_default_logger_get_max_level
GRN_API grn_log_level grn_default_logger_get_max_level(void)
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_...
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_set_segv_handler
GRN_API grn_rc grn_set_segv_handler(void)
grn_index_datum
struct _grn_index_datum grn_index_datum
grn_get_package
GRN_API const char * grn_get_package(void)
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_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_set_back_trace_enable
GRN_API grn_rc grn_set_back_trace_enable(bool enable)
grn_default_query_logger_set_flags
GRN_API void grn_default_query_logger_set_flags(unsigned int flags)
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.
grn_default_logger_get_flags
GRN_API int grn_default_logger_get_flags(void)
grn_obj_flush_only_opened
GRN_API grn_rc grn_obj_flush_only_opened(grn_ctx *ctx, grn_obj *obj)
grn_default_query_logger_get_flags
GRN_API unsigned int grn_default_query_logger_get_flags(void)
grn_rc
grn_rc
Definition groonga.h:61
GRN_OPERATION_WOULD_BLOCK
@ GRN_OPERATION_WOULD_BLOCK
Definition groonga.h:108
GRN_SCORER_ERROR
@ GRN_SCORER_ERROR
Definition groonga.h:145
GRN_EXEC_FORMAT_ERROR
@ GRN_EXEC_FORMAT_ERROR
Definition groonga.h:73
GRN_INTERRUPTED_FUNCTION_CALL
@ GRN_INTERRUPTED_FUNCTION_CALL
Definition groonga.h:69
GRN_INVALID_FORMAT
@ GRN_INVALID_FORMAT
Definition groonga.h:120
GRN_FILE_CORRUPT
@ GRN_FILE_CORRUPT
Definition groonga.h:119
GRN_UPDATE_NOT_ALLOWED
@ GRN_UPDATE_NOT_ALLOWED
Definition groonga.h:134
GRN_INPUT_OUTPUT_ERROR
@ GRN_INPUT_OUTPUT_ERROR
Definition groonga.h:70
GRN_NORMALIZER_ERROR
@ GRN_NORMALIZER_ERROR
Definition groonga.h:141
GRN_RANGE_ERROR
@ GRN_RANGE_ERROR
Definition groonga.h:117
GRN_PERMISSION_DENIED
@ GRN_PERMISSION_DENIED
Definition groonga.h:78
GRN_CONNECTION_REFUSED
@ GRN_CONNECTION_REFUSED
Definition groonga.h:116
GRN_OPENZL_ERROR
@ GRN_OPENZL_ERROR
Definition groonga.h:151
GRN_IMPROPER_LINK
@ GRN_IMPROPER_LINK
Definition groonga.h:82
GRN_LZ4_ERROR
@ GRN_LZ4_ERROR
Definition groonga.h:127
GRN_FUNCTION_NOT_IMPLEMENTED
@ GRN_FUNCTION_NOT_IMPLEMENTED
Definition groonga.h:104
GRN_FILENAME_TOO_LONG
@ GRN_FILENAME_TOO_LONG
Definition groonga.h:102
GRN_TOKENIZER_ERROR
@ GRN_TOKENIZER_ERROR
Definition groonga.h:118
GRN_FILE_TOO_LARGE
@ GRN_FILE_TOO_LARGE
Definition groonga.h:91
GRN_RESOURCE_TEMPORARILY_UNAVAILABLE
@ GRN_RESOURCE_TEMPORARILY_UNAVAILABLE
Definition groonga.h:76
GRN_SUCCESS
@ GRN_SUCCESS
Success (0).
Definition groonga.h:63
GRN_TOO_MANY_LINKS
@ GRN_TOO_MANY_LINKS
Definition groonga.h:95
GRN_CONNECTION_RESET
@ GRN_CONNECTION_RESET
Definition groonga.h:149
GRN_OPERATION_NOT_PERMITTED
@ GRN_OPERATION_NOT_PERMITTED
Definition groonga.h:66
GRN_EXTRACTOR_ERROR
@ GRN_EXTRACTOR_ERROR
Definition groonga.h:152
GRN_NOT_A_DIRECTORY
@ GRN_NOT_A_DIRECTORY
Definition groonga.h:84
GRN_STACK_OVER_FLOW
@ GRN_STACK_OVER_FLOW
Definition groonga.h:130
GRN_END_OF_DATA
@ GRN_END_OF_DATA
Definition groonga.h:64
GRN_OPERATION_NOT_SUPPORTED
@ GRN_OPERATION_NOT_SUPPORTED
Definition groonga.h:124
GRN_DIRECTORY_NOT_EMPTY
@ GRN_DIRECTORY_NOT_EMPTY
Definition groonga.h:105
GRN_SOCKET_IS_NOT_CONNECTED
@ GRN_SOCKET_IS_NOT_CONNECTED
Definition groonga.h:113
GRN_IS_A_DIRECTORY
@ GRN_IS_A_DIRECTORY
Definition groonga.h:85
GRN_ADDRESS_IS_IN_USE
@ GRN_ADDRESS_IS_IN_USE
Definition groonga.h:125
GRN_TOO_MANY_SYMBOLIC_LINKS
@ GRN_TOO_MANY_SYMBOLIC_LINKS
Definition groonga.h:122
GRN_ADDRESS_IS_NOT_AVAILABLE
@ GRN_ADDRESS_IS_NOT_AVAILABLE
Definition groonga.h:109
GRN_NETWORK_IS_DOWN
@ GRN_NETWORK_IS_DOWN
Definition groonga.h:110
GRN_SOCKET_IS_ALREADY_SHUTDOWNED
@ GRN_SOCKET_IS_ALREADY_SHUTDOWNED
Definition groonga.h:114
GRN_RESULT_TOO_LARGE
@ GRN_RESULT_TOO_LARGE
Definition groonga.h:98
GRN_UNKNOWN_ERROR
@ GRN_UNKNOWN_ERROR
Definition groonga.h:65
GRN_NO_LOCKS_AVAILABLE
@ GRN_NO_LOCKS_AVAILABLE
Definition groonga.h:103
GRN_COMMAND_ERROR
@ GRN_COMMAND_ERROR
Definition groonga.h:143
GRN_TOO_SMALL_OFFSET
@ GRN_TOO_SMALL_OFFSET
Definition groonga.h:135
GRN_NOT_ENOUGH_SPACE
@ GRN_NOT_ENOUGH_SPACE
Definition groonga.h:77
GRN_NO_MEMORY_AVAILABLE
@ GRN_NO_MEMORY_AVAILABLE
Not enough memory available (-35).
Definition groonga.h:101
GRN_UNSUPPORTED_COMMAND_VERSION
@ GRN_UNSUPPORTED_COMMAND_VERSION
When a version not supported by the default version set is specified (-71).
Definition groonga.h:140
GRN_ILLEGAL_BYTE_SEQUENCE
@ GRN_ILLEGAL_BYTE_SEQUENCE
Definition groonga.h:106
GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM
@ GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM
Definition groonga.h:88
GRN_BROKEN_PIPE
@ GRN_BROKEN_PIPE
Definition groonga.h:96
GRN_NO_SUCH_DEVICE
@ GRN_NO_SUCH_DEVICE
Definition groonga.h:83
GRN_BLOSC_ERROR
@ GRN_BLOSC_ERROR
Definition groonga.h:150
GRN_DOMAIN_ERROR
@ GRN_DOMAIN_ERROR
Definition groonga.h:97
GRN_SYNTAX_ERROR
@ GRN_SYNTAX_ERROR
Definition groonga.h:131
GRN_TOKEN_FILTER_ERROR
@ GRN_TOKEN_FILTER_ERROR
Definition groonga.h:142
GRN_SOCKET_NOT_INITIALIZED
@ GRN_SOCKET_NOT_INITIALIZED
Definition groonga.h:107
GRN_TOO_LARGE_OFFSET
@ GRN_TOO_LARGE_OFFSET
Definition groonga.h:136
GRN_CANCEL
@ GRN_CANCEL
Definition groonga.h:146
GRN_OBJECT_CORRUPT
@ GRN_OBJECT_CORRUPT
Definition groonga.h:121
GRN_RETRY_MAX
@ GRN_RETRY_MAX
Definition groonga.h:132
GRN_ARG_LIST_TOO_LONG
@ GRN_ARG_LIST_TOO_LONG
Definition groonga.h:72
GRN_INCOMPATIBLE_FILE_FORMAT
@ GRN_INCOMPATIBLE_FILE_FORMAT
Definition groonga.h:133
GRN_NO_SUCH_FILE_OR_DIRECTORY
@ GRN_NO_SUCH_FILE_OR_DIRECTORY
Definition groonga.h:67
GRN_ZSTD_ERROR
@ GRN_ZSTD_ERROR
Definition groonga.h:148
GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION
@ GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION
Definition groonga.h:90
GRN_BAD_ADDRESS
@ GRN_BAD_ADDRESS
Definition groonga.h:79
GRN_SOCKET_IS_ALREADY_CONNECTED
@ GRN_SOCKET_IS_ALREADY_CONNECTED
Definition groonga.h:112
GRN_NO_SPACE_LEFT_ON_DEVICE
@ GRN_NO_SPACE_LEFT_ON_DEVICE
Definition groonga.h:92
GRN_NO_CHILD_PROCESSES
@ GRN_NO_CHILD_PROCESSES
Definition groonga.h:75
GRN_NO_SUCH_DEVICE_OR_ADDRESS
@ GRN_NO_SUCH_DEVICE_OR_ADDRESS
Definition groonga.h:71
GRN_READ_ONLY_FILE_SYSTEM
@ GRN_READ_ONLY_FILE_SYSTEM
Definition groonga.h:94
GRN_OPERATION_TIMEOUT
@ GRN_OPERATION_TIMEOUT
Definition groonga.h:115
GRN_WINDOW_FUNCTION_ERROR
@ GRN_WINDOW_FUNCTION_ERROR
Definition groonga.h:147
GRN_RESOURCE_BUSY
@ GRN_RESOURCE_BUSY
Definition groonga.h:80
GRN_NOT_SOCKET
@ GRN_NOT_SOCKET
Definition groonga.h:123
GRN_INVALID_SEEK
@ GRN_INVALID_SEEK
Definition groonga.h:93
GRN_INVALID_ARGUMENT
@ GRN_INVALID_ARGUMENT
Invalid function argument (-22).
Definition groonga.h:87
GRN_NO_SUCH_PROCESS
@ GRN_NO_SUCH_PROCESS
Definition groonga.h:68
GRN_NO_BUFFER
@ GRN_NO_BUFFER
Definition groonga.h:111
GRN_TOO_MANY_OPEN_FILES
@ GRN_TOO_MANY_OPEN_FILES
Definition groonga.h:89
GRN_TOO_SMALL_LIMIT
@ GRN_TOO_SMALL_LIMIT
Definition groonga.h:137
GRN_RESOURCE_DEADLOCK_AVOIDED
@ GRN_RESOURCE_DEADLOCK_AVOIDED
Definition groonga.h:99
GRN_FILE_EXISTS
@ GRN_FILE_EXISTS
Definition groonga.h:81
GRN_CAS_ERROR
@ GRN_CAS_ERROR
Definition groonga.h:138
GRN_BAD_FILE_DESCRIPTOR
@ GRN_BAD_FILE_DESCRIPTOR
Definition groonga.h:74
GRN_ZLIB_ERROR
@ GRN_ZLIB_ERROR
Definition groonga.h:126
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...
grn_bulk_reserve
GRN_API grn_rc grn_bulk_reserve(grn_ctx *ctx, grn_obj *bulk, size_t len)
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.
grn_ctx_close
GRN_API grn_rc grn_ctx_close(grn_ctx *ctx)
Close the context.
grn_ctx_fin
GRN_API grn_rc grn_ctx_fin(grn_ctx *ctx)
Finish the context.
grn_ctx_get_error_message
GRN_API const char * grn_ctx_get_error_message(grn_ctx *ctx)
Return the error message of the last operation in the given context.
grn_plugin_register
GRN_API grn_rc grn_plugin_register(grn_ctx *ctx, const char *name)
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_set_normalizers
GRN_API grn_rc grn_snip_set_normalizers(grn_ctx *ctx, grn_obj *snip, grn_obj *normalizers)
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.
grn_default_logger_set_flags
GRN_API void grn_default_logger_set_flags(int flags)
grn_ctx_info
struct _grn_ctx_info grn_ctx_info
Definition groonga.h:3411
grn_ctx_info_get
GRN_API grn_rc grn_ctx_info_get(grn_ctx *ctx, grn_ctx_info *info)
grn_obj_close
GRN_API grn_rc grn_obj_close(grn_ctx *ctx, grn_obj *obj)
Close an object.
grn_logger_reopen
GRN_API void grn_logger_reopen(grn_ctx *ctx)
grn_obj_path
GRN_API const char * grn_obj_path(grn_ctx *ctx, grn_obj *obj)
Return the file path associated with an object.
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_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.
grn_ctx
struct _grn_ctx grn_ctx
grn_ctx is the most important object.
Definition groonga.h:332
grn_logger_info
struct _grn_logger_info grn_logger_info
Definition groonga.h:2420
grn_get_version
GRN_API const char * grn_get_version(void)
grn_obj_refer_recursive
GRN_API grn_rc grn_obj_refer_recursive(grn_ctx *ctx, grn_obj *obj)
grn_fuzzy_search_optarg
struct _grn_fuzzy_search_optarg grn_fuzzy_search_optarg
Definition groonga.h:2006
grn_ctx_send
GRN_API unsigned int grn_ctx_send(grn_ctx *ctx, const char *str, unsigned int str_len, int flags)
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.
grn_bulk_get_size
GRN_API size_t grn_bulk_get_size(grn_ctx *ctx, grn_obj *bulk)
Return the size of the content of the given bulk.
grn_default_logger_get_rotate_threshold_size
GRN_API off_t grn_default_logger_get_rotate_threshold_size(void)
grn_ctx_get_rc
GRN_API grn_rc grn_ctx_get_rc(grn_ctx *ctx)
Return the return code of the last operation in the given context.
grn_proc_func
grn_obj * grn_proc_func(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)
Definition groonga.h:346
grn_plugin_func
grn_rc(* grn_plugin_func)(grn_ctx *ctx)
Definition groonga.h:1186
grn_set_lock_timeout
GRN_API grn_rc grn_set_lock_timeout(int timeout)
Set the lock timeout used during write operations.
grn_id
uint32_t grn_id
Definition groonga.h:44
grn_default_logger_get_path
GRN_API const char * grn_default_logger_get_path(void)
grn_query_logger_get_flags
GRN_API unsigned int grn_query_logger_get_flags(grn_ctx *ctx)
grn_ctx_pop_temporary_open_space
GRN_API grn_rc grn_ctx_pop_temporary_open_space(grn_ctx *ctx)
grn_obj_open
GRN_API grn_obj * grn_obj_open(grn_ctx *ctx, unsigned char type, grn_obj_flags flags, grn_id domain)
grn_ctx_push_temporary_open_space
GRN_API grn_rc grn_ctx_push_temporary_open_space(grn_ctx *ctx)
grn_default_query_logger_set_rotate_threshold_size
GRN_API void grn_default_query_logger_set_rotate_threshold_size(off_t threshold)
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_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_log_level_parse
GRN_API bool grn_log_level_parse(const char *string, grn_log_level *level)
grn_obj_id
GRN_API grn_id grn_obj_id(grn_ctx *ctx, grn_obj *obj)
Return the ID of an object.
GRN_API
#define GRN_API
Definition groonga.h:39
grn_text_f32toa
GRN_API grn_rc grn_text_f32toa(grn_ctx *ctx, grn_obj *bulk, float f)
grn_ctx_get_all_tokenizers
GRN_API grn_rc grn_ctx_get_all_tokenizers(grn_ctx *ctx, grn_obj *tokenizers_buffer)
grn_bulk_get_head
GRN_API const char * grn_bulk_get_head(grn_ctx *ctx, grn_obj *bulk)
Return the content of the given bulk.
grn_query_logger_remove_flags
GRN_API void grn_query_logger_remove_flags(grn_ctx *ctx, unsigned int flags)
grn_query_log_flags_parse
GRN_API bool grn_query_log_flags_parse(const char *string, int string_size, unsigned int *flags)
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.
grn_is_reference_count_enable
GRN_API bool grn_is_reference_count_enable(void)
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.
grn_text_time2rfc1123
GRN_API grn_rc grn_text_time2rfc1123(grn_ctx *ctx, grn_obj *bulk, int sec)
grn_obj_flush_recursive
GRN_API grn_rc grn_obj_flush_recursive(grn_ctx *ctx, grn_obj *obj)
grn_operator
grn_operator
Definition groonga.h:1190
GRN_OP_OBJ_SEARCH
@ GRN_OP_OBJ_SEARCH
Definition groonga.h:1264
GRN_OP_PREFIX
@ GRN_OP_PREFIX
Definition groonga.h:1255
GRN_OP_DELETE
@ GRN_OP_DELETE
Definition groonga.h:1244
GRN_OP_SUFFIX
@ GRN_OP_SUFFIX
Definition groonga.h:1256
GRN_OP_ADJUST
@ GRN_OP_ADJUST
Definition groonga.h:1250
GRN_OP_NOP
@ GRN_OP_NOP
Definition groonga.h:1193
GRN_OP_LCP
@ GRN_OP_LCP
Definition groonga.h:1252
GRN_OP_JUMP
@ GRN_OP_JUMP
Definition groonga.h:1215
GRN_OP_NOT
@ GRN_OP_NOT
Definition groonga.h:1249
GRN_OP_NEAR
@ GRN_OP_NEAR
Definition groonga.h:1230
GRN_OP_REGEXP
@ GRN_OP_REGEXP
Definition groonga.h:1272
GRN_OP_SLASH
@ GRN_OP_SLASH
Definition groonga.h:1242
GRN_OP_POP
@ GRN_OP_POP
Definition groonga.h:1192
GRN_OP_BITWISE_NOT
@ GRN_OP_BITWISE_NOT
Definition groonga.h:1221
GRN_OP_MATCH
@ GRN_OP_MATCH
Definition groonga.h:1229
GRN_OP_GEO_WITHINP8
@ GRN_OP_GEO_WITHINP8
Definition groonga.h:1263
GRN_OP_AND_NOT
@ GRN_OP_AND_NOT
Definition groonga.h:1199
GRN_OP_MINUS
@ GRN_OP_MINUS
Definition groonga.h:1240
GRN_OP_GREATER_EQUAL
@ GRN_OP_GREATER_EQUAL
Definition groonga.h:1227
GRN_OP_EQUAL
@ GRN_OP_EQUAL
Definition groonga.h:1222
GRN_OP_GREATER
@ GRN_OP_GREATER
Definition groonga.h:1225
GRN_OP_GET_REF
@ GRN_OP_GET_REF
Definition groonga.h:1196
GRN_OP_EXPR_GET_VAR
@ GRN_OP_EXPR_GET_VAR
Definition groonga.h:1265
GRN_OP_SHIFTRR_ASSIGN
@ GRN_OP_SHIFTRR_ASSIGN
Definition groonga.h:1211
GRN_OP_GEO_DISTANCE1
@ GRN_OP_GEO_DISTANCE1
Definition groonga.h:1257
GRN_OP_OR_ASSIGN
@ GRN_OP_OR_ASSIGN
Definition groonga.h:1214
GRN_OP_TABLE_GROUP
@ GRN_OP_TABLE_GROUP
Definition groonga.h:1269
GRN_OP_MOD
@ GRN_OP_MOD
Definition groonga.h:1243
GRN_OP_GET_MEMBER
@ GRN_OP_GET_MEMBER
Definition groonga.h:1271
GRN_OP_OR
@ GRN_OP_OR
Definition groonga.h:1202
GRN_OP_LESS_EQUAL
@ GRN_OP_LESS_EQUAL
Definition groonga.h:1226
GRN_OP_TERM_EXTRACT
@ GRN_OP_TERM_EXTRACT
Definition groonga.h:1235
GRN_OP_NEAR_NO_OFFSET
@ GRN_OP_NEAR_NO_OFFSET
Definition groonga.h:1231
GRN_OP_SLASH_ASSIGN
@ GRN_OP_SLASH_ASSIGN
Definition groonga.h:1205
GRN_OP_IN
@ GRN_OP_IN
Definition groonga.h:1228
GRN_OP_BITWISE_XOR
@ GRN_OP_BITWISE_XOR
Definition groonga.h:1219
GRN_OP_AND_ASSIGN
@ GRN_OP_AND_ASSIGN
Definition groonga.h:1212
GRN_OP_CJUMP
@ GRN_OP_CJUMP
Definition groonga.h:1216
GRN_OP_CALL
@ GRN_OP_CALL
Definition groonga.h:1194
GRN_OP_SHIFTR_ASSIGN
@ GRN_OP_SHIFTR_ASSIGN
Definition groonga.h:1210
GRN_OP_JSON_PUT
@ GRN_OP_JSON_PUT
Definition groonga.h:1270
GRN_OP_GEO_WITHINP5
@ GRN_OP_GEO_WITHINP5
Definition groonga.h:1261
GRN_OP_SHIFTL_ASSIGN
@ GRN_OP_SHIFTL_ASSIGN
Definition groonga.h:1209
GRN_OP_PLUS
@ GRN_OP_PLUS
Definition groonga.h:1239
GRN_OP_SHIFTRR
@ GRN_OP_SHIFTRR
Definition groonga.h:1238
GRN_OP_XOR_ASSIGN
@ GRN_OP_XOR_ASSIGN
Definition groonga.h:1213
GRN_OP_TABLE_SELECT
@ GRN_OP_TABLE_SELECT
Definition groonga.h:1267
GRN_OP_ORDERED_NEAR_PHRASE
@ GRN_OP_ORDERED_NEAR_PHRASE
Definition groonga.h:1276
GRN_OP_LESS
@ GRN_OP_LESS
Definition groonga.h:1224
GRN_OP_DECR
@ GRN_OP_DECR
Definition groonga.h:1246
GRN_OP_TABLE_CREATE
@ GRN_OP_TABLE_CREATE
Definition groonga.h:1266
GRN_OP_GET_VALUE
@ GRN_OP_GET_VALUE
Definition groonga.h:1197
GRN_OP_NEAR_PHRASE
@ GRN_OP_NEAR_PHRASE
Definition groonga.h:1275
GRN_OP_TABLE_SORT
@ GRN_OP_TABLE_SORT
Definition groonga.h:1268
GRN_OP_GEO_DISTANCE3
@ GRN_OP_GEO_DISTANCE3
Definition groonga.h:1259
GRN_OP_FUZZY
@ GRN_OP_FUZZY
Definition groonga.h:1273
GRN_OP_GEO_DISTANCE2
@ GRN_OP_GEO_DISTANCE2
Definition groonga.h:1258
GRN_OP_STAR_ASSIGN
@ GRN_OP_STAR_ASSIGN
Definition groonga.h:1204
GRN_OP_BITWISE_OR
@ GRN_OP_BITWISE_OR
Definition groonga.h:1218
GRN_OP_UNSPLIT
@ GRN_OP_UNSPLIT
Definition groonga.h:1254
GRN_OP_ASSIGN
@ GRN_OP_ASSIGN
Definition groonga.h:1203
GRN_OP_NOT_EQUAL
@ GRN_OP_NOT_EQUAL
Definition groonga.h:1223
GRN_OP_MOD_ASSIGN
@ GRN_OP_MOD_ASSIGN
Definition groonga.h:1206
GRN_OP_BITWISE_AND
@ GRN_OP_BITWISE_AND
Definition groonga.h:1220
GRN_OP_SIMILAR
@ GRN_OP_SIMILAR
Definition groonga.h:1234
GRN_OP_GEO_WITHINP6
@ GRN_OP_GEO_WITHINP6
Definition groonga.h:1262
GRN_OP_SHIFTR
@ GRN_OP_SHIFTR
Definition groonga.h:1237
GRN_OP_PUSH
@ GRN_OP_PUSH
Definition groonga.h:1191
GRN_OP_NEAR_PHRASE_PRODUCT
@ GRN_OP_NEAR_PHRASE_PRODUCT
Definition groonga.h:1277
GRN_OP_INCR_POST
@ GRN_OP_INCR_POST
Definition groonga.h:1247
GRN_OP_SHIFTL
@ GRN_OP_SHIFTL
Definition groonga.h:1236
GRN_OP_EXACT
@ GRN_OP_EXACT
Definition groonga.h:1251
GRN_OP_PARTIAL
@ GRN_OP_PARTIAL
Definition groonga.h:1253
GRN_OP_INCR
@ GRN_OP_INCR
Definition groonga.h:1245
GRN_OP_COMMA
@ GRN_OP_COMMA
Definition groonga.h:1217
GRN_OP_MINUS_ASSIGN
@ GRN_OP_MINUS_ASSIGN
Definition groonga.h:1208
GRN_OP_STAR
@ GRN_OP_STAR
Definition groonga.h:1241
GRN_OP_ORDERED_NEAR_PHRASE_PRODUCT
@ GRN_OP_ORDERED_NEAR_PHRASE_PRODUCT
Definition groonga.h:1278
GRN_OP_AND
@ GRN_OP_AND
Definition groonga.h:1198
GRN_OP_INTERN
@ GRN_OP_INTERN
Definition groonga.h:1195
GRN_OP_QUORUM
@ GRN_OP_QUORUM
Definition groonga.h:1274
GRN_OP_DECR_POST
@ GRN_OP_DECR_POST
Definition groonga.h:1248
GRN_OP_PLUS_ASSIGN
@ GRN_OP_PLUS_ASSIGN
Definition groonga.h:1207
GRN_OP_GEO_DISTANCE4
@ GRN_OP_GEO_DISTANCE4
Definition groonga.h:1260
grn_ctx_is_quitting
GRN_API bool grn_ctx_is_quitting(grn_ctx *ctx)
Check whether the given context received the quit command.
grn_obj_refer_recursive_dependent
GRN_API grn_rc grn_obj_refer_recursive_dependent(grn_ctx *ctx, grn_obj *obj)
grn_plugin_get_system_plugins_dir
GRN_API const char * grn_plugin_get_system_plugins_dir(void)
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_ATTRIBUTE_PRINTF(6)
grn_match_info
struct _grn_match_info grn_match_info
Definition groonga.h:2027
grn_plugin_get_names
GRN_API grn_rc grn_plugin_get_names(grn_ctx *ctx, grn_obj *names)
grn_text_urlenc
GRN_API grn_rc grn_text_urlenc(grn_ctx *ctx, grn_obj *buf, const char *str, size_t len)
grn_bulk_reinit
GRN_API grn_rc grn_bulk_reinit(grn_ctx *ctx, grn_obj *bulk, size_t size)
grn_obj_remove_flags
GRN_API grn_rc grn_obj_remove_flags(grn_ctx *ctx, grn_obj *obj, uint32_t flags)
grn_section
struct _grn_section grn_section
grn_text_benc
GRN_API grn_rc grn_text_benc(grn_ctx *ctx, grn_obj *bulk, unsigned int v)
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_ctx_get_n_workers
GRN_API int32_t grn_ctx_get_n_workers(grn_ctx *ctx)
grn_proc_get_hook_local_data
GRN_API void * grn_proc_get_hook_local_data(grn_ctx *ctx, grn_obj *exec_info)
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_query_logger_put
GRN_API void grn_query_logger_put(grn_ctx *ctx, unsigned int flag, const char *mark, const char *format,...) GRN_ATTRIBUTE_PRINTF(4)
grn_bool
bool grn_bool
Definition groonga.h:46
grn_snip_get_normalizer
GRN_API grn_obj * grn_snip_get_normalizer(grn_ctx *ctx, grn_obj *snip)
grn_logger_info_set
GRN_API grn_rc grn_logger_info_set(grn_ctx *ctx, const grn_logger_info *info)
grn_default_logger_set_rotate_threshold_size
GRN_API void grn_default_logger_set_rotate_threshold_size(off_t threshold)
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_default_logger_set_path
GRN_API void grn_default_logger_set_path(const char *path)
grn_ctx_remove_by_id
GRN_API grn_rc grn_ctx_remove_by_id(grn_ctx *ctx, grn_id id, uint32_t flags)
grn_text_code_point
GRN_API grn_rc grn_text_code_point(grn_ctx *ctx, grn_obj *buffer, uint32_t code_point)
grn_query_logger_pass
GRN_API bool grn_query_logger_pass(grn_ctx *ctx, unsigned int flag)
grn_logger
struct _grn_logger grn_logger
Definition groonga.h:2435
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)
grn_unset_variable
GRN_API grn_rc grn_unset_variable(const char *name, int name_size)
grn_ctx_pop
GRN_API grn_obj * grn_ctx_pop(grn_ctx *ctx)
grn_get_version_major
GRN_API uint32_t grn_get_version_major(void)
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 conte...
grn_ctx_get_force_match_escalation
GRN_API bool grn_ctx_get_force_match_escalation(grn_ctx *ctx)
grn_proc_set_is_stable
GRN_API grn_rc grn_proc_set_is_stable(grn_ctx *ctx, grn_obj *proc, bool is_stable)
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.
grn_log_level
grn_log_level
Definition groonga.h:192
GRN_LOG_WARNING
@ GRN_LOG_WARNING
Definition groonga.h:198
GRN_LOG_CRIT
@ GRN_LOG_CRIT
Definition groonga.h:196
GRN_LOG_NOTICE
@ GRN_LOG_NOTICE
Definition groonga.h:199
GRN_LOG_ALERT
@ GRN_LOG_ALERT
Definition groonga.h:195
GRN_LOG_DEBUG
@ GRN_LOG_DEBUG
Definition groonga.h:201
GRN_LOG_DUMP
@ GRN_LOG_DUMP
Definition groonga.h:202
GRN_LOG_ERROR
@ GRN_LOG_ERROR
Definition groonga.h:197
GRN_LOG_INFO
@ GRN_LOG_INFO
Definition groonga.h:200
GRN_LOG_EMERG
@ GRN_LOG_EMERG
Definition groonga.h:194
grn_snip_set_normalizer
GRN_API grn_rc grn_snip_set_normalizer(grn_ctx *ctx, grn_obj *snip, grn_obj *normalizer)
grn_bulk_detach
GRN_API char * grn_bulk_detach(grn_ctx *ctx, grn_obj *bulk)
GRN_ATTRIBUTE_PRINTF
#define GRN_ATTRIBUTE_PRINTF(fmt_pos)
Definition groonga.h:2467
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
struct _grn_obj grn_obj
The generic Groonga object type.
Definition groonga.h:310
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.
grn_recv_handler_func
void(* grn_recv_handler_func)(grn_ctx *ctx, int flags, void *user_data)
Definition groonga.h:2826
grn_log_level_to_string
GRN_API const char * grn_log_level_to_string(grn_log_level level)
grn_bulk_write
GRN_API grn_rc grn_bulk_write(grn_ctx *ctx, grn_obj *bulk, const char *str, 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_set_int_handler
GRN_API grn_rc grn_set_int_handler(void)
grn_get_version_micro
GRN_API uint32_t grn_get_version_micro(void)
grn_set_default_encoding
GRN_API grn_rc grn_set_default_encoding(grn_encoding encoding)
Set the default encoding.
grn_get_default_n_workers
GRN_API int32_t grn_get_default_n_workers(void)
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.
grn_text_printfv
GRN_API grn_rc grn_text_printfv(grn_ctx *ctx, grn_obj *bulk, const char *format, va_list args)
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.
grn_text_printf
GRN_API grn_rc grn_text_printf(grn_ctx *ctx, grn_obj *bulk, const char *format,...) GRN_ATTRIBUTE_PRINTF(3)
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_close_func
void(* grn_close_func)(grn_ctx *ctx, void *data)
Definition groonga.h:337
grn_set_default_command_version
GRN_API grn_rc grn_set_default_command_version(grn_command_version version)
Set default command version.
grn_snip_get_normalizers
GRN_API grn_obj * grn_snip_get_normalizers(grn_ctx *ctx, grn_obj *snip)
grn_get_version_minor
GRN_API uint32_t grn_get_version_minor(void)
grn_get_package_label
GRN_API const char * grn_get_package_label(void)
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.
grn_get_lock_timeout
GRN_API int grn_get_lock_timeout(void)
Retrieve the current lock timeout.
grn_plugin_get_ruby_suffix
GRN_API const char * grn_plugin_get_ruby_suffix(void)
grn_builtin_type
grn_builtin_type
Definition groonga.h:1104
GRN_DB_SHORT_BINARY
@ GRN_DB_SHORT_BINARY
Definition groonga.h:1126
GRN_DB_BINARY
@ GRN_DB_BINARY
Definition groonga.h:1127
GRN_DB_UINT8
@ GRN_DB_UINT8
Definition groonga.h:1110
GRN_DB_OBJECT
@ GRN_DB_OBJECT
Definition groonga.h:1107
GRN_DB_INT8
@ GRN_DB_INT8
Definition groonga.h:1109
GRN_DB_TEXT
@ GRN_DB_TEXT
Definition groonga.h:1120
GRN_DB_LONG_BINARY
@ GRN_DB_LONG_BINARY
Definition groonga.h:1128
GRN_DB_TIME
@ GRN_DB_TIME
Definition groonga.h:1118
GRN_DB_JSON
@ GRN_DB_JSON
Definition groonga.h:1129
GRN_DB_VOID
@ GRN_DB_VOID
Definition groonga.h:1105
GRN_DB_LONG_TEXT
@ GRN_DB_LONG_TEXT
Definition groonga.h:1121
GRN_DB_DB
@ GRN_DB_DB
Definition groonga.h:1106
GRN_DB_SHORT_TEXT
@ GRN_DB_SHORT_TEXT
Definition groonga.h:1119
GRN_DB_BFLOAT16
@ GRN_DB_BFLOAT16
Definition groonga.h:1125
GRN_DB_UINT16
@ GRN_DB_UINT16
Definition groonga.h:1112
GRN_DB_INT32
@ GRN_DB_INT32
Definition groonga.h:1113
GRN_DB_BOOL
@ GRN_DB_BOOL
Definition groonga.h:1108
GRN_DB_INT16
@ GRN_DB_INT16
Definition groonga.h:1111
GRN_DB_FLOAT32
@ GRN_DB_FLOAT32
Definition groonga.h:1124
GRN_DB_TOKYO_GEO_POINT
@ GRN_DB_TOKYO_GEO_POINT
Definition groonga.h:1122
GRN_DB_UINT32
@ GRN_DB_UINT32
Definition groonga.h:1114
GRN_DB_UINT64
@ GRN_DB_UINT64
Definition groonga.h:1116
GRN_DB_INT64
@ GRN_DB_INT64
Definition groonga.h:1115
GRN_DB_FLOAT
@ GRN_DB_FLOAT
Definition groonga.h:1117
GRN_DB_WGS84_GEO_POINT
@ GRN_DB_WGS84_GEO_POINT
Definition groonga.h:1123
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_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.
grn_get_memory_map_size
GRN_API size_t grn_get_memory_map_size(void)
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.
grn_set_abrt_handler
GRN_API grn_rc grn_set_abrt_handler(void)
grn_set_reference_count_enable
GRN_API grn_rc grn_set_reference_count_enable(bool enable)
grn_obj_flush
GRN_API grn_rc grn_obj_flush(grn_ctx *ctx, grn_obj *obj)
grn_table_delete_optarg
struct _grn_table_delete_optarg grn_table_delete_optarg
Definition groonga.h:3432
grn_proc_get_ctx_local_data
GRN_API void * grn_proc_get_ctx_local_data(grn_ctx *ctx, grn_obj *exec_info)
grn_builtin_tokenizer
grn_builtin_tokenizer
Definition groonga.h:1132
GRN_DB_TRIGRAM
@ GRN_DB_TRIGRAM
Definition groonga.h:1137
GRN_DB_UNIGRAM
@ GRN_DB_UNIGRAM
Definition groonga.h:1135
GRN_DB_BIGRAM
@ GRN_DB_BIGRAM
Definition groonga.h:1136
GRN_DB_MECAB
@ GRN_DB_MECAB
Definition groonga.h:1133
GRN_DB_DELIMIT
@ GRN_DB_DELIMIT
Definition groonga.h:1134
grn_ctx_recv
GRN_API grn_rc grn_ctx_recv(grn_ctx *ctx, char **str, unsigned int *str_len, int *flags)
grn_obj_remove_force
GRN_API grn_rc grn_obj_remove_force(grn_ctx *ctx, const char *name, int name_size)
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.
grn_ctx_db
GRN_API grn_obj * grn_ctx_db(grn_ctx *ctx)
Retrieve the database that the context is using.
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.
grn_hook_entry
grn_hook_entry
Definition groonga.h:2106
GRN_HOOK_INSERT
@ GRN_HOOK_INSERT
Hooked on insertion.
Definition groonga.h:2112
GRN_HOOK_SELECT
@ GRN_HOOK_SELECT
Definition groonga.h:2117
GRN_HOOK_DELETE
@ GRN_HOOK_DELETE
Hooked on deletion.
Definition groonga.h:2114
GRN_HOOK_SET
@ GRN_HOOK_SET
Hooked on update.
Definition groonga.h:2108
GRN_HOOK_GET
@ GRN_HOOK_GET
Hooked on getting.
Definition groonga.h:2110
grn_obj_flush_recursive_dependent
GRN_API grn_rc grn_obj_flush_recursive_dependent(grn_ctx *ctx, grn_obj *obj)
grn_obj_unlink
GRN_API grn_rc grn_obj_unlink(grn_ctx *ctx, grn_obj *obj)
Unlink an object.
grn_ctx_open
GRN_API grn_ctx * grn_ctx_open(int flags)
Open the context.
grn_ctx_set_n_workers
GRN_API grn_rc grn_ctx_set_n_workers(grn_ctx *ctx, int32_t n_workers)
grn_content_type
grn_content_type
The input/output content format.
Definition groonga.h:225
GRN_CONTENT_APACHE_ARROW
@ GRN_CONTENT_APACHE_ARROW
Definition groonga.h:252
GRN_CONTENT_TSV
@ GRN_CONTENT_TSV
Definition groonga.h:232
GRN_CONTENT_GROONGA_COMMAND_LIST
@ GRN_CONTENT_GROONGA_COMMAND_LIST
Definition groonga.h:244
GRN_CONTENT_XML
@ GRN_CONTENT_XML
Definition groonga.h:236
GRN_CONTENT_MSGPACK
@ GRN_CONTENT_MSGPACK
Definition groonga.h:242
GRN_CONTENT_NONE
@ GRN_CONTENT_NONE
Definition groonga.h:230
GRN_CONTENT_JSON
@ GRN_CONTENT_JSON
Definition groonga.h:234
grn_text_lltoa
GRN_API grn_rc grn_text_lltoa(grn_ctx *ctx, grn_obj *bulk, long long int i)
grn_set_default_n_workers
GRN_API grn_rc grn_set_default_n_workers(int32_t n_workers)
grn_logger_pass
GRN_API bool grn_logger_pass(grn_ctx *ctx, grn_log_level level)
grn_table_flags
uint32_t grn_table_flags
Definition groonga.h:720
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.
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.
grn_text_itoa
GRN_API grn_rc grn_text_itoa(grn_ctx *ctx, grn_obj *bulk, int i)
grn_obj_unref
GRN_API void grn_obj_unref(grn_ctx *ctx, grn_obj *obj)
grn_default_query_logger_set_path
GRN_API void grn_default_query_logger_set_path(const char *path)
grn_get_default_encoding
GRN_API grn_encoding grn_get_default_encoding(void)
grn_column_flags
uint32_t grn_column_flags
Definition groonga.h:721
GRN_CTX_MSGSIZE
#define GRN_CTX_MSGSIZE
Definition groonga.h:334
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_obj_reinit
GRN_API grn_rc grn_obj_reinit(grn_ctx *ctx, grn_obj *obj, grn_id domain, uint8_t flags)
Reinitialize an object.
grn_bulk_truncate
GRN_API grn_rc grn_bulk_truncate(grn_ctx *ctx, grn_obj *bulk, size_t len)
grn_plugin_unregister_by_path
GRN_API grn_rc grn_plugin_unregister_by_path(grn_ctx *ctx, const char *path)
grn_text_vprintf
GRN_API grn_rc grn_text_vprintf(grn_ctx *ctx, grn_obj *bulk, const char *format, va_list args)
grn_text_esc
GRN_API grn_rc grn_text_esc(grn_ctx *ctx, grn_obj *bulk, const char *s, size_t len)
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_ctx_is_opened
GRN_API bool grn_ctx_is_opened(grn_ctx *ctx, grn_id id)
grn_is_back_trace_enable
GRN_API bool grn_is_back_trace_enable(void)
grn_slow_log_pop
GRN_API double grn_slow_log_pop(grn_ctx *ctx)
grn_query_logger_reopen
GRN_API void grn_query_logger_reopen(grn_ctx *ctx)
grn_ctx_use
GRN_API grn_rc grn_ctx_use(grn_ctx *ctx, grn_obj *db)
Set the database that the context is using.
grn_ctx_push
GRN_API grn_rc grn_ctx_push(grn_ctx *ctx, grn_obj *obj)
grn_plugin_get_suffix
GRN_API const char * grn_plugin_get_suffix(void)
grn_ctx_init
GRN_API grn_rc grn_ctx_init(grn_ctx *ctx, int flags)
Initialize the context.
grn_get_default_match_escalation_threshold
GRN_API int64_t grn_get_default_match_escalation_threshold(void)
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.
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.
grn_obj_remove
GRN_API grn_rc grn_obj_remove(grn_ctx *ctx, grn_obj *obj)
Remove the specified object.
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_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_proc_is_stable
GRN_API bool grn_proc_is_stable(grn_ctx *ctx, grn_obj *proc)
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_obj_clear_lock
GRN_API grn_rc grn_obj_clear_lock(grn_ctx *ctx, grn_obj *obj)
Forcefully clear locks on an object.
grn_bulk_set
GRN_API void grn_bulk_set(grn_ctx *ctx, grn_obj *bulk, const char *content, size_t size)
Set the content of the given bulk.
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.
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.
grn_slow_log_push
GRN_API grn_rc grn_slow_log_push(grn_ctx *ctx)
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.
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.
grn_bulk_space
GRN_API grn_rc grn_bulk_space(grn_ctx *ctx, grn_obj *bulk, size_t len)
grn_ctx_get_variable
GRN_API void * grn_ctx_get_variable(grn_ctx *ctx, const char *name, int name_size)
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_fin
GRN_API grn_rc grn_fin(void)
grn_ctx_remove
GRN_API grn_rc grn_ctx_remove(grn_ctx *ctx, const char *name, int name_size, uint32_t flags)
grn_query_logger_set_flags
GRN_API void grn_query_logger_set_flags(grn_ctx *ctx, unsigned int flags)
grn_ctx_get_all_types
GRN_API grn_rc grn_ctx_get_all_types(grn_ctx *ctx, grn_obj *types_buffer)
grn_get_default_command_version
GRN_API grn_command_version grn_get_default_command_version(void)
grn_init
GRN_API grn_rc grn_init(void)
grn_text_lltob32h
GRN_API grn_rc grn_text_lltob32h(grn_ctx *ctx, grn_obj *bulk, long long int i)
grn_slow_log_is_slow
GRN_API bool grn_slow_log_is_slow(grn_ctx *ctx, double elapsed_time)
grn_query_logger_set
GRN_API grn_rc grn_query_logger_set(grn_ctx *ctx, const grn_query_logger *logger)
grn_ctx_get_all_normalizers
GRN_API grn_rc grn_ctx_get_all_normalizers(grn_ctx *ctx, grn_obj *normalizers_buffer)
grn_hook_entry_to_string
GRN_API const char * grn_hook_entry_to_string(grn_hook_entry entry)
grn_obj_header
struct _grn_obj_header grn_obj_header
grn_obj_refer
GRN_API grn_rc grn_obj_refer(grn_ctx *ctx, grn_obj *obj)
grn_ctx_get_command_version
GRN_API grn_command_version grn_ctx_get_command_version(grn_ctx *ctx)
grn_bulk_rewind
GRN_API void grn_bulk_rewind(grn_ctx *ctx, grn_obj *bulk)
Remove all content of the given bulk.
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.
grn_logger_set
GRN_API grn_rc grn_logger_set(grn_ctx *ctx, const grn_logger *logger)
grn_query_logger_add_flags
GRN_API void grn_query_logger_add_flags(grn_ctx *ctx, unsigned int flags)
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.
grn_encoding
grn_encoding
Definition groonga.h:163
GRN_ENC_EUC_JP
@ GRN_ENC_EUC_JP
EUC-JP (2).
Definition groonga.h:170
GRN_ENC_UTF8
@ GRN_ENC_UTF8
UTF-8 (3).
Definition groonga.h:172
GRN_ENC_LATIN1
@ GRN_ENC_LATIN1
Latin-1 (5).
Definition groonga.h:176
GRN_ENC_DEFAULT
@ GRN_ENC_DEFAULT
Definition groonga.h:166
GRN_ENC_KOI8R
@ GRN_ENC_KOI8R
KOI8-R (6).
Definition groonga.h:178
GRN_ENC_SJIS
@ GRN_ENC_SJIS
Shift_JIS (4).
Definition groonga.h:174
GRN_ENC_NONE
@ GRN_ENC_NONE
Process strings as binary data (1).
Definition groonga.h:168
GRN_LOG_NONE
#define GRN_LOG_NONE
Definition groonga.h:2403
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_obj_remove_dependent
GRN_API grn_rc grn_obj_remove_dependent(grn_ctx *ctx, grn_obj *obj)
grn_text_ftoa
GRN_API grn_rc grn_text_ftoa(grn_ctx *ctx, grn_obj *bulk, double d)
grn_plugin_unregister
GRN_API grn_rc grn_plugin_unregister(grn_ctx *ctx, const char *name)
grn_table_cursor
grn_obj grn_table_cursor
Definition groonga.h:1188
GRN_PLUGIN_ERROR
#define GRN_PLUGIN_ERROR(ctx, error_code,...)
Definition plugin.h:145
_grn_ctx_info
Definition groonga.h:3413
_grn_ctx_info::com_status
unsigned int com_status
Definition groonga.h:3415
_grn_ctx_info::fd
int fd
Definition groonga.h:3414
_grn_ctx_info::outbuf
grn_obj * outbuf
Definition groonga.h:3416
_grn_ctx_info::stat
unsigned char stat
Definition groonga.h:3417
_grn_ctx
Definition groonga.h:351
_grn_ctx::ntrace
unsigned char ntrace
Definition groonga.h:355
_grn_ctx::impl
struct _grn_ctx_impl * impl
Definition groonga.h:367
_grn_ctx::trace
void * trace[16]
Definition groonga.h:368
_grn_ctx::errfile
const char * errfile
Definition groonga.h:365
_grn_ctx::errlvl
unsigned char errlvl
Definition groonga.h:356
_grn_ctx::seqno2
unsigned int seqno2
Definition groonga.h:360
_grn_ctx::errline
unsigned int errline
Definition groonga.h:361
_grn_ctx::subno
unsigned int subno
Definition groonga.h:359
_grn_ctx::seqno
unsigned int seqno
Definition groonga.h:358
_grn_ctx::errbuf
char errbuf[GRN_CTX_MSGSIZE]
Definition groonga.h:369
_grn_ctx::encoding
grn_encoding encoding
Definition groonga.h:354
_grn_ctx::flags
int flags
Definition groonga.h:353
_grn_ctx::stat
unsigned char stat
Definition groonga.h:357
_grn_ctx::errfunc
const char * errfunc
Definition groonga.h:366
_grn_ctx::rc
grn_rc rc
Definition groonga.h:352
_grn_ctx::next
grn_ctx * next
Definition groonga.h:364
_grn_ctx::user_data
grn_user_data user_data
Definition groonga.h:362
_grn_ctx::prev
grn_ctx * prev
Definition groonga.h:363
_grn_fuzzy_search_optarg
Definition groonga.h:2008
_grn_fuzzy_search_optarg::max_distance_ratio
float max_distance_ratio
Definition groonga.h:2021
_grn_fuzzy_search_optarg::flags
uint32_t flags
Definition groonga.h:2015
_grn_fuzzy_search_optarg::max_expansion
uint32_t max_expansion
Definition groonga.h:2012
_grn_fuzzy_search_optarg::prefix_match_size
uint32_t prefix_match_size
Definition groonga.h:2014
_grn_fuzzy_search_optarg::prefix_length
uint32_t prefix_length
Definition groonga.h:2018
_grn_fuzzy_search_optarg::max_distance
uint32_t max_distance
Definition groonga.h:2009
_grn_index_datum
Definition groonga.h:2208
_grn_index_datum::index
grn_obj * index
Definition groonga.h:2209
_grn_index_datum::section
unsigned int section
Definition groonga.h:2210
_grn_logger_info
Definition groonga.h:2423
_grn_logger_info::func_arg
void * func_arg
Definition groonga.h:2428
_grn_logger_info::func
void(* func)(int, const char *, const char *, const char *, const char *, void *)
Definition groonga.h:2426
_grn_logger_info::max_level
grn_log_level max_level
Definition groonga.h:2424
_grn_logger_info::flags
int flags
Definition groonga.h:2425
_grn_logger
Definition groonga.h:2437
_grn_logger::user_data
void * user_data
Definition groonga.h:2440
_grn_logger::max_level
grn_log_level max_level
Definition groonga.h:2438
_grn_logger::fin
void(* fin)(grn_ctx *ctx, void *user_data)
Definition groonga.h:2449
_grn_logger::flags
int flags
Definition groonga.h:2439
_grn_logger::log
void(* log)(grn_ctx *ctx, grn_log_level level, const char *timestamp, const char *title, const char *message, const char *location, void *user_data)
Definition groonga.h:2441
_grn_logger::reopen
void(* reopen)(grn_ctx *ctx, void *user_data)
Definition groonga.h:2448
_grn_match_info
Definition groonga.h:2029
_grn_match_info::min
grn_id min
Definition groonga.h:2031
_grn_match_info::flags
int flags
Definition groonga.h:2030
_grn_obj_header
Definition groonga.h:953
_grn_obj_header::type
uint8_t type
Definition groonga.h:954
_grn_obj_header::domain
grn_id domain
Definition groonga.h:957
_grn_obj_header::impl_flags
uint8_t impl_flags
Definition groonga.h:955
_grn_obj_header::flags
grn_obj_flags flags
Definition groonga.h:956
_grn_obj
Definition groonga.h:960
_grn_obj::v
struct _grn_obj::@036047341171357341330246173323011302022226155262::@014143152111314361257106341353313301344154362306 v
_grn_obj::tail
char * tail
Definition groonga.h:966
_grn_obj::sections
grn_section * sections
Definition groonga.h:970
_grn_obj::curr
char * curr
Definition groonga.h:965
_grn_obj::u
union _grn_obj::@036047341171357341330246173323011302022226155262 u
_grn_obj::b
struct _grn_obj::@036047341171357341330246173323011302022226155262::@075342217235065136334176170202275324111152337131 b
_grn_obj::body
grn_obj * body
Definition groonga.h:969
_grn_obj::n_sections
uint32_t n_sections
Definition groonga.h:971
_grn_obj::header
grn_obj_header header
Definition groonga.h:961
_grn_obj::head
char * head
Definition groonga.h:964
_grn_query_logger
Definition groonga.h:2574
_grn_query_logger::reopen
void(* reopen)(grn_ctx *ctx, void *user_data)
Definition groonga.h:2583
_grn_query_logger::log
void(* log)(grn_ctx *ctx, unsigned int flag, const char *timestamp, const char *info, const char *message, void *user_data)
Definition groonga.h:2577
_grn_query_logger::fin
void(* fin)(grn_ctx *ctx, void *user_data)
Definition groonga.h:2584
_grn_query_logger::flags
unsigned int flags
Definition groonga.h:2575
_grn_query_logger::user_data
void * user_data
Definition groonga.h:2576
_grn_search_optarg
Definition groonga.h:2036
_grn_search_optarg::vector_size
int vector_size
Definition groonga.h:2041
_grn_search_optarg::additional_last_interval
int additional_last_interval
Definition groonga.h:2050
_grn_search_optarg::scorer
grn_obj * scorer
Definition groonga.h:2044
_grn_search_optarg::start_position
int32_t * start_position
Definition groonga.h:2056
_grn_search_optarg::max_size
int max_size
Definition groonga.h:2043
_grn_search_optarg::weight_float
float weight_float
Definition groonga.h:2052
_grn_search_optarg::scorer_args_expr_offset
unsigned int scorer_args_expr_offset
Definition groonga.h:2046
_grn_search_optarg::max_interval
int max_interval
Definition groonga.h:2039
_grn_search_optarg::quorum_threshold
int quorum_threshold
Definition groonga.h:2049
_grn_search_optarg::query_options
grn_obj * query_options
Definition groonga.h:2053
_grn_search_optarg::mode
grn_operator mode
Definition groonga.h:2037
_grn_search_optarg::weight_vector
int * weight_vector
Definition groonga.h:2040
_grn_search_optarg::scorer_args_expr
grn_obj * scorer_args_expr
Definition groonga.h:2045
_grn_search_optarg::match_info
grn_match_info match_info
Definition groonga.h:2048
_grn_search_optarg::weight_vector_float
float * weight_vector_float
Definition groonga.h:2051
_grn_search_optarg::proc
grn_obj * proc
Definition groonga.h:2042
_grn_search_optarg::fuzzy
grn_fuzzy_search_optarg fuzzy
Definition groonga.h:2047
_grn_search_optarg::max_element_intervals
grn_obj * max_element_intervals
Definition groonga.h:2054
_grn_search_optarg::similarity_threshold
int similarity_threshold
Definition groonga.h:2038
_grn_search_optarg::query_domain
grn_id * query_domain
Definition groonga.h:2057
_grn_search_optarg::min_interval
int * min_interval
Definition groonga.h:2055
_grn_section
Definition groonga.h:946
_grn_section::weight
float weight
Definition groonga.h:949
_grn_section::domain
grn_id domain
Definition groonga.h:950
_grn_section::offset
uint32_t offset
Definition groonga.h:947
_grn_section::length
uint32_t length
Definition groonga.h:948
_grn_snip_mapping
Definition groonga.h:2341
_grn_snip_mapping::dummy
void * dummy
Definition groonga.h:2342
_grn_table_delete_optarg
Definition groonga.h:3434
_grn_table_delete_optarg::func_arg
void * func_arg
Definition groonga.h:3437
_grn_table_delete_optarg::flags
int flags
Definition groonga.h:3435
_grn_table_delete_optarg::func
int(* func)(grn_ctx *ctx, grn_obj *, grn_id, void *)
Definition groonga.h:3436
_grn_table_scan_hit
Definition groonga.h:3440
_grn_table_scan_hit::id
grn_id id
Definition groonga.h:3441
_grn_table_scan_hit::length
unsigned int length
Definition groonga.h:3443
_grn_table_scan_hit::offset
unsigned int offset
Definition groonga.h:3442
grn_expr_var
Definition groonga.h:1180
grn_expr_var::name
const char * name
Definition groonga.h:1181
grn_expr_var::value
grn_obj value
Definition groonga.h:1183
grn_expr_var::name_size
unsigned int name_size
Definition groonga.h:1182
grn_timeval
Definition groonga.h:3446
grn_timeval::tv_nsec
int32_t tv_nsec
Definition groonga.h:3448
grn_timeval::tv_sec
int64_t tv_sec
Definition groonga.h:3447
grn_user_data
Definition groonga.h:339
grn_user_data::int_value
int int_value
Definition groonga.h:340
grn_user_data::id
grn_id id
Definition groonga.h:341
grn_user_data::ptr
void * ptr
Definition groonga.h:342