Groonga 3.0.9 Source Code Document
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
groonga.h
Go to the documentation of this file.
1 /*
2  Copyright(C) 2009-2013 Brazil
3 
4  This library is free software; you can redistribute it and/or
5  modify it under the terms of the GNU Lesser General Public
6  License as published by the Free Software Foundation; either
7  version 2.1 of the License, or (at your option) any later version.
8 
9  This library is distributed in the hope that it will be useful,
10  but WITHOUT ANY WARRANTY; without even the implied warranty of
11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  Lesser General Public License for more details.
13 
14  You should have received a copy of the GNU Lesser General Public
15  License along with this library; if not, write to the Free Software
16  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18 #ifndef GROONGA_H
19 #define GROONGA_H
20 
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24 
25 #ifndef GRN_API
26 #if defined(_WIN32) || defined(_WIN64)
27 #define GRN_API __declspec(dllimport)
28 #else
29 #define GRN_API
30 #endif /* defined(_WIN32) || defined(_WIN64) */
31 #endif /* GRN_API */
32 
33 typedef unsigned int grn_id;
34 typedef unsigned char grn_bool;
35 
36 #define GRN_ID_NIL (0x00)
37 #define GRN_ID_MAX (0x3fffffff)
38 
39 #define GRN_TRUE (1)
40 #define GRN_FALSE (0)
41 
42 typedef enum {
43  GRN_SUCCESS = 0,
44  GRN_END_OF_DATA = 1,
45  GRN_UNKNOWN_ERROR = -1,
46  GRN_OPERATION_NOT_PERMITTED = -2,
47  GRN_NO_SUCH_FILE_OR_DIRECTORY = -3,
48  GRN_NO_SUCH_PROCESS = -4,
49  GRN_INTERRUPTED_FUNCTION_CALL = -5,
50  GRN_INPUT_OUTPUT_ERROR = -6,
51  GRN_NO_SUCH_DEVICE_OR_ADDRESS = -7,
52  GRN_ARG_LIST_TOO_LONG = -8,
53  GRN_EXEC_FORMAT_ERROR = -9,
54  GRN_BAD_FILE_DESCRIPTOR = -10,
55  GRN_NO_CHILD_PROCESSES = -11,
56  GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = -12,
57  GRN_NOT_ENOUGH_SPACE = -13,
58  GRN_PERMISSION_DENIED = -14,
59  GRN_BAD_ADDRESS = -15,
60  GRN_RESOURCE_BUSY = -16,
61  GRN_FILE_EXISTS = -17,
62  GRN_IMPROPER_LINK = -18,
63  GRN_NO_SUCH_DEVICE = -19,
64  GRN_NOT_A_DIRECTORY = -20,
65  GRN_IS_A_DIRECTORY = -21,
66  GRN_INVALID_ARGUMENT = -22,
67  GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = -23,
68  GRN_TOO_MANY_OPEN_FILES = -24,
69  GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = -25,
70  GRN_FILE_TOO_LARGE = -26,
71  GRN_NO_SPACE_LEFT_ON_DEVICE = -27,
72  GRN_INVALID_SEEK = -28,
73  GRN_READ_ONLY_FILE_SYSTEM = -29,
74  GRN_TOO_MANY_LINKS = -30,
75  GRN_BROKEN_PIPE = -31,
76  GRN_DOMAIN_ERROR = -32,
77  GRN_RESULT_TOO_LARGE = -33,
78  GRN_RESOURCE_DEADLOCK_AVOIDED = -34,
79  GRN_NO_MEMORY_AVAILABLE = -35,
80  GRN_FILENAME_TOO_LONG = -36,
81  GRN_NO_LOCKS_AVAILABLE = -37,
82  GRN_FUNCTION_NOT_IMPLEMENTED = -38,
83  GRN_DIRECTORY_NOT_EMPTY = -39,
84  GRN_ILLEGAL_BYTE_SEQUENCE = -40,
85  GRN_SOCKET_NOT_INITIALIZED = -41,
86  GRN_OPERATION_WOULD_BLOCK = -42,
87  GRN_ADDRESS_IS_NOT_AVAILABLE = -43,
88  GRN_NETWORK_IS_DOWN = -44,
89  GRN_NO_BUFFER = -45,
90  GRN_SOCKET_IS_ALREADY_CONNECTED = -46,
91  GRN_SOCKET_IS_NOT_CONNECTED = -47,
92  GRN_SOCKET_IS_ALREADY_SHUTDOWNED = -48,
93  GRN_OPERATION_TIMEOUT = -49,
94  GRN_CONNECTION_REFUSED = -50,
95  GRN_RANGE_ERROR = -51,
96  GRN_TOKENIZER_ERROR = -52,
97  GRN_FILE_CORRUPT = -53,
98  GRN_INVALID_FORMAT = -54,
99  GRN_OBJECT_CORRUPT = -55,
100  GRN_TOO_MANY_SYMBOLIC_LINKS = -56,
101  GRN_NOT_SOCKET = -57,
102  GRN_OPERATION_NOT_SUPPORTED = -58,
103  GRN_ADDRESS_IS_IN_USE = -59,
104  GRN_ZLIB_ERROR = -60,
105  GRN_LZO_ERROR = -61,
106  GRN_STACK_OVER_FLOW = -62,
107  GRN_SYNTAX_ERROR = -63,
108  GRN_RETRY_MAX = -64,
109  GRN_INCOMPATIBLE_FILE_FORMAT = -65,
110  GRN_UPDATE_NOT_ALLOWED = -66,
111  GRN_TOO_SMALL_OFFSET = -67,
112  GRN_TOO_LARGE_OFFSET = -68,
113  GRN_TOO_SMALL_LIMIT = -69,
114  GRN_CAS_ERROR = -70,
115  GRN_UNSUPPORTED_COMMAND_VERSION = -71,
116  GRN_NORMALIZER_ERROR = -72,
117 } grn_rc;
118 
119 GRN_API grn_rc grn_init(void);
120 GRN_API grn_rc grn_fin(void);
121 
122 typedef enum {
123  GRN_ENC_DEFAULT = 0,
124  GRN_ENC_NONE,
125  GRN_ENC_EUC_JP,
126  GRN_ENC_UTF8,
127  GRN_ENC_SJIS,
128  GRN_ENC_LATIN1,
129  GRN_ENC_KOI8R
130 } grn_encoding;
131 
132 typedef enum {
133  GRN_COMMAND_VERSION_DEFAULT = 0,
134  GRN_COMMAND_VERSION_1,
135  GRN_COMMAND_VERSION_2
136 } grn_command_version;
137 
138 #define GRN_COMMAND_VERSION_MIN GRN_COMMAND_VERSION_1
139 #define GRN_COMMAND_VERSION_STABLE GRN_COMMAND_VERSION_1
140 #define GRN_COMMAND_VERSION_MAX GRN_COMMAND_VERSION_2
141 
142 typedef enum {
143  GRN_LOG_NONE = 0,
144  GRN_LOG_EMERG,
145  GRN_LOG_ALERT,
146  GRN_LOG_CRIT,
147  GRN_LOG_ERROR,
148  GRN_LOG_WARNING,
149  GRN_LOG_NOTICE,
150  GRN_LOG_INFO,
151  GRN_LOG_DEBUG,
152  GRN_LOG_DUMP
153 } grn_log_level;
154 
155 /* query log flags */
156 #define GRN_QUERY_LOG_NONE (0x00)
157 #define GRN_QUERY_LOG_COMMAND (0x01<<0)
158 #define GRN_QUERY_LOG_RESULT_CODE (0x01<<1)
159 #define GRN_QUERY_LOG_DESTINATION (0x01<<2)
160 #define GRN_QUERY_LOG_CACHE (0x01<<3)
161 #define GRN_QUERY_LOG_SIZE (0x01<<4)
162 #define GRN_QUERY_LOG_SCORE (0x01<<5)
163 #define GRN_QUERY_LOG_ALL\
164  (GRN_QUERY_LOG_COMMAND |\
165  GRN_QUERY_LOG_RESULT_CODE |\
166  GRN_QUERY_LOG_DESTINATION |\
167  GRN_QUERY_LOG_CACHE |\
168  GRN_QUERY_LOG_SIZE |\
169  GRN_QUERY_LOG_SCORE)
170 #define GRN_QUERY_LOG_DEFAULT GRN_QUERY_LOG_ALL
171 
172 typedef enum {
173  GRN_CONTENT_NONE = 0,
174  GRN_CONTENT_TSV,
175  GRN_CONTENT_JSON,
176  GRN_CONTENT_XML,
177  GRN_CONTENT_MSGPACK
178 } grn_content_type;
179 
180 typedef struct _grn_obj grn_obj;
181 typedef struct _grn_ctx grn_ctx;
182 
183 #define GRN_CTX_MSGSIZE (0x80)
184 #define GRN_CTX_FIN (0xff)
185 
186 typedef union {
187  int int_value;
188  grn_id id;
189  void *ptr;
190 } grn_user_data;
191 
192 typedef grn_obj *grn_proc_func(grn_ctx *ctx, int nargs, grn_obj **args,
193  grn_user_data *user_data);
194 
195 struct _grn_ctx {
196  grn_rc rc;
197  int flags;
198  grn_encoding encoding;
199  unsigned char ntrace;
200  unsigned char errlvl;
201  unsigned char stat;
202  unsigned int seqno;
203  unsigned int subno;
204  unsigned int seqno2;
205  unsigned int errline;
206  grn_user_data user_data;
207  grn_ctx *prev;
208  grn_ctx *next;
209  const char *errfile;
210  const char *errfunc;
211  struct _grn_ctx_impl *impl;
212  void *trace[16];
213  char errbuf[GRN_CTX_MSGSIZE];
214 };
215 
216 #define GRN_CTX_USER_DATA(ctx) (&((ctx)->user_data))
217 
218 #define GRN_CTX_USE_QL (0x03)
219 #define GRN_CTX_BATCH_MODE (0x04)
220 #define GRN_CTX_PER_DB (0x08)
221 
222 GRN_API grn_rc grn_ctx_init(grn_ctx *ctx, int flags);
223 GRN_API grn_rc grn_ctx_fin(grn_ctx *ctx);
224 GRN_API grn_ctx *grn_ctx_open(int flags);
225 GRN_API grn_rc grn_ctx_close(grn_ctx *ctx);
226 GRN_API grn_rc grn_ctx_set_finalizer(grn_ctx *ctx, grn_proc_func *func);
227 
228 GRN_API grn_encoding grn_get_default_encoding(void);
229 GRN_API grn_rc grn_set_default_encoding(grn_encoding encoding);
230 
231 #define GRN_CTX_GET_ENCODING(ctx) ((ctx)->encoding)
232 #define GRN_CTX_SET_ENCODING(ctx,enc) \
233  ((ctx)->encoding = (enc == GRN_ENC_DEFAULT) ? grn_get_default_encoding() : enc)
234 
235 GRN_API const char *grn_get_version(void);
236 GRN_API const char *grn_get_package(void);
237 
238 GRN_API grn_command_version grn_get_default_command_version(void);
239 GRN_API grn_rc grn_set_default_command_version(grn_command_version version);
240 GRN_API grn_command_version grn_ctx_get_command_version(grn_ctx *ctx);
241 GRN_API grn_rc grn_ctx_set_command_version(grn_ctx *ctx, grn_command_version version);
242 GRN_API long long int grn_ctx_get_match_escalation_threshold(grn_ctx *ctx);
243 GRN_API grn_rc grn_ctx_set_match_escalation_threshold(grn_ctx *ctx, long long int threshold);
244 GRN_API long long int grn_get_default_match_escalation_threshold(void);
245 GRN_API grn_rc grn_set_default_match_escalation_threshold(long long int threshold);
246 
247 /* cache */
248 #define GRN_CACHE_DEFAULT_MAX_N_ENTRIES 100
249 typedef struct _grn_cache grn_cache;
250 
251 GRN_API grn_cache *grn_cache_open(grn_ctx *ctx);
252 GRN_API grn_rc grn_cache_close(grn_ctx *ctx, grn_cache *cache);
253 
254 GRN_API grn_rc grn_cache_current_set(grn_ctx *ctx, grn_cache *cache);
255 GRN_API grn_cache *grn_cache_current_get(grn_ctx *ctx);
256 
257 GRN_API grn_rc grn_cache_set_max_n_entries(grn_ctx *ctx,
258  grn_cache *cache,
259  unsigned int n);
260 GRN_API unsigned int grn_cache_get_max_n_entries(grn_ctx *ctx,
261  grn_cache *cache);
262 
263 /* grn_encoding */
264 
265 GRN_API const char *grn_encoding_to_string(grn_encoding encoding);
266 GRN_API grn_encoding grn_encoding_parse(const char *name);
267 
268 /* obj */
269 
270 typedef unsigned short int grn_obj_flags;
271 
272 #define GRN_OBJ_TABLE_TYPE_MASK (0x07)
273 #define GRN_OBJ_TABLE_HASH_KEY (0x00)
274 #define GRN_OBJ_TABLE_PAT_KEY (0x01)
275 #define GRN_OBJ_TABLE_DAT_KEY (0x02)
276 #define GRN_OBJ_TABLE_NO_KEY (0x03)
277 
278 #define GRN_OBJ_KEY_MASK (0x07<<3)
279 #define GRN_OBJ_KEY_UINT (0x00<<3)
280 #define GRN_OBJ_KEY_INT (0x01<<3)
281 #define GRN_OBJ_KEY_FLOAT (0x02<<3)
282 #define GRN_OBJ_KEY_GEO_POINT (0x03<<3)
283 
284 #define GRN_OBJ_KEY_WITH_SIS (0x01<<6)
285 #define GRN_OBJ_KEY_NORMALIZE (0x01<<7)
286 
287 #define GRN_OBJ_COLUMN_TYPE_MASK (0x07)
288 #define GRN_OBJ_COLUMN_SCALAR (0x00)
289 #define GRN_OBJ_COLUMN_VECTOR (0x01)
290 #define GRN_OBJ_COLUMN_INDEX (0x02)
291 
292 #define GRN_OBJ_COMPRESS_MASK (0x07<<4)
293 #define GRN_OBJ_COMPRESS_NONE (0x00<<4)
294 #define GRN_OBJ_COMPRESS_ZLIB (0x01<<4)
295 #define GRN_OBJ_COMPRESS_LZO (0x02<<4)
296 
297 #define GRN_OBJ_WITH_SECTION (0x01<<7)
298 #define GRN_OBJ_WITH_WEIGHT (0x01<<8)
299 #define GRN_OBJ_WITH_POSITION (0x01<<9)
300 #define GRN_OBJ_RING_BUFFER (0x01<<10)
301 
302 #define GRN_OBJ_UNIT_MASK (0x0f<<8)
303 #define GRN_OBJ_UNIT_DOCUMENT_NONE (0x00<<8)
304 #define GRN_OBJ_UNIT_DOCUMENT_SECTION (0x01<<8)
305 #define GRN_OBJ_UNIT_DOCUMENT_POSITION (0x02<<8)
306 #define GRN_OBJ_UNIT_SECTION_NONE (0x03<<8)
307 #define GRN_OBJ_UNIT_SECTION_POSITION (0x04<<8)
308 #define GRN_OBJ_UNIT_POSITION_NONE (0x05<<8)
309 #define GRN_OBJ_UNIT_USERDEF_DOCUMENT (0x06<<8)
310 #define GRN_OBJ_UNIT_USERDEF_SECTION (0x07<<8)
311 #define GRN_OBJ_UNIT_USERDEF_POSITION (0x08<<8)
312 
313 #define GRN_OBJ_NO_SUBREC (0x00<<13)
314 #define GRN_OBJ_WITH_SUBREC (0x01<<13)
315 
316 #define GRN_OBJ_KEY_VAR_SIZE (0x01<<14)
317 
318 #define GRN_OBJ_TEMPORARY (0x00<<15)
319 #define GRN_OBJ_PERSISTENT (0x01<<15)
320 
321 /* obj types */
322 
323 #define GRN_VOID (0x00)
324 #define GRN_BULK (0x02)
325 #define GRN_PTR (0x03)
326 #define GRN_UVECTOR (0x04) /* vector of grn_id */
327 #define GRN_PVECTOR (0x05) /* vector of grn_obj* */
328 #define GRN_VECTOR (0x06) /* vector of arbitrary data */
329 #define GRN_MSG (0x07)
330 #define GRN_QUERY (0x08)
331 #define GRN_ACCESSOR (0x09)
332 #define GRN_SNIP (0x0b)
333 #define GRN_PATSNIP (0x0c)
334 #define GRN_STRING (0x0d)
335 #define GRN_CURSOR_TABLE_HASH_KEY (0x10)
336 #define GRN_CURSOR_TABLE_PAT_KEY (0x11)
337 #define GRN_CURSOR_TABLE_DAT_KEY (0x12)
338 #define GRN_CURSOR_TABLE_NO_KEY (0x13)
339 #define GRN_CURSOR_COLUMN_INDEX (0x18)
340 #define GRN_CURSOR_COLUMN_GEO_INDEX (0x1a)
341 #define GRN_TYPE (0x20)
342 #define GRN_PROC (0x21)
343 #define GRN_EXPR (0x22)
344 #define GRN_TABLE_HASH_KEY (0x30)
345 #define GRN_TABLE_PAT_KEY (0x31)
346 #define GRN_TABLE_DAT_KEY (0x32)
347 #define GRN_TABLE_NO_KEY (0x33)
348 #define GRN_DB (0x37)
349 #define GRN_COLUMN_FIX_SIZE (0x40)
350 #define GRN_COLUMN_VAR_SIZE (0x41)
351 #define GRN_COLUMN_INDEX (0x48)
352 
353 typedef struct _grn_section grn_section;
354 typedef struct _grn_obj_header grn_obj_header;
355 
356 struct _grn_section {
357  unsigned int offset;
358  unsigned int length;
359  unsigned int weight;
360  grn_id domain;
361 };
362 
363 struct _grn_obj_header {
364  unsigned char type;
365  unsigned char impl_flags;
366  grn_obj_flags flags;
367  grn_id domain;
368 };
369 
370 struct _grn_obj {
371  grn_obj_header header;
372  union {
373  struct {
374  char *head;
375  char *curr;
376  char *tail;
377  } b;
378  struct {
379  grn_obj *body;
380  grn_section *sections;
381  int n_sections;
382  } v;
383  } u;
384 };
385 
386 #define GRN_OBJ_REFER (0x01<<0)
387 #define GRN_OBJ_OUTPLACE (0x01<<1)
388 
389 #define GRN_OBJ_INIT(obj,obj_type,obj_flags,obj_domain) do { \
390  (obj)->header.type = (obj_type);\
391  (obj)->header.impl_flags = (obj_flags);\
392  (obj)->header.flags = 0;\
393  (obj)->header.domain = (obj_domain);\
394  (obj)->u.b.head = NULL;\
395  (obj)->u.b.curr = NULL;\
396  (obj)->u.b.tail = NULL;\
397 } while (0)
398 
399 #define GRN_OBJ_FIN(ctx,obj) (grn_obj_close((ctx), (obj)))
400 
401 typedef struct _grn_db_create_optarg grn_db_create_optarg;
402 
403 struct _grn_db_create_optarg {
404  char **builtin_type_names;
405  int n_builtin_type_names;
406 };
407 
408 GRN_API grn_obj *grn_db_create(grn_ctx *ctx, const char *path, grn_db_create_optarg *optarg);
409 
410 #define GRN_DB_OPEN_OR_CREATE(ctx,path,optarg,db) \
411  (((db) = grn_db_open((ctx), (path))) || (db = grn_db_create((ctx), (path), (optarg))))
412 
413 GRN_API grn_obj *grn_db_open(grn_ctx *ctx, const char *path);
414 GRN_API void grn_db_touch(grn_ctx *ctx, grn_obj *db);
415 
416 GRN_API grn_rc grn_ctx_use(grn_ctx *ctx, grn_obj *db);
417 GRN_API grn_obj *grn_ctx_db(grn_ctx *ctx);
418 GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, int name_size);
419 
420 typedef enum {
421  GRN_DB_VOID = 0,
422  GRN_DB_DB,
423  GRN_DB_OBJECT,
424  GRN_DB_BOOL,
425  GRN_DB_INT8,
426  GRN_DB_UINT8,
427  GRN_DB_INT16,
428  GRN_DB_UINT16,
429  GRN_DB_INT32,
430  GRN_DB_UINT32,
431  GRN_DB_INT64,
432  GRN_DB_UINT64,
433  GRN_DB_FLOAT,
434  GRN_DB_TIME,
435  GRN_DB_SHORT_TEXT,
436  GRN_DB_TEXT,
437  GRN_DB_LONG_TEXT,
438  GRN_DB_TOKYO_GEO_POINT,
439  GRN_DB_WGS84_GEO_POINT
440 } grn_builtin_type;
441 
442 typedef enum {
443  GRN_DB_MECAB = 64,
444  GRN_DB_DELIMIT,
445  GRN_DB_UNIGRAM,
446  GRN_DB_BIGRAM,
447  GRN_DB_TRIGRAM
448 } grn_builtin_tokenizer;
449 
450 GRN_API grn_obj *grn_ctx_at(grn_ctx *ctx, grn_id id);
451 
452 GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,
453  grn_obj_flags flags, unsigned int size);
454 
455 GRN_API grn_rc grn_plugin_register(grn_ctx *ctx, const char *name);
456 GRN_API grn_rc grn_plugin_register_by_path(grn_ctx *ctx, const char *path);
457 GRN_API const char *grn_plugin_get_system_plugins_dir(void);
458 GRN_API const char *grn_plugin_get_suffix(void);
459 
460 typedef struct {
461  const char *name;
462  unsigned int name_size;
463  grn_obj value;
464 } grn_expr_var;
465 
466 typedef grn_rc (*grn_plugin_func)(grn_ctx *ctx);
467 
468 typedef enum {
469  GRN_PROC_TOKENIZER = 1,
470  GRN_PROC_COMMAND,
471  GRN_PROC_FUNCTION,
472  GRN_PROC_HOOK,
473  GRN_PROC_NORMALIZER
474 } grn_proc_type;
475 
476 GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
477  const char *name, int name_size, grn_proc_type type,
478  grn_proc_func *init, grn_proc_func *next, grn_proc_func *fin,
479  unsigned int nvars, grn_expr_var *vars);
480 GRN_API grn_obj *grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
481  grn_expr_var **vars, unsigned int *nvars, grn_obj **caller);
482 
483 /*-------------------------------------------------------------
484  * table操作のための関数
485  */
486 
487 #define GRN_TABLE_MAX_KEY_SIZE (0x1000)
488 
489 GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
490  const char *name, unsigned int name_size,
491  const char *path, grn_obj_flags flags,
492  grn_obj *key_type, grn_obj *value_type);
493 
494 #define GRN_TABLE_OPEN_OR_CREATE(ctx,name,name_size,path,flags,key_type,value_type,table) \
495  (((table) = grn_ctx_get((ctx), (name), (name_size))) ||\
496  ((table) = grn_table_create((ctx), (name), (name_size), (path), (flags), (key_type), (value_type))))
497 
498 /* TODO: int *added -> grn_bool *added */
499 GRN_API grn_id grn_table_add(grn_ctx *ctx, grn_obj *table,
500  const void *key, unsigned int key_size, int *added);
501 GRN_API grn_id grn_table_get(grn_ctx *ctx, grn_obj *table,
502  const void *key, unsigned int key_size);
503 GRN_API grn_id grn_table_at(grn_ctx *ctx, grn_obj *table, grn_id id);
504 GRN_API grn_id grn_table_lcp_search(grn_ctx *ctx, grn_obj *table,
505  const void *key, unsigned int key_size);
506 GRN_API int grn_table_get_key(grn_ctx *ctx, grn_obj *table,
507  grn_id id, void *keybuf, int buf_size);
508 GRN_API grn_rc grn_table_delete(grn_ctx *ctx, grn_obj *table,
509  const void *key, unsigned int key_size);
510 GRN_API grn_rc grn_table_delete_by_id(grn_ctx *ctx, grn_obj *table, grn_id id);
511 GRN_API grn_rc grn_table_update_by_id(grn_ctx *ctx, grn_obj *table, grn_id id,
512  const void *dest_key, unsigned int dest_key_size);
513 GRN_API grn_rc grn_table_update(grn_ctx *ctx, grn_obj *table,
514  const void *src_key, unsigned int src_key_size,
515  const void *dest_key, unsigned int dest_key_size);
516 GRN_API grn_rc grn_table_truncate(grn_ctx *ctx, grn_obj *table);
517 
518 typedef grn_obj grn_table_cursor;
519 
520 #define GRN_CURSOR_ASCENDING (0x00<<0)
521 #define GRN_CURSOR_DESCENDING (0x01<<0)
522 #define GRN_CURSOR_GE (0x00<<1)
523 #define GRN_CURSOR_GT (0x01<<1)
524 #define GRN_CURSOR_LE (0x00<<2)
525 #define GRN_CURSOR_LT (0x01<<2)
526 #define GRN_CURSOR_BY_KEY (0x00<<3)
527 #define GRN_CURSOR_BY_ID (0x01<<3)
528 #define GRN_CURSOR_PREFIX (0x01<<4)
529 #define GRN_CURSOR_SIZE_BY_BIT (0x01<<5)
530 #define GRN_CURSOR_RK (0x01<<6)
531 
532 GRN_API grn_table_cursor *grn_table_cursor_open(grn_ctx *ctx, grn_obj *table,
533  const void *min, unsigned int min_size,
534  const void *max, unsigned int max_size,
535  int offset, int limit, int flags);
536 GRN_API grn_rc grn_table_cursor_close(grn_ctx *ctx, grn_table_cursor *tc);
537 GRN_API grn_id grn_table_cursor_next(grn_ctx *ctx, grn_table_cursor *tc);
538 GRN_API int grn_table_cursor_get_key(grn_ctx *ctx, grn_table_cursor *tc, void **key);
539 GRN_API int grn_table_cursor_get_value(grn_ctx *ctx, grn_table_cursor *tc, void **value);
540 GRN_API grn_rc grn_table_cursor_set_value(grn_ctx *ctx, grn_table_cursor *tc,
541  const void *value, int flags);
542 GRN_API grn_rc grn_table_cursor_delete(grn_ctx *ctx, grn_table_cursor *tc);
543 GRN_API grn_obj *grn_table_cursor_table(grn_ctx *ctx, grn_table_cursor *tc);
544 
545 typedef struct {
546  grn_id rid;
547  grn_id sid;
548  unsigned int pos;
549  unsigned int tf;
550  unsigned int weight;
551  unsigned int rest;
552 } grn_posting;
553 
554 GRN_API grn_obj *grn_index_cursor_open(grn_ctx *ctx, grn_table_cursor *tc, grn_obj *index,
555  grn_id rid_min, grn_id rid_max, int flags);
556 GRN_API grn_posting *grn_index_cursor_next(grn_ctx *ctx, grn_obj *ic, grn_id *tid);
557 
558 #define GRN_TABLE_EACH(ctx,table,head,tail,id,key,key_size,value,block) do {\
559  (ctx)->errlvl = GRN_LOG_NOTICE;\
560  (ctx)->rc = GRN_SUCCESS;\
561  if ((ctx)->seqno & 1) {\
562  (ctx)->subno++;\
563  } else {\
564  (ctx)->seqno++;\
565  }\
566  if (table) {\
567  switch ((table)->header.type) {\
568  case GRN_TABLE_PAT_KEY :\
569  GRN_PAT_EACH((ctx), (grn_pat *)(table), (id), (key), (key_size), (value), block);\
570  break;\
571  case GRN_TABLE_DAT_KEY :\
572  GRN_DAT_EACH((ctx), (grn_dat *)(table), (id), (key), (key_size), block);\
573  break;\
574  case GRN_TABLE_HASH_KEY :\
575  GRN_HASH_EACH((ctx), (grn_hash *)(table), (id), (key), (key_size), (value), block);\
576  break;\
577  case GRN_TABLE_NO_KEY :\
578  GRN_ARRAY_EACH((ctx), (grn_array *)(table), (head), (tail), (id), (value), block);\
579  break;\
580  }\
581  }\
582  if ((ctx)->subno) {\
583  (ctx)->subno--;\
584  } else {\
585  (ctx)->seqno++;\
586  }\
587 } while (0)
588 
589 typedef struct _grn_table_sort_key grn_table_sort_key;
590 typedef unsigned char grn_table_sort_flags;
591 
592 #define GRN_TABLE_SORT_ASC (0x00<<0)
593 #define GRN_TABLE_SORT_DESC (0x01<<0)
594 
595 struct _grn_table_sort_key {
596  grn_obj *key;
597  grn_table_sort_flags flags;
598  int offset;
599 };
600 
601 GRN_API int grn_table_sort(grn_ctx *ctx, grn_obj *table, int offset, int limit,
602  grn_obj *result, grn_table_sort_key *keys, int n_keys);
603 
604 typedef struct _grn_table_group_result grn_table_group_result;
605 typedef unsigned int grn_table_group_flags;
606 
607 #define GRN_TABLE_GROUP_CALC_COUNT (0x01<<3)
608 #define GRN_TABLE_GROUP_CALC_MAX (0x01<<4)
609 #define GRN_TABLE_GROUP_CALC_MIN (0x01<<5)
610 #define GRN_TABLE_GROUP_CALC_SUM (0x01<<6)
611 #define GRN_TABLE_GROUP_CALC_AVG (0x01<<7)
612 
613 typedef enum {
614  GRN_OP_PUSH = 0,
615  GRN_OP_POP,
616  GRN_OP_NOP,
617  GRN_OP_CALL,
618  GRN_OP_INTERN,
619  GRN_OP_GET_REF,
620  GRN_OP_GET_VALUE,
621  GRN_OP_AND,
622  GRN_OP_AND_NOT,
623  /* Deprecated. Just for backward compatibility. */
624 #define GRN_OP_BUT GRN_OP_AND_NOT
625  GRN_OP_OR,
626  GRN_OP_ASSIGN,
627  GRN_OP_STAR_ASSIGN,
628  GRN_OP_SLASH_ASSIGN,
629  GRN_OP_MOD_ASSIGN,
630  GRN_OP_PLUS_ASSIGN,
631  GRN_OP_MINUS_ASSIGN,
632  GRN_OP_SHIFTL_ASSIGN,
633  GRN_OP_SHIFTR_ASSIGN,
634  GRN_OP_SHIFTRR_ASSIGN,
635  GRN_OP_AND_ASSIGN,
636  GRN_OP_XOR_ASSIGN,
637  GRN_OP_OR_ASSIGN,
638  GRN_OP_JUMP,
639  GRN_OP_CJUMP,
640  GRN_OP_COMMA,
641  GRN_OP_BITWISE_OR,
642  GRN_OP_BITWISE_XOR,
643  GRN_OP_BITWISE_AND,
644  GRN_OP_BITWISE_NOT,
645  GRN_OP_EQUAL,
646  GRN_OP_NOT_EQUAL,
647  GRN_OP_LESS,
648  GRN_OP_GREATER,
649  GRN_OP_LESS_EQUAL,
650  GRN_OP_GREATER_EQUAL,
651  GRN_OP_IN,
652  GRN_OP_MATCH,
653  GRN_OP_NEAR,
654  GRN_OP_NEAR2,
655  GRN_OP_SIMILAR,
656  GRN_OP_TERM_EXTRACT,
657  GRN_OP_SHIFTL,
658  GRN_OP_SHIFTR,
659  GRN_OP_SHIFTRR,
660  GRN_OP_PLUS,
661  GRN_OP_MINUS,
662  GRN_OP_STAR,
663  GRN_OP_SLASH,
664  GRN_OP_MOD,
665  GRN_OP_DELETE,
666  GRN_OP_INCR,
667  GRN_OP_DECR,
668  GRN_OP_INCR_POST,
669  GRN_OP_DECR_POST,
670  GRN_OP_NOT,
671  GRN_OP_ADJUST,
672  GRN_OP_EXACT,
673  GRN_OP_LCP,
674  GRN_OP_PARTIAL,
675  GRN_OP_UNSPLIT,
676  GRN_OP_PREFIX,
677  GRN_OP_SUFFIX,
678  GRN_OP_GEO_DISTANCE1,
679  GRN_OP_GEO_DISTANCE2,
680  GRN_OP_GEO_DISTANCE3,
681  GRN_OP_GEO_DISTANCE4,
682  GRN_OP_GEO_WITHINP5,
683  GRN_OP_GEO_WITHINP6,
684  GRN_OP_GEO_WITHINP8,
685  GRN_OP_OBJ_SEARCH,
686  GRN_OP_EXPR_GET_VAR,
687  GRN_OP_TABLE_CREATE,
688  GRN_OP_TABLE_SELECT,
689  GRN_OP_TABLE_SORT,
690  GRN_OP_TABLE_GROUP,
691  GRN_OP_JSON_PUT,
692  GRN_OP_GET_MEMBER
693 } grn_operator;
694 
695 struct _grn_table_group_result {
696  grn_obj *table;
697  unsigned char key_begin;
698  unsigned char key_end;
699  int limit;
700  grn_table_group_flags flags;
701  grn_operator op;
702 };
703 
704 GRN_API grn_rc grn_table_group(grn_ctx *ctx, grn_obj *table,
705  grn_table_sort_key *keys, int n_keys,
706  grn_table_group_result *results, int n_results);
707 GRN_API grn_rc grn_table_setoperation(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
708  grn_obj *res, grn_operator op);
709 GRN_API grn_rc grn_table_difference(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
710  grn_obj *res1, grn_obj *res2);
711 GRN_API int grn_table_columns(grn_ctx *ctx, grn_obj *table,
712  const char *name, unsigned int name_size,
713  grn_obj *res);
714 
715 GRN_API grn_obj *grn_obj_column(grn_ctx *ctx, grn_obj *table,
716  const char *name, unsigned int name_size);
717 
718 GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
719 
720 /*-------------------------------------------------------------
721  * column操作のための関数
722  */
723 
724 GRN_API grn_obj *grn_column_create(grn_ctx *ctx, grn_obj *table,
725  const char *name, unsigned int name_size,
726  const char *path, grn_obj_flags flags, grn_obj *type);
727 
728 #define GRN_COLUMN_OPEN_OR_CREATE(ctx,table,name,name_size,path,flags,type,column) \
729  (((column) = grn_obj_column((ctx), (table), (name), (name_size))) ||\
730  ((column) = grn_column_create((ctx), (table), (name), (name_size), (path), (flags), (type))))
731 
732 GRN_API grn_rc grn_column_index_update(grn_ctx *ctx, grn_obj *column,
733  grn_id id, unsigned int section,
734  grn_obj *oldvalue, grn_obj *newvalue);
735 GRN_API grn_obj *grn_column_table(grn_ctx *ctx, grn_obj *column);
736 
737 /*-------------------------------------------------------------
738  * db, table, columnの全てまたは幾つかで共通に使用できる関数
739  */
740 
741 typedef enum {
742  GRN_INFO_ENCODING = 0,
743  GRN_INFO_SOURCE,
744  GRN_INFO_DEFAULT_TOKENIZER,
745  GRN_INFO_ELEMENT_SIZE,
746  GRN_INFO_CURR_MAX,
747  GRN_INFO_MAX_ELEMENT_SIZE,
748  GRN_INFO_SEG_SIZE,
749  GRN_INFO_CHUNK_SIZE,
750  GRN_INFO_MAX_SECTION,
751  GRN_INFO_HOOK_LOCAL_DATA,
752  GRN_INFO_ELEMENT_A,
753  GRN_INFO_ELEMENT_CHUNK,
754  GRN_INFO_ELEMENT_CHUNK_SIZE,
755  GRN_INFO_ELEMENT_BUFFER_FREE,
756  GRN_INFO_ELEMENT_NTERMS,
757  GRN_INFO_ELEMENT_NTERMS_VOID,
758  GRN_INFO_ELEMENT_SIZE_IN_CHUNK,
759  GRN_INFO_ELEMENT_POS_IN_CHUNK,
760  GRN_INFO_ELEMENT_SIZE_IN_BUFFER,
761  GRN_INFO_ELEMENT_POS_IN_BUFFER,
762  GRN_INFO_ELEMENT_ESTIMATE_SIZE,
763  GRN_INFO_NGRAM_UNIT_SIZE,
764  /*
765  GRN_INFO_VERSION,
766  GRN_INFO_CONFIGURE_OPTIONS,
767  GRN_INFO_CONFIG_PATH,
768  */
769  GRN_INFO_PARTIAL_MATCH_THRESHOLD,
770  GRN_INFO_II_SPLIT_THRESHOLD,
771  GRN_INFO_SUPPORT_ZLIB,
772  GRN_INFO_SUPPORT_LZO,
773  GRN_INFO_NORMALIZER
774 } grn_info_type;
775 
776 GRN_API grn_obj *grn_obj_get_info(grn_ctx *ctx, grn_obj *obj, grn_info_type type, grn_obj *valuebuf);
777 GRN_API grn_rc grn_obj_set_info(grn_ctx *ctx, grn_obj *obj, grn_info_type type, grn_obj *value);
778 GRN_API grn_obj *grn_obj_get_element_info(grn_ctx *ctx, grn_obj *obj, grn_id id,
779  grn_info_type type, grn_obj *value);
780 GRN_API grn_rc grn_obj_set_element_info(grn_ctx *ctx, grn_obj *obj, grn_id id,
781  grn_info_type type, grn_obj *value);
782 
783 GRN_API grn_bool grn_obj_is_builtin(grn_ctx *ctx, grn_obj *obj);
784 
785 GRN_API grn_obj *grn_obj_get_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value);
786 GRN_API int grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void **values);
787 
788 #define GRN_COLUMN_EACH(ctx,column,id,value,block) do {\
789  int _n;\
790  grn_id id = 1;\
791  while ((_n = grn_obj_get_values(ctx, column, id, (void **)&value)) > 0) {\
792  for (; _n; _n--, id++, value++) {\
793  block\
794  }\
795  }\
796 } while (0)
797 
798 #define GRN_OBJ_SET_MASK (0x07)
799 #define GRN_OBJ_SET (0x01)
800 #define GRN_OBJ_INCR (0x02)
801 #define GRN_OBJ_DECR (0x03)
802 #define GRN_OBJ_APPEND (0x04)
803 #define GRN_OBJ_PREPEND (0x05)
804 #define GRN_OBJ_GET (0x01<<4)
805 #define GRN_OBJ_COMPARE (0x01<<5)
806 #define GRN_OBJ_LOCK (0x01<<6)
807 #define GRN_OBJ_UNLOCK (0x01<<7)
808 
809 GRN_API grn_rc grn_obj_set_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value, int flags);
810 GRN_API grn_rc grn_obj_remove(grn_ctx *ctx, grn_obj *obj);
811 GRN_API grn_rc grn_obj_rename(grn_ctx *ctx, grn_obj *obj,
812  const char *name, unsigned int name_size);
813 GRN_API grn_rc grn_table_rename(grn_ctx *ctx, grn_obj *table,
814  const char *name, unsigned int name_size);
815 
816 GRN_API grn_rc grn_column_rename(grn_ctx *ctx, grn_obj *column,
817  const char *name, unsigned int name_size);
818 
819 GRN_API grn_rc grn_obj_close(grn_ctx *ctx, grn_obj *obj);
820 GRN_API grn_rc grn_obj_reinit(grn_ctx *ctx, grn_obj *obj, grn_id domain, unsigned char flags);
821 GRN_API void grn_obj_unlink(grn_ctx *ctx, grn_obj *obj);
822 
823 GRN_API grn_user_data *grn_obj_user_data(grn_ctx *ctx, grn_obj *obj);
824 
825 GRN_API grn_rc grn_obj_set_finalizer(grn_ctx *ctx, grn_obj *obj, grn_proc_func *func);
826 
827 GRN_API const char *grn_obj_path(grn_ctx *ctx, grn_obj *obj);
828 GRN_API int grn_obj_name(grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size);
829 
830 GRN_API int grn_column_name(grn_ctx *ctx, grn_obj *obj, char *namebuf, int buf_size);
831 
832 GRN_API grn_id grn_obj_get_range(grn_ctx *ctx, grn_obj *obj);
833 
834 #define GRN_OBJ_GET_DOMAIN(obj) \
835  ((obj)->header.type == GRN_TABLE_NO_KEY ? GRN_ID_NIL : (obj)->header.domain)
836 
837 GRN_API int grn_obj_expire(grn_ctx *ctx, grn_obj *obj, int threshold);
838 GRN_API int grn_obj_check(grn_ctx *ctx, grn_obj *obj);
839 GRN_API grn_rc grn_obj_lock(grn_ctx *ctx, grn_obj *obj, grn_id id, int timeout);
840 GRN_API grn_rc grn_obj_unlock(grn_ctx *ctx, grn_obj *obj, grn_id id);
841 GRN_API grn_rc grn_obj_clear_lock(grn_ctx *ctx, grn_obj *obj);
842 GRN_API unsigned int grn_obj_is_locked(grn_ctx *ctx, grn_obj *obj);
843 GRN_API int grn_obj_defrag(grn_ctx *ctx, grn_obj *obj, int threshold);
844 
845 GRN_API grn_obj *grn_obj_db(grn_ctx *ctx, grn_obj *obj);
846 
847 GRN_API grn_id grn_obj_id(grn_ctx *ctx, grn_obj *obj);
848 
849 typedef struct _grn_search_optarg grn_search_optarg;
850 
851 struct _grn_search_optarg {
852  grn_operator mode;
853  int similarity_threshold;
854  int max_interval;
855  int *weight_vector;
856  int vector_size;
857  grn_obj *proc;
858  int max_size;
859 };
860 
861 GRN_API grn_rc grn_obj_search(grn_ctx *ctx, grn_obj *obj, grn_obj *query,
862  grn_obj *res, grn_operator op, grn_search_optarg *optarg);
863 
864 /*-------------------------------------------------------------
865  * grn_vector
866 */
867 
868 GRN_API unsigned int grn_vector_size(grn_ctx *ctx, grn_obj *vector);
869 
870 GRN_API grn_rc grn_vector_add_element(grn_ctx *ctx, grn_obj *vector,
871  const char *str, unsigned int str_len,
872  unsigned int weight, grn_id domain);
873 
874 GRN_API unsigned int grn_vector_get_element(grn_ctx *ctx, grn_obj *vector,
875  unsigned int offset, const char **str,
876  unsigned int *weight, grn_id *domain);
877 
878 /*-------------------------------------------------------------
879  * hook操作のための関数
880  */
881 
882 GRN_API int grn_proc_call_next(grn_ctx *ctx, grn_obj *exec_info, grn_obj *in, grn_obj *out);
883 GRN_API void *grn_proc_get_ctx_local_data(grn_ctx *ctx, grn_obj *exec_info);
884 GRN_API void *grn_proc_get_hook_local_data(grn_ctx *ctx, grn_obj *exec_info);
885 
886 typedef enum {
887  GRN_HOOK_SET = 0,
888  GRN_HOOK_GET,
889  GRN_HOOK_INSERT,
890  GRN_HOOK_DELETE,
891  GRN_HOOK_SELECT
892 } grn_hook_entry;
893 
894 GRN_API grn_rc grn_obj_add_hook(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry,
895  int offset, grn_obj *proc, grn_obj *data);
896 GRN_API int grn_obj_get_nhooks(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry);
897 GRN_API grn_obj *grn_obj_get_hook(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry,
898  int offset, grn_obj *data);
899 GRN_API grn_rc grn_obj_delete_hook(grn_ctx *ctx, grn_obj *obj, grn_hook_entry entry, int offset);
900 
901 GRN_API grn_obj *grn_obj_open(grn_ctx *ctx, unsigned char type, grn_obj_flags flags, grn_id domain);
902 
903 GRN_API int grn_column_index(grn_ctx *ctx, grn_obj *column, grn_operator op,
904  grn_obj **indexbuf, int buf_size, int *section);
905 
906 GRN_API grn_rc grn_obj_delete_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, grn_bool removep);
907 GRN_API grn_rc grn_obj_path_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, char *buffer);
908 
909 /* geo */
910 
911 typedef struct {
912  int latitude;
913  int longitude;
914 } grn_geo_point;
915 
916 GRN_API grn_rc grn_geo_select_in_rectangle(grn_ctx *ctx,
917  grn_obj *index,
918  grn_obj *top_left_point,
919  grn_obj *bottom_right_point,
920  grn_obj *res,
921  grn_operator op);
922 GRN_API int grn_geo_estimate_in_rectangle(grn_ctx *ctx,
923  grn_obj *index,
924  grn_obj *top_left_point,
925  grn_obj *bottom_right_point);
926 GRN_API grn_obj *grn_geo_cursor_open_in_rectangle(grn_ctx *ctx,
927  grn_obj *index,
928  grn_obj *top_left_point,
929  grn_obj *bottom_right_point,
930  int offset,
931  int limit);
932 GRN_API grn_posting *grn_geo_cursor_next(grn_ctx *ctx, grn_obj *cursor);
933 
934 
935 /* query & snippet */
936 
937 #ifndef GRN_QUERY_AND
938 #define GRN_QUERY_AND '+'
939 #endif /* GRN_QUERY_AND */
940 #ifndef GRN_QUERY_AND_NOT
941 # ifdef GRN_QUERY_BUT
942  /* Deprecated. Just for backward compatibility. */
943 # define GRN_QUERY_AND_NOT GRN_QUERY_BUT
944 # else
945 # define GRN_QUERY_AND_NOT '-'
946 # endif /* GRN_QUERY_BUT */
947 #endif /* GRN_QUERY_AND_NOT */
948 #ifndef GRN_QUERY_ADJ_INC
949 #define GRN_QUERY_ADJ_INC '>'
950 #endif /* GRN_QUERY_ADJ_POS2 */
951 #ifndef GRN_QUERY_ADJ_DEC
952 #define GRN_QUERY_ADJ_DEC '<'
953 #endif /* GRN_QUERY_ADJ_POS1 */
954 #ifndef GRN_QUERY_ADJ_NEG
955 #define GRN_QUERY_ADJ_NEG '~'
956 #endif /* GRN_QUERY_ADJ_NEG */
957 #ifndef GRN_QUERY_PREFIX
958 #define GRN_QUERY_PREFIX '*'
959 #endif /* GRN_QUERY_PREFIX */
960 #ifndef GRN_QUERY_PARENL
961 #define GRN_QUERY_PARENL '('
962 #endif /* GRN_QUERY_PARENL */
963 #ifndef GRN_QUERY_PARENR
964 #define GRN_QUERY_PARENR ')'
965 #endif /* GRN_QUERY_PARENR */
966 #ifndef GRN_QUERY_QUOTEL
967 #define GRN_QUERY_QUOTEL '"'
968 #endif /* GRN_QUERY_QUOTEL */
969 #ifndef GRN_QUERY_QUOTER
970 #define GRN_QUERY_QUOTER '"'
971 #endif /* GRN_QUERY_QUOTER */
972 #ifndef GRN_QUERY_ESCAPE
973 #define GRN_QUERY_ESCAPE '\\'
974 #endif /* GRN_QUERY_ESCAPE */
975 #ifndef GRN_QUERY_COLUMN
976 #define GRN_QUERY_COLUMN ':'
977 #endif /* GRN_QUERY_COLUMN */
978 
979 /* grn_snip should be removed.
980  * TODO: 3.0 */
981 typedef struct _grn_snip grn_snip;
982 typedef struct _grn_snip_mapping grn_snip_mapping;
983 
984 struct _grn_snip_mapping {
985  void *dummy;
986 };
987 
988 #define GRN_SNIP_NORMALIZE (0x01<<0)
989 #define GRN_SNIP_COPY_TAG (0x01<<1)
990 #define GRN_SNIP_SKIP_LEADING_SPACES (0x01<<2)
991 
992 #define GRN_SNIP_MAPPING_HTML_ESCAPE ((grn_snip_mapping *)-1)
993 
994 /* grn_snip_open() should return grn_obj * instead.
995  * TODO: 3.0 */
996 GRN_API grn_snip *grn_snip_open(grn_ctx *ctx, int flags, unsigned int width,
997  unsigned int max_results,
998  const char *defaultopentag, unsigned int defaultopentag_len,
999  const char *defaultclosetag, unsigned int defaultclosetag_len,
1000  grn_snip_mapping *mapping);
1001 /* grn_snip_close() should be removed. Use grn_obj_close() instead.
1002  * TODO: 3.0 */
1003 GRN_API grn_rc grn_snip_close(grn_ctx *ctx, grn_snip *snip);
1004 GRN_API grn_rc grn_snip_add_cond(grn_ctx *ctx, grn_snip *snip,
1005  const char *keyword, unsigned int keyword_len,
1006  const char *opentag, unsigned int opentag_len,
1007  const char *closetag, unsigned int closetag_len);
1008 GRN_API grn_rc grn_snip_exec(grn_ctx *ctx, grn_snip *snip,
1009  const char *string, unsigned int string_len,
1010  unsigned int *nresults, unsigned int *max_tagged_len);
1011 GRN_API grn_rc grn_snip_get_result(grn_ctx *ctx, grn_snip *snip, const unsigned int index,
1012  char *result, unsigned int *result_len);
1013 
1014 /* log */
1015 
1016 #define GRN_LOG_TIME (0x01<<0)
1017 #define GRN_LOG_TITLE (0x01<<1)
1018 #define GRN_LOG_MESSAGE (0x01<<2)
1019 #define GRN_LOG_LOCATION (0x01<<3)
1020 
1021 /* Deprecated since 2.1.2. Use grn_logger instead. */
1022 typedef struct _grn_logger_info grn_logger_info;
1023 
1024 /* Deprecated since 2.1.2. Use grn_logger instead. */
1025 struct _grn_logger_info {
1026  grn_log_level max_level;
1027  int flags;
1028  void (*func)(int, const char *, const char *, const char *, const char *, void *);
1029  void *func_arg;
1030 };
1031 
1032 /* Deprecated since 2.1.2. Use grn_logger_set() instead. */
1033 GRN_API grn_rc grn_logger_info_set(grn_ctx *ctx, const grn_logger_info *info);
1034 
1035 typedef struct _grn_logger grn_logger;
1036 
1037 struct _grn_logger {
1038  grn_log_level max_level;
1039  int flags;
1040  void *user_data;
1041  void (*log)(grn_ctx *ctx, grn_log_level level,
1042  const char *timestamp, const char *title, const char *message,
1043  const char *location, void *user_data);
1044  void (*reopen)(grn_ctx *ctx, void *user_data);
1045  void (*fin)(grn_ctx *ctx, void *user_data);
1046 };
1047 
1048 GRN_API grn_rc grn_logger_set(grn_ctx *ctx, const grn_logger *logger);
1049 
1050 GRN_API void grn_logger_set_max_level(grn_ctx *ctx, grn_log_level max_level);
1051 GRN_API grn_log_level grn_logger_get_max_level(grn_ctx *ctx);
1052 
1053 #ifdef __GNUC__
1054 #define GRN_ATTRIBUTE_PRINTF(fmt_pos) \
1055  __attribute__ ((format(printf, fmt_pos, fmt_pos + 1)))
1056 #else
1057 #define GRN_ATTRIBUTE_PRINTF(fmt_pos)
1058 #endif /* __GNUC__ */
1059 
1060 GRN_API void grn_logger_put(grn_ctx *ctx, grn_log_level level,
1061  const char *file, int line, const char *func, const char *fmt, ...) GRN_ATTRIBUTE_PRINTF(6);
1062 GRN_API void grn_logger_reopen(grn_ctx *ctx);
1063 
1064 GRN_API grn_bool grn_logger_pass(grn_ctx *ctx, grn_log_level level);
1065 
1066 #ifndef GRN_LOG_DEFAULT_LEVEL
1067 #define GRN_LOG_DEFAULT_LEVEL GRN_LOG_NOTICE
1068 #endif /* GRN_LOG_DEFAULT_LEVEL */
1069 
1070 GRN_API void grn_default_logger_set_max_level(grn_log_level level);
1071 GRN_API grn_log_level grn_default_logger_get_max_level(void);
1072 GRN_API void grn_default_logger_set_path(const char *path);
1073 GRN_API const char *grn_default_logger_get_path(void);
1074 
1075 #define GRN_LOG(ctx,level,...) do {\
1076  if (grn_logger_pass(ctx, level)) {\
1077  grn_logger_put(ctx, (level), __FILE__, __LINE__, __FUNCTION__, __VA_ARGS__); \
1078  }\
1079 } while (0)
1080 
1081 typedef struct _grn_query_logger grn_query_logger;
1082 
1083 struct _grn_query_logger {
1084  unsigned int flags;
1085  void *user_data;
1086  void (*log)(grn_ctx *ctx, unsigned int flag,
1087  const char *timestamp, const char *info, const char *message,
1088  void *user_data);
1089  void (*reopen)(grn_ctx *ctx, void *user_data);
1090  void (*fin)(grn_ctx *ctx, void *user_data);
1091 };
1092 
1093 GRN_API grn_rc grn_query_logger_set(grn_ctx *ctx, const grn_query_logger *logger);
1094 
1095 GRN_API void grn_query_logger_put(grn_ctx *ctx, unsigned int flag,
1096  const char *mark,
1097  const char *format, ...) GRN_ATTRIBUTE_PRINTF(4);
1098 GRN_API void grn_query_logger_reopen(grn_ctx *ctx);
1099 
1100 GRN_API grn_bool grn_query_logger_pass(grn_ctx *ctx, unsigned int flag);
1101 
1102 GRN_API void grn_default_query_logger_set_flags(unsigned int flags);
1103 GRN_API unsigned int grn_default_query_logger_get_flags(void);
1104 GRN_API void grn_default_query_logger_set_path(const char *path);
1105 GRN_API const char *grn_default_query_logger_get_path(void);
1106 
1107 #define GRN_QUERY_LOG(ctx, flag, mark, format, ...) do {\
1108  if (grn_query_logger_pass(ctx, flag)) {\
1109  grn_query_logger_put(ctx, (flag), (mark), format, __VA_ARGS__);\
1110  }\
1111 } while (0)
1112 
1113 /* grn_bulk */
1114 
1115 #define GRN_BULK_BUFSIZE (sizeof(grn_obj) - sizeof(grn_obj_header))
1116 #define GRN_BULK_OUTP(bulk) ((bulk)->header.impl_flags & GRN_OBJ_OUTPLACE)
1117 #define GRN_BULK_REWIND(bulk) do {\
1118  if ((bulk)->header.type == GRN_VECTOR) {\
1119  grn_obj *_body = (bulk)->u.v.body;\
1120  if (_body) {\
1121  if (GRN_BULK_OUTP(_body)) {\
1122  (_body)->u.b.curr = (_body)->u.b.head;\
1123  } else {\
1124  (_body)->header.flags = 0;\
1125  }\
1126  }\
1127  (bulk)->u.v.n_sections = 0;\
1128  } else {\
1129  if (GRN_BULK_OUTP(bulk)) {\
1130  (bulk)->u.b.curr = (bulk)->u.b.head;\
1131  } else {\
1132  (bulk)->header.flags = 0;\
1133  }\
1134  }\
1135 } while (0)
1136 #define GRN_BULK_WSIZE(bulk) \
1137  (GRN_BULK_OUTP(bulk)\
1138  ? ((bulk)->u.b.tail - (bulk)->u.b.head)\
1139  : GRN_BULK_BUFSIZE)
1140 #define GRN_BULK_REST(bulk) \
1141  (GRN_BULK_OUTP(bulk)\
1142  ? ((bulk)->u.b.tail - (bulk)->u.b.curr)\
1143  : GRN_BULK_BUFSIZE - (bulk)->header.flags)
1144 #define GRN_BULK_VSIZE(bulk) \
1145  (GRN_BULK_OUTP(bulk)\
1146  ? ((bulk)->u.b.curr - (bulk)->u.b.head)\
1147  : (bulk)->header.flags)
1148 #define GRN_BULK_EMPTYP(bulk) \
1149  (GRN_BULK_OUTP(bulk)\
1150  ? ((bulk)->u.b.curr == (bulk)->u.b.head)\
1151  : !((bulk)->header.flags))
1152 #define GRN_BULK_HEAD(bulk) \
1153  (GRN_BULK_OUTP(bulk)\
1154  ? ((bulk)->u.b.head)\
1155  : (char *)&((bulk)->u.b.head))
1156 #define GRN_BULK_CURR(bulk) \
1157  (GRN_BULK_OUTP(bulk)\
1158  ? ((bulk)->u.b.curr)\
1159  : (char *)&((bulk)->u.b.head) + (bulk)->header.flags)
1160 #define GRN_BULK_TAIL(bulk) \
1161  (GRN_BULK_OUTP(bulk)\
1162  ? ((bulk)->u.b.tail)\
1163  : (char *)&((bulk)[1]))
1164 
1165 GRN_API grn_rc grn_bulk_reinit(grn_ctx *ctx, grn_obj *bulk, unsigned int size);
1166 GRN_API grn_rc grn_bulk_resize(grn_ctx *ctx, grn_obj *bulk, unsigned int newsize);
1167 GRN_API grn_rc grn_bulk_write(grn_ctx *ctx, grn_obj *bulk,
1168  const char *str, unsigned int len);
1169 GRN_API grn_rc grn_bulk_write_from(grn_ctx *ctx, grn_obj *bulk,
1170  const char *str, unsigned int from, unsigned int len);
1171 GRN_API grn_rc grn_bulk_reserve(grn_ctx *ctx, grn_obj *bulk, unsigned int len);
1172 GRN_API grn_rc grn_bulk_space(grn_ctx *ctx, grn_obj *bulk, unsigned int len);
1173 GRN_API grn_rc grn_bulk_truncate(grn_ctx *ctx, grn_obj *bulk, unsigned int len);
1174 GRN_API grn_rc grn_bulk_fin(grn_ctx *ctx, grn_obj *bulk);
1175 
1176 /* grn_text */
1177 
1178 GRN_API grn_rc grn_text_itoa(grn_ctx *ctx, grn_obj *bulk, int i);
1179 GRN_API grn_rc grn_text_itoa_padded(grn_ctx *ctx, grn_obj *bulk, int i, char ch, unsigned int len);
1180 GRN_API grn_rc grn_text_lltoa(grn_ctx *ctx, grn_obj *bulk, long long int i);
1181 GRN_API grn_rc grn_text_ftoa(grn_ctx *ctx, grn_obj *bulk, double d);
1182 GRN_API grn_rc grn_text_itoh(grn_ctx *ctx, grn_obj *bulk, int i, unsigned int len);
1183 GRN_API grn_rc grn_text_itob(grn_ctx *ctx, grn_obj *bulk, grn_id id);
1184 GRN_API grn_rc grn_text_lltob32h(grn_ctx *ctx, grn_obj *bulk, long long int i);
1185 GRN_API grn_rc grn_text_benc(grn_ctx *ctx, grn_obj *bulk, unsigned int v);
1186 GRN_API grn_rc grn_text_esc(grn_ctx *ctx, grn_obj *bulk, const char *s, unsigned int len);
1187 GRN_API grn_rc grn_text_urlenc(grn_ctx *ctx, grn_obj *buf,
1188  const char *str, unsigned int len);
1189 GRN_API const char *grn_text_urldec(grn_ctx *ctx, grn_obj *buf,
1190  const char *s, const char *e, char d);
1191 GRN_API grn_rc grn_text_escape_xml(grn_ctx *ctx, grn_obj *buf,
1192  const char *s, unsigned int len);
1193 GRN_API grn_rc grn_text_time2rfc1123(grn_ctx *ctx, grn_obj *bulk, int sec);
1194 
1195 typedef struct _grn_obj_format grn_obj_format;
1196 
1197 #define GRN_OBJ_FORMAT_WITH_COLUMN_NAMES (0x01<<0)
1198 #define GRN_OBJ_FORMAT_ASARRAY (0x01<<3)
1199 
1200 struct _grn_obj_format {
1201  grn_obj columns;
1202  const void *min;
1203  const void *max;
1204  unsigned int min_size;
1205  unsigned int max_size;
1206  int nhits;
1207  int offset;
1208  int limit;
1209  int hits_offset;
1210  int flags;
1211  grn_obj *expression;
1212 };
1213 
1214 #define GRN_OBJ_FORMAT_INIT(format,format_nhits,format_offset,format_limit,format_hits_offset) do { \
1215  GRN_PTR_INIT(&(format)->columns, GRN_OBJ_VECTOR, GRN_ID_NIL);\
1216  (format)->nhits = (format_nhits);\
1217  (format)->offset = (format_offset);\
1218  (format)->limit = (format_limit);\
1219  (format)->hits_offset = (format_hits_offset);\
1220  (format)->expression = NULL;\
1221 } while (0)
1222 
1223 #define GRN_OBJ_FORMAT_FIN(ctx,format) do {\
1224  int ncolumns = GRN_BULK_VSIZE(&(format)->columns) / sizeof(grn_obj *);\
1225  grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&(format)->columns);\
1226  while (ncolumns--) { grn_obj_unlink((ctx), *columns++); }\
1227  GRN_OBJ_FIN((ctx), &(format)->columns);\
1228  if ((format)->expression) { GRN_OBJ_FIN((ctx), (format)->expression); } \
1229 } while (0)
1230 
1231 GRN_API void grn_output_obj(grn_ctx *ctx, grn_obj *outbuf, grn_content_type output_type,
1232  grn_obj *obj, grn_obj_format *format);
1233 GRN_API void grn_output_envelope(grn_ctx *ctx, grn_rc rc,
1234  grn_obj *head, grn_obj *body, grn_obj *foot,
1235  const char *file, int line);
1236 
1237 GRN_API void grn_ctx_output_array_open(grn_ctx *ctx,
1238  const char *name, int nelements);
1239 GRN_API void grn_ctx_output_array_close(grn_ctx *ctx);
1240 GRN_API void grn_ctx_output_map_open(grn_ctx *ctx,
1241  const char *name, int nelements);
1242 GRN_API void grn_ctx_output_map_close(grn_ctx *ctx);
1243 GRN_API void grn_ctx_output_int32(grn_ctx *ctx, int value);
1244 GRN_API void grn_ctx_output_int64(grn_ctx *ctx, long long int value);
1245 GRN_API void grn_ctx_output_float(grn_ctx *ctx, double value);
1246 GRN_API void grn_ctx_output_cstr(grn_ctx *ctx, const char *value);
1247 GRN_API void grn_ctx_output_str(grn_ctx *ctx,
1248  const char *value, unsigned int value_len);
1249 GRN_API void grn_ctx_output_bool(grn_ctx *ctx, grn_bool value);
1250 GRN_API void grn_ctx_output_obj(grn_ctx *ctx,
1251  grn_obj *value, grn_obj_format *format);
1252 
1253 
1254 GRN_API const char *grn_ctx_get_mime_type(grn_ctx *ctx);
1255 GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
1256  void (*func)(grn_ctx *, int, void *),
1257  void *func_arg);
1258 
1259 /* obsolete */
1260 GRN_API grn_rc grn_text_otoj(grn_ctx *ctx, grn_obj *bulk, grn_obj *obj,
1261  grn_obj_format *format);
1262 
1263 /* various values exchanged via grn_obj */
1264 
1265 #define GRN_OBJ_DO_SHALLOW_COPY (GRN_OBJ_REFER|GRN_OBJ_OUTPLACE)
1266 #define GRN_OBJ_VECTOR (0x01<<7)
1267 
1268 #define GRN_OBJ_MUTABLE(obj) ((obj) && (obj)->header.type <= GRN_VECTOR)
1269 
1270 #define GRN_VALUE_FIX_SIZE_INIT(obj,flags,domain)\
1271  GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_UVECTOR : GRN_BULK,\
1272  ((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain))
1273 #define GRN_VALUE_VAR_SIZE_INIT(obj,flags,domain)\
1274  GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_VECTOR : GRN_BULK,\
1275  ((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain))
1276 
1277 #define GRN_VOID_INIT(obj) GRN_OBJ_INIT((obj), GRN_VOID, 0, GRN_DB_VOID)
1278 #define GRN_TEXT_INIT(obj,flags) \
1279  GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_TEXT)
1280 #define GRN_SHORT_TEXT_INIT(obj,flags) \
1281  GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_SHORT_TEXT)
1282 #define GRN_LONG_TEXT_INIT(obj,flags) \
1283  GRN_VALUE_VAR_SIZE_INIT(obj, flags, GRN_DB_LONG_TEXT)
1284 #define GRN_TEXT_SET_REF(obj,str,len) do {\
1285  (obj)->u.b.head = (char *)(str);\
1286  (obj)->u.b.curr = (char *)(str) + (len);\
1287 } while (0)
1288 #define GRN_TEXT_SET(ctx,obj,str,len) do {\
1289  if ((obj)->header.impl_flags & GRN_OBJ_REFER) {\
1290  GRN_TEXT_SET_REF((obj), (str), (len));\
1291  } else {\
1292  grn_bulk_write_from((ctx), (obj), (const char *)(str), 0, (unsigned int)(len));\
1293  }\
1294 } while (0)
1295 #define GRN_TEXT_PUT(ctx,obj,str,len) \
1296  grn_bulk_write((ctx), (obj), (const char *)(str), (unsigned int)(len))
1297 #define GRN_TEXT_PUTC(ctx,obj,c) do {\
1298  char _c = (c); grn_bulk_write((ctx), (obj), &_c, 1);\
1299 } while (0)
1300 
1301 #define GRN_TEXT_PUTS(ctx,obj,str) GRN_TEXT_PUT((ctx), (obj), (str), strlen(str))
1302 #define GRN_TEXT_SETS(ctx,obj,str) GRN_TEXT_SET((ctx), (obj), (str), strlen(str))
1303 #define GRN_TEXT_VALUE(obj) GRN_BULK_HEAD(obj)
1304 #define GRN_TEXT_LEN(obj) GRN_BULK_VSIZE(obj)
1305 
1306 #define GRN_BOOL_INIT(obj,flags) \
1307  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BOOL)
1308 #define GRN_INT8_INIT(obj,flags) \
1309  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT8)
1310 #define GRN_UINT8_INIT(obj,flags) \
1311  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT8)
1312 #define GRN_INT16_INIT(obj,flags) \
1313  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT16)
1314 #define GRN_UINT16_INIT(obj,flags) \
1315  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT16)
1316 #define GRN_INT32_INIT(obj,flags) \
1317  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT32)
1318 #define GRN_UINT32_INIT(obj,flags) \
1319  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT32)
1320 #define GRN_INT64_INIT(obj,flags) \
1321  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_INT64)
1322 #define GRN_UINT64_INIT(obj,flags) \
1323  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_UINT64)
1324 #define GRN_FLOAT_INIT(obj,flags) \
1325  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_FLOAT)
1326 #define GRN_TIME_INIT(obj,flags) \
1327  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TIME)
1328 #define GRN_RECORD_INIT GRN_VALUE_FIX_SIZE_INIT
1329 #define GRN_PTR_INIT(obj,flags,domain)\
1330  GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_PVECTOR : GRN_PTR,\
1331  ((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain))
1332 #define GRN_TOKYO_GEO_POINT_INIT(obj,flags) \
1333  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TOKYO_GEO_POINT)
1334 #define GRN_WGS84_GEO_POINT_INIT(obj,flags) \
1335  GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_WGS84_GEO_POINT)
1336 
1337 #define GRN_BOOL_SET(ctx,obj,val) do {\
1338  unsigned char _val = (unsigned char)(val);\
1339  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned char));\
1340 } while (0)
1341 #define GRN_INT8_SET(ctx,obj,val) do {\
1342  signed char _val = (signed char)(val);\
1343  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(signed char));\
1344 } while (0)
1345 #define GRN_UINT8_SET(ctx,obj,val) do {\
1346  unsigned char _val = (unsigned char)(val);\
1347  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned char));\
1348 } while (0)
1349 #define GRN_INT16_SET(ctx,obj,val) do {\
1350  signed short _val = (signed short)(val);\
1351  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(signed short));\
1352 } while (0)
1353 #define GRN_UINT16_SET(ctx,obj,val) do {\
1354  unsigned short _val = (unsigned short)(val);\
1355  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned short));\
1356 } while (0)
1357 #define GRN_INT32_SET(ctx,obj,val) do {\
1358  int _val = (int)(val);\
1359  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(int));\
1360 } while (0)
1361 #define GRN_UINT32_SET(ctx,obj,val) do {\
1362  unsigned int _val = (unsigned int)(val);\
1363  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(unsigned int));\
1364 } while (0)
1365 #define GRN_INT64_SET(ctx,obj,val) do {\
1366  long long int _val = (long long int)(val);\
1367  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(long long int));\
1368 } while (0)
1369 #define GRN_UINT64_SET(ctx,obj,val) do {\
1370  long long unsigned int _val = (long long unsigned int)(val);\
1371  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(long long unsigned int));\
1372 } while (0)
1373 #define GRN_FLOAT_SET(ctx,obj,val) do {\
1374  double _val = (double)(val);\
1375  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(double));\
1376 } while (0)
1377 #define GRN_TIME_SET GRN_INT64_SET
1378 #define GRN_RECORD_SET(ctx,obj,val) do {\
1379  grn_id _val = (grn_id)(val);\
1380  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_id));\
1381 } while (0)
1382 #define GRN_PTR_SET(ctx,obj,val) do {\
1383  grn_obj *_val = (grn_obj *)(val);\
1384  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_obj *));\
1385 } while (0)
1386 
1387 #define GRN_GEO_DEGREE2MSEC(degree)\
1388  ((int)((degree) * 3600 * 1000 + ((degree) > 0 ? 0.5 : -0.5)))
1389 #define GRN_GEO_MSEC2DEGREE(msec)\
1390  ((((int)(msec)) / 3600.0) * 0.001)
1391 
1392 #define GRN_GEO_POINT_SET(ctx,obj,_latitude,_longitude) do {\
1393  grn_geo_point _val;\
1394  _val.latitude = (int)(_latitude);\
1395  _val.longitude = (int)(_longitude);\
1396  grn_bulk_write_from((ctx), (obj), (char *)&_val, 0, sizeof(grn_geo_point));\
1397 } while (0)
1398 
1399 #define GRN_BOOL_SET_AT(ctx,obj,offset,val) do {\
1400  unsigned char _val = (unsigned char)(val);\
1401  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1402  (offset), sizeof(unsigned char));\
1403 } while (0)
1404 #define GRN_INT8_SET_AT(ctx,obj,offset,val) do {\
1405  signed char _val = (signed char)(val);\
1406  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1407  (offset) * sizeof(signed char), sizeof(signed char));\
1408 } while (0)
1409 #define GRN_UINT8_SET_AT(ctx,obj,offset,val) do { \
1410  unsigned char _val = (unsigned char)(val);\
1411  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1412  (offset) * sizeof(unsigned char), sizeof(unsigned char));\
1413 } while (0)
1414 #define GRN_INT16_SET_AT(ctx,obj,offset,val) do {\
1415  signed short _val = (signed short)(val);\
1416  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1417  (offset) * sizeof(signed short), sizeof(signed short));\
1418 } while (0)
1419 #define GRN_UINT16_SET_AT(ctx,obj,offset,val) do { \
1420  unsigned short _val = (unsigned short)(val);\
1421  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1422  (offset) * sizeof(unsigned short), sizeof(unsigned short));\
1423 } while (0)
1424 #define GRN_INT32_SET_AT(ctx,obj,offset,val) do {\
1425  int _val = (int)(val);\
1426  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1427  (offset) * sizeof(int), sizeof(int));\
1428 } while (0)
1429 #define GRN_UINT32_SET_AT(ctx,obj,offset,val) do { \
1430  unsigned int _val = (unsigned int)(val);\
1431  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1432  (offset) * sizeof(unsigned int), sizeof(unsigned int));\
1433 } while (0)
1434 #define GRN_INT64_SET_AT(ctx,obj,offset,val) do {\
1435  long long int _val = (long long int)(val);\
1436  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1437  (offset) * sizeof(long long int), sizeof(long long int));\
1438 } while (0)
1439 #define GRN_UINT64_SET_AT(ctx,obj,offset,val) do {\
1440  long long unsigned int _val = (long long unsigned int)(val);\
1441  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1442  (offset) * sizeof(long long unsigned int),\
1443  sizeof(long long unsigned int));\
1444 } while (0)
1445 #define GRN_FLOAT_SET_AT(ctx,obj,offset,val) do {\
1446  double _val = (double)(val);\
1447  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1448  (offset) * sizeof(double), sizeof(double));\
1449 } while (0)
1450 #define GRN_TIME_SET_AT GRN_INT64_SET_AT
1451 #define GRN_RECORD_SET_AT(ctx,obj,offset,val) do {\
1452  grn_id _val = (grn_id)(val);\
1453  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1454  (offset) * sizeof(grn_id), sizeof(grn_id));\
1455 } while (0)
1456 #define GRN_PTR_SET_AT(ctx,obj,offset,val) do {\
1457  grn_obj *_val = (grn_obj *)(val);\
1458  grn_bulk_write_from((ctx), (obj), (char *)&_val,\
1459  (offset) * sizeof(grn_obj *), sizeof(grn_obj *));\
1460 } while (0)
1461 
1462 #define GRN_TIME_USEC_PER_SEC 1000000
1463 #define GRN_TIME_PACK(sec, usec) ((long long int)(sec) * GRN_TIME_USEC_PER_SEC + (usec))
1464 #define GRN_TIME_UNPACK(time_value, sec, usec) do {\
1465  sec = (time_value) / GRN_TIME_USEC_PER_SEC;\
1466  usec = (time_value) % GRN_TIME_USEC_PER_SEC;\
1467 } while (0)
1468 
1469 GRN_API void grn_time_now(grn_ctx *ctx, grn_obj *obj);
1470 
1471 #define GRN_TIME_NOW(ctx,obj) (grn_time_now((ctx), (obj)))
1472 
1473 #define GRN_BOOL_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
1474 #define GRN_INT8_VALUE(obj) (*((signed char *)GRN_BULK_HEAD(obj)))
1475 #define GRN_UINT8_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
1476 #define GRN_INT16_VALUE(obj) (*((signed short *)GRN_BULK_HEAD(obj)))
1477 #define GRN_UINT16_VALUE(obj) (*((unsigned short *)GRN_BULK_HEAD(obj)))
1478 #define GRN_INT32_VALUE(obj) (*((int *)GRN_BULK_HEAD(obj)))
1479 #define GRN_UINT32_VALUE(obj) (*((unsigned int *)GRN_BULK_HEAD(obj)))
1480 #define GRN_INT64_VALUE(obj) (*((long long int *)GRN_BULK_HEAD(obj)))
1481 #define GRN_UINT64_VALUE(obj) (*((long long unsigned int *)GRN_BULK_HEAD(obj)))
1482 #define GRN_FLOAT_VALUE(obj) (*((double *)GRN_BULK_HEAD(obj)))
1483 #define GRN_TIME_VALUE GRN_INT64_VALUE
1484 #define GRN_RECORD_VALUE(obj) (*((grn_id *)GRN_BULK_HEAD(obj)))
1485 #define GRN_PTR_VALUE(obj) (*((grn_obj **)GRN_BULK_HEAD(obj)))
1486 #define GRN_GEO_POINT_VALUE(obj,_latitude,_longitude) do {\
1487  grn_geo_point *_val = (grn_geo_point *)GRN_BULK_HEAD(obj);\
1488  _latitude = _val->latitude;\
1489  _longitude = _val->longitude;\
1490 } while (0)
1491 
1492 #define GRN_BOOL_VALUE_AT(obj,offset) (((unsigned char *)GRN_BULK_HEAD(obj))[offset])
1493 #define GRN_INT8_VALUE_AT(obj,offset) (((signed char *)GRN_BULK_HEAD(obj))[offset])
1494 #define GRN_UINT8_VALUE_AT(obj,offset) (((unsigned char *)GRN_BULK_HEAD(obj))[offset])
1495 #define GRN_INT16_VALUE_AT(obj,offset) (((signed short *)GRN_BULK_HEAD(obj))[offset])
1496 #define GRN_UINT16_VALUE_AT(obj,offset) (((unsigned short *)GRN_BULK_HEAD(obj))[offset])
1497 #define GRN_INT32_VALUE_AT(obj,offset) (((int *)GRN_BULK_HEAD(obj))[offset])
1498 #define GRN_UINT32_VALUE_AT(obj,offset) (((unsigned int *)GRN_BULK_HEAD(obj))[offset])
1499 #define GRN_INT64_VALUE_AT(obj,offset) (((long long int *)GRN_BULK_HEAD(obj))[offset])
1500 #define GRN_UINT64_VALUE_AT(obj,offset) (((long long unsigned int *)GRN_BULK_HEAD(obj))[offset])
1501 #define GRN_FLOAT_VALUE_AT(obj,offset) (((double *)GRN_BULK_HEAD(obj))[offset])
1502 #define GRN_TIME_VALUE_AT GRN_INT64_VALUE_AT
1503 #define GRN_RECORD_VALUE_AT(obj,offset) (((grn_id *)GRN_BULK_HEAD(obj))[offset])
1504 #define GRN_PTR_VALUE_AT(obj,offset) (((grn_obj **)GRN_BULK_HEAD(obj))[offset])
1505 
1506 #define GRN_BOOL_PUT(ctx,obj,val) do {\
1507  unsigned char _val = (unsigned char)(val);\
1508  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned char));\
1509 } while (0)
1510 #define GRN_INT8_PUT(ctx,obj,val) do {\
1511  signed char _val = (signed char)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(signed char));\
1512 } while (0)
1513 #define GRN_UINT8_PUT(ctx,obj,val) do {\
1514  unsigned char _val = (unsigned char)(val);\
1515  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned char));\
1516 } while (0)
1517 #define GRN_INT16_PUT(ctx,obj,val) do {\
1518  signed short _val = (signed short)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(signed short));\
1519 } while (0)
1520 #define GRN_UINT16_PUT(ctx,obj,val) do {\
1521  unsigned short _val = (unsigned short)(val);\
1522  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned short));\
1523 } while (0)
1524 #define GRN_INT32_PUT(ctx,obj,val) do {\
1525  int _val = (int)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(int));\
1526 } while (0)
1527 #define GRN_UINT32_PUT(ctx,obj,val) do {\
1528  unsigned int _val = (unsigned int)(val);\
1529  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(unsigned int));\
1530 } while (0)
1531 #define GRN_INT64_PUT(ctx,obj,val) do {\
1532  long long int _val = (long long int)(val);\
1533  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(long long int));\
1534 } while (0)
1535 #define GRN_UINT64_PUT(ctx,obj,val) do {\
1536  long long unsigned int _val = (long long unsigned int)(val);\
1537  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(long long unsigned int));\
1538 } while (0)
1539 #define GRN_FLOAT_PUT(ctx,obj,val) do {\
1540  double _val = (double)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(double));\
1541 } while (0)
1542 #define GRN_TIME_PUT GRN_INT64_PUT
1543 #define GRN_RECORD_PUT(ctx,obj,val) do {\
1544  grn_id _val = (grn_id)(val); grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_id));\
1545 } while (0)
1546 #define GRN_PTR_PUT(ctx,obj,val) do {\
1547  grn_obj *_val = (grn_obj *)(val);\
1548  grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_obj *));\
1549 } while (0)
1550 
1551 /* grn_str: deprecated. use grn_string instead. */
1552 
1553 typedef struct {
1554  const char *orig;
1555  char *norm;
1556  short *checks;
1557  unsigned char *ctypes;
1558  int flags;
1559  unsigned int orig_blen;
1560  unsigned int norm_blen;
1561  unsigned int length;
1562  grn_encoding encoding;
1563 } grn_str;
1564 
1565 #define GRN_STR_REMOVEBLANK (0x01<<0)
1566 #define GRN_STR_WITH_CTYPES (0x01<<1)
1567 #define GRN_STR_WITH_CHECKS (0x01<<2)
1568 #define GRN_STR_NORMALIZE GRN_OBJ_KEY_NORMALIZE
1569 
1570 GRN_API grn_str *grn_str_open(grn_ctx *ctx, const char *str, unsigned int str_len,
1571  int flags);
1572 GRN_API grn_rc grn_str_close(grn_ctx *ctx, grn_str *nstr);
1573 
1574 /* grn_string */
1575 
1576 #define GRN_STRING_REMOVE_BLANK (0x01<<0)
1577 #define GRN_STRING_WITH_TYPES (0x01<<1)
1578 #define GRN_STRING_WITH_CHECKS (0x01<<2)
1579 #define GRN_STRING_REMOVE_TOKENIZED_DELIMITER (0x01<<3)
1580 
1581 #define GRN_NORMALIZER_AUTO ((grn_obj *)1)
1582 
1583 #define GRN_CHAR_BLANK 0x80
1584 #define GRN_CHAR_IS_BLANK(c) ((c) & (GRN_CHAR_BLANK))
1585 #define GRN_CHAR_TYPE(c) ((c) & 0x7f)
1586 
1587 typedef enum {
1588  GRN_CHAR_NULL = 0,
1589  GRN_CHAR_ALPHA,
1590  GRN_CHAR_DIGIT,
1591  GRN_CHAR_SYMBOL,
1592  GRN_CHAR_HIRAGANA,
1593  GRN_CHAR_KATAKANA,
1594  GRN_CHAR_KANJI,
1595  GRN_CHAR_OTHERS
1596 } grn_char_type;
1597 
1598 GRN_API grn_obj *grn_string_open(grn_ctx *ctx,
1599  const char *string,
1600  unsigned int length_in_bytes,
1601  grn_obj *normalizer, int flags);
1602 GRN_API grn_rc grn_string_get_original(grn_ctx *ctx, grn_obj *string,
1603  const char **original,
1604  unsigned int *length_in_bytes);
1605 GRN_API int grn_string_get_flags(grn_ctx *ctx, grn_obj *string);
1606 GRN_API grn_rc grn_string_get_normalized(grn_ctx *ctx, grn_obj *string,
1607  const char **normalized,
1608  unsigned int *length_in_bytes,
1609  unsigned int *n_characters);
1610 GRN_API grn_rc grn_string_set_normalized(grn_ctx *ctx, grn_obj *string,
1611  char *normalized,
1612  unsigned int length_in_bytes,
1613  unsigned int n_characters);
1614 GRN_API const short *grn_string_get_checks(grn_ctx *ctx, grn_obj *string);
1615 GRN_API grn_rc grn_string_set_checks(grn_ctx *ctx,
1616  grn_obj *string,
1617  short *checks);
1618 GRN_API const unsigned char *grn_string_get_types(grn_ctx *ctx, grn_obj *string);
1619 GRN_API grn_rc grn_string_set_types(grn_ctx *ctx,
1620  grn_obj *string,
1621  unsigned char *types);
1622 GRN_API grn_encoding grn_string_get_encoding(grn_ctx *ctx, grn_obj *string);
1623 
1624 
1625 GRN_API int grn_charlen(grn_ctx *ctx, const char *str, const char *end);
1626 
1627 /* expr */
1628 
1629 GRN_API grn_obj *grn_expr_create(grn_ctx *ctx, const char *name, unsigned int name_size);
1630 GRN_API grn_rc grn_expr_close(grn_ctx *ctx, grn_obj *expr);
1631 GRN_API grn_obj *grn_expr_add_var(grn_ctx *ctx, grn_obj *expr,
1632  const char *name, unsigned int name_size);
1633 GRN_API grn_obj *grn_expr_get_var(grn_ctx *ctx, grn_obj *expr,
1634  const char *name, unsigned int name_size);
1635 GRN_API grn_obj *grn_expr_get_var_by_offset(grn_ctx *ctx, grn_obj *expr, unsigned int offset);
1636 
1637 GRN_API grn_obj *grn_expr_append_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
1638  grn_operator op, int nargs);
1639 GRN_API grn_obj *grn_expr_append_const(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
1640  grn_operator op, int nargs);
1641 GRN_API grn_obj *grn_expr_append_const_str(grn_ctx *ctx, grn_obj *expr,
1642  const char *str, unsigned int str_size,
1643  grn_operator op, int nargs);
1644 GRN_API grn_obj *grn_expr_append_const_int(grn_ctx *ctx, grn_obj *expr, int i,
1645  grn_operator op, int nargs);
1646 GRN_API grn_rc grn_expr_append_op(grn_ctx *ctx, grn_obj *expr, grn_operator op, int nargs);
1647 
1648 GRN_API grn_rc grn_expr_syntax_escape(grn_ctx *ctx,
1649  const char *query, int query_size,
1650  const char *target_characters,
1651  char escape_character,
1652  grn_obj *escaped_query);
1653 GRN_API grn_rc grn_expr_syntax_escape_query(grn_ctx *ctx,
1654  const char *query, int query_size,
1655  grn_obj *escaped_query);
1656 
1657 GRN_API grn_rc grn_expr_compile(grn_ctx *ctx, grn_obj *expr);
1658 GRN_API grn_obj *grn_expr_exec(grn_ctx *ctx, grn_obj *expr, int nargs);
1659 GRN_API grn_rc grn_ctx_push(grn_ctx *ctx, grn_obj *obj);
1660 GRN_API grn_obj *grn_ctx_pop(grn_ctx *ctx);
1661 
1662 GRN_API grn_obj *grn_expr_alloc(grn_ctx *ctx, grn_obj *expr,
1663  grn_id domain, grn_obj_flags flags);
1664 
1665 GRN_API grn_obj *grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
1666  grn_obj *res, grn_operator op);
1667 
1668 GRN_API int grn_obj_columns(grn_ctx *ctx, grn_obj *table,
1669  const char *str, unsigned int str_size, grn_obj *res);
1670 
1671 #define GRN_EXPR_CREATE_FOR_QUERY(ctx,table,expr,var) do {\
1672  if (((expr) = grn_expr_create((ctx), NULL, 0)) &&\
1673  ((var) = grn_expr_add_var((ctx), (expr), NULL, 0))) {\
1674  GRN_RECORD_INIT((var), 0, grn_obj_id((ctx), (table)));\
1675  } else {\
1676  (var) = NULL;\
1677  }\
1678 } while (0)
1679 
1680 typedef unsigned int grn_expr_flags;
1681 
1682 #define GRN_EXPR_SYNTAX_QUERY (0x00)
1683 #define GRN_EXPR_SYNTAX_SCRIPT (0x01)
1684 #define GRN_EXPR_SYNTAX_OUTPUT_COLUMNS (0x20)
1685 #define GRN_EXPR_ALLOW_PRAGMA (0x02)
1686 #define GRN_EXPR_ALLOW_COLUMN (0x04)
1687 #define GRN_EXPR_ALLOW_UPDATE (0x08)
1688 #define GRN_EXPR_ALLOW_LEADING_NOT (0x10)
1689 
1690 GRN_API grn_rc grn_expr_parse(grn_ctx *ctx, grn_obj *expr,
1691  const char *str, unsigned int str_size,
1692  grn_obj *default_column, grn_operator default_mode,
1693  grn_operator default_op, grn_expr_flags flags);
1694 
1695 GRN_API grn_snip *grn_expr_snip(grn_ctx *ctx, grn_obj *expr, int flags,
1696  unsigned int width, unsigned int max_results,
1697  unsigned int n_tags,
1698  const char **opentags, unsigned int *opentag_lens,
1699  const char **closetags, unsigned int *closetag_lens,
1700  grn_snip_mapping *mapping);
1701 
1702 GRN_API grn_table_sort_key *grn_table_sort_key_from_str(grn_ctx *ctx,
1703  const char *str, unsigned int str_size,
1704  grn_obj *table, unsigned int *nkeys);
1705 GRN_API grn_rc grn_table_sort_key_close(grn_ctx *ctx,
1706  grn_table_sort_key *keys, unsigned int nkeys);
1707 
1708 GRN_API grn_bool grn_table_is_grouped(grn_ctx *ctx, grn_obj *table);
1709 
1710 GRN_API unsigned int grn_table_max_n_subrecs(grn_ctx *ctx, grn_obj *table);
1711 
1712 GRN_API grn_obj *grn_table_create_for_group(grn_ctx *ctx,
1713  const char *name,
1714  unsigned int name_size,
1715  const char *path,
1716  grn_obj *group_key,
1717  grn_obj *value_type,
1718  unsigned int max_n_subrecs);
1719 
1720 GRN_API unsigned int grn_table_get_subrecs(grn_ctx *ctx, grn_obj *table,
1721  grn_id id, grn_id *subrecbuf,
1722  int *scorebuf, int buf_size);
1723 
1724 GRN_API grn_obj *grn_table_tokenize(grn_ctx *ctx, grn_obj *table,
1725  const char *str, unsigned int str_len,
1726  grn_obj *buf, grn_bool addp);
1727 
1728 GRN_API grn_rc grn_load(grn_ctx *ctx, grn_content_type input_type,
1729  const char *table, unsigned int table_len,
1730  const char *columns, unsigned int columns_len,
1731  const char *values, unsigned int values_len,
1732  const char *ifexists, unsigned int ifexists_len,
1733  const char *each, unsigned int each_len);
1734 
1735 #define GRN_CTX_MORE (0x01<<0)
1736 #define GRN_CTX_TAIL (0x01<<1)
1737 #define GRN_CTX_HEAD (0x01<<2)
1738 #define GRN_CTX_QUIET (0x01<<3)
1739 #define GRN_CTX_QUIT (0x01<<4)
1740 
1741 GRN_API grn_rc grn_ctx_connect(grn_ctx *ctx, const char *host, int port, int flags);
1742 GRN_API unsigned int grn_ctx_send(grn_ctx *ctx, const char *str, unsigned int str_len, int flags);
1743 GRN_API unsigned int grn_ctx_recv(grn_ctx *ctx, char **str, unsigned int *str_len, int *flags);
1744 
1745 typedef struct _grn_ctx_info grn_ctx_info;
1746 
1747 struct _grn_ctx_info {
1748  int fd;
1749  unsigned int com_status;
1750  grn_obj *outbuf;
1751  unsigned char stat;
1752 };
1753 
1754 GRN_API grn_rc grn_ctx_info_get(grn_ctx *ctx, grn_ctx_info *info);
1755 
1756 GRN_API grn_rc grn_set_segv_handler(void);
1757 GRN_API grn_rc grn_set_int_handler(void);
1758 GRN_API grn_rc grn_set_term_handler(void);
1759 
1760 /* hash */
1761 
1762 typedef struct _grn_hash grn_hash;
1763 typedef struct _grn_hash_cursor grn_hash_cursor;
1764 
1765 GRN_API grn_hash *grn_hash_create(grn_ctx *ctx, const char *path, unsigned int key_size,
1766  unsigned int value_size, unsigned int flags);
1767 
1768 GRN_API grn_hash *grn_hash_open(grn_ctx *ctx, const char *path);
1769 
1770 GRN_API grn_rc grn_hash_close(grn_ctx *ctx, grn_hash *hash);
1771 
1772 GRN_API grn_id grn_hash_add(grn_ctx *ctx, grn_hash *hash, const void *key,
1773  unsigned int key_size, void **value, int *added);
1774 GRN_API grn_id grn_hash_get(grn_ctx *ctx, grn_hash *hash, const void *key,
1775  unsigned int key_size, void **value);
1776 
1777 GRN_API int grn_hash_get_key(grn_ctx *ctx, grn_hash *hash, grn_id id, void *keybuf, int bufsize);
1778 GRN_API int grn_hash_get_key2(grn_ctx *ctx, grn_hash *hash, grn_id id, grn_obj *bulk);
1779 GRN_API int grn_hash_get_value(grn_ctx *ctx, grn_hash *hash, grn_id id, void *valuebuf);
1780 GRN_API grn_rc grn_hash_set_value(grn_ctx *ctx, grn_hash *hash, grn_id id,
1781  const void *value, int flags);
1782 
1783 typedef struct _grn_table_delete_optarg grn_table_delete_optarg;
1784 
1785 struct _grn_table_delete_optarg {
1786  int flags;
1787  int (*func)(grn_ctx *ctx, grn_obj *, grn_id, void *);
1788  void *func_arg;
1789 };
1790 
1791 GRN_API grn_rc grn_hash_delete_by_id(grn_ctx *ctx, grn_hash *hash, grn_id id,
1792  grn_table_delete_optarg *optarg);
1793 GRN_API grn_rc grn_hash_delete(grn_ctx *ctx, grn_hash *hash,
1794  const void *key, unsigned int key_size,
1795  grn_table_delete_optarg *optarg);
1796 
1797 GRN_API grn_hash_cursor *grn_hash_cursor_open(grn_ctx *ctx, grn_hash *hash,
1798  const void *min, unsigned int min_size,
1799  const void *max, unsigned int max_size,
1800  int offset, int limit, int flags);
1801 GRN_API grn_id grn_hash_cursor_next(grn_ctx *ctx, grn_hash_cursor *c);
1802 GRN_API void grn_hash_cursor_close(grn_ctx *ctx, grn_hash_cursor *c);
1803 
1804 GRN_API int grn_hash_cursor_get_key(grn_ctx *ctx, grn_hash_cursor *c, void **key);
1805 GRN_API int grn_hash_cursor_get_value(grn_ctx *ctx, grn_hash_cursor *c, void **value);
1806 GRN_API grn_rc grn_hash_cursor_set_value(grn_ctx *ctx, grn_hash_cursor *c,
1807  const void *value, int flags);
1808 
1809 GRN_API int grn_hash_cursor_get_key_value(grn_ctx *ctx, grn_hash_cursor *c,
1810  void **key, unsigned int *key_size, void **value);
1811 
1812 GRN_API grn_rc grn_hash_cursor_delete(grn_ctx *ctx, grn_hash_cursor *c,
1813  grn_table_delete_optarg *optarg);
1814 
1815 #define GRN_HASH_EACH(ctx,hash,id,key,key_size,value,block) do {\
1816  grn_hash_cursor *_sc = grn_hash_cursor_open(ctx, hash, NULL, 0, NULL, 0, 0, -1, 0); \
1817  if (_sc) {\
1818  grn_id id;\
1819  while ((id = grn_hash_cursor_next(ctx, _sc))) {\
1820  grn_hash_cursor_get_key_value(ctx, _sc, (void **)(key),\
1821  (key_size), (void **)(value));\
1822  block\
1823  }\
1824  grn_hash_cursor_close(ctx, _sc);\
1825  }\
1826 } while (0)
1827 
1828 /* array */
1829 
1830 typedef struct _grn_array grn_array;
1831 typedef struct _grn_array_cursor grn_array_cursor;
1832 
1833 GRN_API grn_array *grn_array_create(grn_ctx *ctx, const char *path,
1834  unsigned int value_size, unsigned int flags);
1835 GRN_API grn_array *grn_array_open(grn_ctx *ctx, const char *path);
1836 GRN_API grn_rc grn_array_close(grn_ctx *ctx, grn_array *array);
1837 GRN_API grn_id grn_array_add(grn_ctx *ctx, grn_array *array, void **value);
1838 GRN_API grn_id grn_array_push(grn_ctx *ctx, grn_array *array,
1839  void (*func)(grn_ctx *ctx, grn_array *array,
1840  grn_id id, void *func_arg),
1841  void *func_arg);
1842 GRN_API grn_id grn_array_pull(grn_ctx *ctx, grn_array *array, grn_bool blockp,
1843  void (*func)(grn_ctx *ctx, grn_array *array,
1844  grn_id id, void *func_arg),
1845  void *func_arg);
1846 GRN_API void grn_array_unblock(grn_ctx *ctx, grn_array *array);
1847 GRN_API int grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id, void *valuebuf);
1848 GRN_API grn_rc grn_array_set_value(grn_ctx *ctx, grn_array *array, grn_id id,
1849  const void *value, int flags);
1850 GRN_API grn_array_cursor *grn_array_cursor_open(grn_ctx *ctx, grn_array *array,
1851  grn_id min, grn_id max,
1852  int offset, int limit, int flags);
1853 GRN_API grn_id grn_array_cursor_next(grn_ctx *ctx, grn_array_cursor *cursor);
1854 GRN_API int grn_array_cursor_get_value(grn_ctx *ctx, grn_array_cursor *cursor, void **value);
1855 GRN_API grn_rc grn_array_cursor_set_value(grn_ctx *ctx, grn_array_cursor *cursor,
1856  const void *value, int flags);
1857 GRN_API grn_rc grn_array_cursor_delete(grn_ctx *ctx, grn_array_cursor *cursor,
1858  grn_table_delete_optarg *optarg);
1859 GRN_API void grn_array_cursor_close(grn_ctx *ctx, grn_array_cursor *cursor);
1860 GRN_API grn_rc grn_array_delete_by_id(grn_ctx *ctx, grn_array *array, grn_id id,
1861  grn_table_delete_optarg *optarg);
1862 
1863 GRN_API grn_id grn_array_next(grn_ctx *ctx, grn_array *array, grn_id id);
1864 
1865 GRN_API void *_grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id);
1866 
1867 #define GRN_ARRAY_EACH(ctx,array,head,tail,id,value,block) do {\
1868  grn_array_cursor *_sc = grn_array_cursor_open(ctx, array, head, tail, 0, -1, 0); \
1869  if (_sc) {\
1870  grn_id id;\
1871  while ((id = grn_array_cursor_next(ctx, _sc))) {\
1872  grn_array_cursor_get_value(ctx, _sc, (void **)(value));\
1873  block\
1874  }\
1875  grn_array_cursor_close(ctx, _sc); \
1876  }\
1877 } while (0)
1878 
1879 /* pat */
1880 
1881 typedef struct _grn_pat grn_pat;
1882 typedef struct _grn_pat_cursor grn_pat_cursor;
1883 
1884 GRN_API grn_pat *grn_pat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
1885  unsigned int value_size, unsigned int flags);
1886 
1887 GRN_API grn_pat *grn_pat_open(grn_ctx *ctx, const char *path);
1888 
1889 GRN_API grn_rc grn_pat_close(grn_ctx *ctx, grn_pat *pat);
1890 
1891 GRN_API grn_rc grn_pat_remove(grn_ctx *ctx, const char *path);
1892 
1893 GRN_API grn_id grn_pat_get(grn_ctx *ctx, grn_pat *pat, const void *key,
1894  unsigned int key_size, void **value);
1895 GRN_API grn_id grn_pat_add(grn_ctx *ctx, grn_pat *pat, const void *key,
1896  unsigned int key_size, void **value, int *added);
1897 
1898 GRN_API int grn_pat_get_key(grn_ctx *ctx, grn_pat *pat, grn_id id, void *keybuf, int bufsize);
1899 GRN_API int grn_pat_get_key2(grn_ctx *ctx, grn_pat *pat, grn_id id, grn_obj *bulk);
1900 GRN_API int grn_pat_get_value(grn_ctx *ctx, grn_pat *pat, grn_id id, void *valuebuf);
1901 GRN_API grn_rc grn_pat_set_value(grn_ctx *ctx, grn_pat *pat, grn_id id,
1902  const void *value, int flags);
1903 
1904 GRN_API grn_rc grn_pat_delete_by_id(grn_ctx *ctx, grn_pat *pat, grn_id id,
1905  grn_table_delete_optarg *optarg);
1906 GRN_API grn_rc grn_pat_delete(grn_ctx *ctx, grn_pat *pat, const void *key, unsigned int key_size,
1907  grn_table_delete_optarg *optarg);
1908 GRN_API int grn_pat_delete_with_sis(grn_ctx *ctx, grn_pat *pat, grn_id id,
1909  grn_table_delete_optarg *optarg);
1910 
1911 typedef struct _grn_pat_scan_hit grn_pat_scan_hit;
1912 
1913 struct _grn_pat_scan_hit {
1914  grn_id id;
1915  unsigned int offset;
1916  unsigned int length;
1917 };
1918 
1919 GRN_API int grn_pat_scan(grn_ctx *ctx, grn_pat *pat, const char *str, unsigned int str_len,
1920  grn_pat_scan_hit *sh, unsigned int sh_size, const char **rest);
1921 
1922 GRN_API grn_rc grn_pat_prefix_search(grn_ctx *ctx, grn_pat *pat,
1923  const void *key, unsigned int key_size, grn_hash *h);
1924 GRN_API grn_rc grn_pat_suffix_search(grn_ctx *ctx, grn_pat *pat,
1925  const void *key, unsigned int key_size, grn_hash *h);
1926 GRN_API grn_id grn_pat_lcp_search(grn_ctx *ctx, grn_pat *pat,
1927  const void *key, unsigned int key_size);
1928 
1929 GRN_API unsigned int grn_pat_size(grn_ctx *ctx, grn_pat *pat);
1930 
1931 GRN_API grn_pat_cursor *grn_pat_cursor_open(grn_ctx *ctx, grn_pat *pat,
1932  const void *min, unsigned int min_size,
1933  const void *max, unsigned int max_size,
1934  int offset, int limit, int flags);
1935 GRN_API grn_id grn_pat_cursor_next(grn_ctx *ctx, grn_pat_cursor *c);
1936 GRN_API void grn_pat_cursor_close(grn_ctx *ctx, grn_pat_cursor *c);
1937 
1938 GRN_API int grn_pat_cursor_get_key(grn_ctx *ctx, grn_pat_cursor *c, void **key);
1939 GRN_API int grn_pat_cursor_get_value(grn_ctx *ctx, grn_pat_cursor *c, void **value);
1940 
1941 GRN_API int grn_pat_cursor_get_key_value(grn_ctx *ctx, grn_pat_cursor *c,
1942  void **key, unsigned int *key_size, void **value);
1943 GRN_API grn_rc grn_pat_cursor_set_value(grn_ctx *ctx, grn_pat_cursor *c,
1944  const void *value, int flags);
1945 GRN_API grn_rc grn_pat_cursor_delete(grn_ctx *ctx, grn_pat_cursor *c,
1946  grn_table_delete_optarg *optarg);
1947 
1948 #define GRN_PAT_EACH(ctx,pat,id,key,key_size,value,block) do { \
1949  grn_pat_cursor *_sc = grn_pat_cursor_open(ctx, pat, NULL, 0, NULL, 0, 0, -1, 0); \
1950  if (_sc) {\
1951  grn_id id;\
1952  while ((id = grn_pat_cursor_next(ctx, _sc))) {\
1953  grn_pat_cursor_get_key_value(ctx, _sc, (void **)(key),\
1954  (key_size), (void **)(value));\
1955  block\
1956  }\
1957  grn_pat_cursor_close(ctx, _sc);\
1958  }\
1959 } while (0)
1960 
1961 /* dat */
1962 
1963 typedef struct _grn_dat grn_dat;
1964 typedef struct _grn_dat_cursor grn_dat_cursor;
1965 
1966 GRN_API grn_dat *grn_dat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
1967  unsigned int value_size, unsigned int flags);
1968 
1969 GRN_API grn_dat *grn_dat_open(grn_ctx *ctx, const char *path);
1970 
1971 GRN_API grn_rc grn_dat_close(grn_ctx *ctx, grn_dat *dat);
1972 
1973 GRN_API grn_rc grn_dat_remove(grn_ctx *ctx, const char *path);
1974 
1975 GRN_API grn_id grn_dat_get(grn_ctx *ctx, grn_dat *dat, const void *key,
1976  unsigned int key_size, void **value);
1977 GRN_API grn_id grn_dat_add(grn_ctx *ctx, grn_dat *dat, const void *key,
1978  unsigned int key_size, void **value, int *added);
1979 
1980 GRN_API int grn_dat_get_key(grn_ctx *ctx, grn_dat *dat, grn_id id, void *keybuf, int bufsize);
1981 GRN_API int grn_dat_get_key2(grn_ctx *ctx, grn_dat *dat, grn_id id, grn_obj *bulk);
1982 
1983 GRN_API grn_rc grn_dat_delete_by_id(grn_ctx *ctx, grn_dat *dat, grn_id id,
1984  grn_table_delete_optarg *optarg);
1985 GRN_API grn_rc grn_dat_delete(grn_ctx *ctx, grn_dat *dat, const void *key, unsigned int key_size,
1986  grn_table_delete_optarg *optarg);
1987 
1988 GRN_API grn_rc grn_dat_update_by_id(grn_ctx *ctx, grn_dat *dat, grn_id src_key_id,
1989  const void *dest_key, unsigned int dest_key_size);
1990 GRN_API grn_rc grn_dat_update(grn_ctx *ctx, grn_dat *dat,
1991  const void *src_key, unsigned int src_key_size,
1992  const void *dest_key, unsigned int dest_key_size);
1993 
1994 GRN_API unsigned int grn_dat_size(grn_ctx *ctx, grn_dat *dat);
1995 
1996 GRN_API grn_dat_cursor *grn_dat_cursor_open(grn_ctx *ctx, grn_dat *dat,
1997  const void *min, unsigned int min_size,
1998  const void *max, unsigned int max_size,
1999  int offset, int limit, int flags);
2000 GRN_API grn_id grn_dat_cursor_next(grn_ctx *ctx, grn_dat_cursor *c);
2001 GRN_API void grn_dat_cursor_close(grn_ctx *ctx, grn_dat_cursor *c);
2002 
2003 GRN_API int grn_dat_cursor_get_key(grn_ctx *ctx, grn_dat_cursor *c, const void **key);
2004 GRN_API grn_rc grn_dat_cursor_delete(grn_ctx *ctx, grn_dat_cursor *c,
2005  grn_table_delete_optarg *optarg);
2006 
2007 #define GRN_DAT_EACH(ctx,dat,id,key,key_size,block) do {\
2008  grn_dat_cursor *_sc = grn_dat_cursor_open(ctx, dat, NULL, 0, NULL, 0, 0, -1, 0);\
2009  if (_sc) {\
2010  grn_id id;\
2011  unsigned int *_ks = (key_size);\
2012  if (_ks) {\
2013  while ((id = grn_dat_cursor_next(ctx, _sc))) {\
2014  int _ks_raw = grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
2015  *(_ks) = (unsigned int)_ks_raw;\
2016  block\
2017  }\
2018  } else {\
2019  while ((id = grn_dat_cursor_next(ctx, _sc))) {\
2020  grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
2021  block\
2022  }\
2023  }\
2024  grn_dat_cursor_close(ctx, _sc);\
2025  }\
2026 } while (0)
2027 
2028 /* buffered index builder */
2029 
2030 typedef struct _grn_ii grn_ii;
2031 typedef struct _grn_ii_buffer grn_ii_buffer;
2032 
2033 grn_ii_buffer *grn_ii_buffer_open(grn_ctx *ctx, grn_ii *ii,
2034  long long unsigned int update_buffer_size);
2035 grn_rc grn_ii_buffer_append(grn_ctx *ctx, grn_ii_buffer *ii_buffer,
2036  grn_id rid, unsigned int section, grn_obj *value);
2037 grn_rc grn_ii_buffer_commit(grn_ctx *ctx, grn_ii_buffer *ii_buffer);
2038 grn_rc grn_ii_buffer_close(grn_ctx *ctx, grn_ii_buffer *ii_buffer);
2039 
2040 
2041 #ifdef __cplusplus
2042 }
2043 #endif
2044 
2045 #endif /* GROONGA_H */
Generated on Sun Nov 10 2013 09:49:01 for Groonga 3.0.9 Source Code Document by   doxygen 1.8.1.2