1#![allow(dead_code,
4 non_camel_case_types,
5 non_upper_case_globals,
6 non_snake_case)]
7pub type int8_t = i8;
8pub type int16_t = i16;
9pub type int32_t = i32;
10pub type int64_t = i64;
11pub type uint8_t = u8;
12pub type uint16_t = u16;
13pub type uint32_t = u32;
14pub type uint64_t = u64;
15pub type size_t = usize;
16pub type __off_t = ::std::os::raw::c_long;
17pub type off_t = __off_t;
18
19pub type grn_id = ::std::os::raw::c_uint;
20pub type grn_bool = uint8_t;
21#[derive(Copy, Clone, PartialEq, Eq)]
22#[repr(i32)]
23#[derive(Debug)]
24pub enum grn_rc {
25 GRN_SUCCESS = 0,
26 GRN_END_OF_DATA = 1,
27 GRN_UNKNOWN_ERROR = -1,
28 GRN_OPERATION_NOT_PERMITTED = -2,
29 GRN_NO_SUCH_FILE_OR_DIRECTORY = -3,
30 GRN_NO_SUCH_PROCESS = -4,
31 GRN_INTERRUPTED_FUNCTION_CALL = -5,
32 GRN_INPUT_OUTPUT_ERROR = -6,
33 GRN_NO_SUCH_DEVICE_OR_ADDRESS = -7,
34 GRN_ARG_LIST_TOO_LONG = -8,
35 GRN_EXEC_FORMAT_ERROR = -9,
36 GRN_BAD_FILE_DESCRIPTOR = -10,
37 GRN_NO_CHILD_PROCESSES = -11,
38 GRN_RESOURCE_TEMPORARILY_UNAVAILABLE = -12,
39 GRN_NOT_ENOUGH_SPACE = -13,
40 GRN_PERMISSION_DENIED = -14,
41 GRN_BAD_ADDRESS = -15,
42 GRN_RESOURCE_BUSY = -16,
43 GRN_FILE_EXISTS = -17,
44 GRN_IMPROPER_LINK = -18,
45 GRN_NO_SUCH_DEVICE = -19,
46 GRN_NOT_A_DIRECTORY = -20,
47 GRN_IS_A_DIRECTORY = -21,
48 GRN_INVALID_ARGUMENT = -22,
49 GRN_TOO_MANY_OPEN_FILES_IN_SYSTEM = -23,
50 GRN_TOO_MANY_OPEN_FILES = -24,
51 GRN_INAPPROPRIATE_I_O_CONTROL_OPERATION = -25,
52 GRN_FILE_TOO_LARGE = -26,
53 GRN_NO_SPACE_LEFT_ON_DEVICE = -27,
54 GRN_INVALID_SEEK = -28,
55 GRN_READ_ONLY_FILE_SYSTEM = -29,
56 GRN_TOO_MANY_LINKS = -30,
57 GRN_BROKEN_PIPE = -31,
58 GRN_DOMAIN_ERROR = -32,
59 GRN_RESULT_TOO_LARGE = -33,
60 GRN_RESOURCE_DEADLOCK_AVOIDED = -34,
61 GRN_NO_MEMORY_AVAILABLE = -35,
62 GRN_FILENAME_TOO_LONG = -36,
63 GRN_NO_LOCKS_AVAILABLE = -37,
64 GRN_FUNCTION_NOT_IMPLEMENTED = -38,
65 GRN_DIRECTORY_NOT_EMPTY = -39,
66 GRN_ILLEGAL_BYTE_SEQUENCE = -40,
67 GRN_SOCKET_NOT_INITIALIZED = -41,
68 GRN_OPERATION_WOULD_BLOCK = -42,
69 GRN_ADDRESS_IS_NOT_AVAILABLE = -43,
70 GRN_NETWORK_IS_DOWN = -44,
71 GRN_NO_BUFFER = -45,
72 GRN_SOCKET_IS_ALREADY_CONNECTED = -46,
73 GRN_SOCKET_IS_NOT_CONNECTED = -47,
74 GRN_SOCKET_IS_ALREADY_SHUTDOWNED = -48,
75 GRN_OPERATION_TIMEOUT = -49,
76 GRN_CONNECTION_REFUSED = -50,
77 GRN_RANGE_ERROR = -51,
78 GRN_TOKENIZER_ERROR = -52,
79 GRN_FILE_CORRUPT = -53,
80 GRN_INVALID_FORMAT = -54,
81 GRN_OBJECT_CORRUPT = -55,
82 GRN_TOO_MANY_SYMBOLIC_LINKS = -56,
83 GRN_NOT_SOCKET = -57,
84 GRN_OPERATION_NOT_SUPPORTED = -58,
85 GRN_ADDRESS_IS_IN_USE = -59,
86 GRN_ZLIB_ERROR = -60,
87 GRN_LZ4_ERROR = -61,
88 GRN_STACK_OVER_FLOW = -62,
89 GRN_SYNTAX_ERROR = -63,
90 GRN_RETRY_MAX = -64,
91 GRN_INCOMPATIBLE_FILE_FORMAT = -65,
92 GRN_UPDATE_NOT_ALLOWED = -66,
93 GRN_TOO_SMALL_OFFSET = -67,
94 GRN_TOO_LARGE_OFFSET = -68,
95 GRN_TOO_SMALL_LIMIT = -69,
96 GRN_CAS_ERROR = -70,
97 GRN_UNSUPPORTED_COMMAND_VERSION = -71,
98 GRN_NORMALIZER_ERROR = -72,
99 GRN_TOKEN_FILTER_ERROR = -73,
100 GRN_COMMAND_ERROR = -74,
101 GRN_PLUGIN_ERROR = -75,
102 GRN_SCORER_ERROR = -76,
103 GRN_CANCEL = -77,
104 GRN_WINDOW_FUNCTION_ERROR = -78,
105}
106#[derive(Copy, Clone, PartialEq, Eq)]
107#[repr(u32)]
108#[derive(Debug)]
109pub enum grn_encoding {
110 GRN_ENC_DEFAULT = 0,
111 GRN_ENC_NONE = 1,
112 GRN_ENC_EUC_JP = 2,
113 GRN_ENC_UTF8 = 3,
114 GRN_ENC_SJIS = 4,
115 GRN_ENC_LATIN1 = 5,
116 GRN_ENC_KOI8R = 6,
117}
118#[derive(Copy, Clone)]
119#[repr(u32)]
120#[derive(Debug)]
121pub enum grn_command_version {
122 GRN_COMMAND_VERSION_DEFAULT = 0,
123 GRN_COMMAND_VERSION_1 = 1,
124 GRN_COMMAND_VERSION_2 = 2,
125 GRN_COMMAND_VERSION_3 = 3,
126}
127#[derive(Copy, Clone, PartialEq, Eq)]
128#[repr(u32)]
129#[derive(Debug)]
130pub enum grn_log_level {
131 GRN_LOG_NONE = 0,
132 GRN_LOG_EMERG = 1,
133 GRN_LOG_ALERT = 2,
134 GRN_LOG_CRIT = 3,
135 GRN_LOG_ERROR = 4,
136 GRN_LOG_WARNING = 5,
137 GRN_LOG_NOTICE = 6,
138 GRN_LOG_INFO = 7,
139 GRN_LOG_DEBUG = 8,
140 GRN_LOG_DUMP = 9,
141}
142#[derive(Copy, Clone, PartialEq, Eq)]
143#[repr(u32)]
144#[derive(Debug)]
145pub enum grn_content_type {
146 GRN_CONTENT_NONE = 0,
147 GRN_CONTENT_TSV = 1,
148 GRN_CONTENT_JSON = 2,
149 GRN_CONTENT_XML = 3,
150 GRN_CONTENT_MSGPACK = 4,
151 GRN_CONTENT_GROONGA_COMMAND_LIST = 5,
152}
153pub type grn_obj = _grn_obj;
154pub type grn_ctx = _grn_ctx;
155#[repr(C)]
156#[derive(Copy, Clone)]
157#[derive(Debug)]
158pub struct grn_user_data {
159 pub _bindgen_data_: [u64; 1usize],
160}
161impl grn_user_data {
162 pub unsafe fn int_value(&mut self) -> *mut ::std::os::raw::c_int {
163 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
164 ::std::mem::transmute(raw.offset(0))
165 }
166 pub unsafe fn id(&mut self) -> *mut grn_id {
167 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
168 ::std::mem::transmute(raw.offset(0))
169 }
170 pub unsafe fn ptr(&mut self) -> *mut *mut ::std::os::raw::c_void {
171 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
172 ::std::mem::transmute(raw.offset(0))
173 }
174}
175impl ::std::default::Default for grn_user_data {
176 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
177}
178pub type grn_proc_func =
179 ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
180 nargs: ::std::os::raw::c_int,
181 args: *mut *mut grn_obj,
182 user_data: *mut grn_user_data)
183 -> *mut grn_obj>;
184pub enum _grn_ctx_impl { }
185#[repr(C)]
186#[derive(Copy)]
187pub struct _grn_ctx {
188 pub rc: grn_rc,
189 pub flags: ::std::os::raw::c_int,
190 pub encoding: grn_encoding,
191 pub ntrace: ::std::os::raw::c_uchar,
192 pub errlvl: ::std::os::raw::c_uchar,
193 pub stat: ::std::os::raw::c_uchar,
194 pub seqno: ::std::os::raw::c_uint,
195 pub subno: ::std::os::raw::c_uint,
196 pub seqno2: ::std::os::raw::c_uint,
197 pub errline: ::std::os::raw::c_uint,
198 pub user_data: grn_user_data,
199 pub prev: *mut grn_ctx,
200 pub next: *mut grn_ctx,
201 pub errfile: *const ::std::os::raw::c_char,
202 pub errfunc: *const ::std::os::raw::c_char,
203 pub impl_: *mut _grn_ctx_impl,
204 pub trace: [*mut ::std::os::raw::c_void; 16usize],
205 pub errbuf: [::std::os::raw::c_char; 128usize],
206}
207impl ::std::clone::Clone for _grn_ctx {
208 fn clone(&self) -> Self { *self }
209}
210impl ::std::default::Default for _grn_ctx {
211 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
212}
213pub enum _grn_cache { }
214pub type grn_cache = _grn_cache;
215pub type grn_obj_flags = uint16_t;
216pub type grn_table_flags = uint32_t;
217pub type grn_column_flags = uint32_t;
218pub type grn_section = _grn_section;
219pub type grn_obj_header = _grn_obj_header;
220#[repr(C)]
221#[derive(Copy, Clone)]
222#[derive(Debug)]
223pub struct _grn_section {
224 pub offset: ::std::os::raw::c_uint,
225 pub length: ::std::os::raw::c_uint,
226 pub weight: ::std::os::raw::c_uint,
227 pub domain: grn_id,
228}
229impl ::std::default::Default for _grn_section {
230 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
231}
232#[repr(C)]
233#[derive(Copy, Clone)]
234#[derive(Debug)]
235pub struct _grn_obj_header {
236 pub type_: ::std::os::raw::c_uchar,
237 pub impl_flags: ::std::os::raw::c_uchar,
238 pub flags: grn_obj_flags,
239 pub domain: grn_id,
240}
241impl ::std::default::Default for _grn_obj_header {
242 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
243}
244#[repr(C)]
245#[derive(Copy, Clone)]
246#[derive(Debug)]
247pub struct _grn_obj {
248 pub header: grn_obj_header,
249 pub u: Union_Unnamed3,
250}
251impl ::std::default::Default for _grn_obj {
252 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
253}
254#[repr(C)]
255#[derive(Copy, Clone)]
256#[derive(Debug)]
257pub struct Union_Unnamed3 {
258 pub _bindgen_data_: [u64; 3usize],
259}
260impl Union_Unnamed3 {
261 pub unsafe fn b(&mut self) -> *mut Struct_Unnamed4 {
262 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
263 ::std::mem::transmute(raw.offset(0))
264 }
265 pub unsafe fn v(&mut self) -> *mut Struct_Unnamed5 {
266 let raw: *mut u8 = ::std::mem::transmute(&self._bindgen_data_);
267 ::std::mem::transmute(raw.offset(0))
268 }
269}
270impl ::std::default::Default for Union_Unnamed3 {
271 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
272}
273#[repr(C)]
274#[derive(Copy, Clone)]
275#[derive(Debug)]
276pub struct Struct_Unnamed4 {
277 pub head: *mut ::std::os::raw::c_char,
278 pub curr: *mut ::std::os::raw::c_char,
279 pub tail: *mut ::std::os::raw::c_char,
280}
281impl ::std::default::Default for Struct_Unnamed4 {
282 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
283}
284#[repr(C)]
285#[derive(Copy, Clone)]
286#[derive(Debug)]
287pub struct Struct_Unnamed5 {
288 pub body: *mut grn_obj,
289 pub sections: *mut grn_section,
290 pub n_sections: ::std::os::raw::c_int,
291}
292impl ::std::default::Default for Struct_Unnamed5 {
293 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
294}
295#[derive(Copy, Clone, PartialEq, Eq)]
296#[repr(u32)]
297#[derive(Debug)]
298pub enum grn_builtin_type {
299 GRN_DB_VOID = 0,
300 GRN_DB_DB = 1,
301 GRN_DB_OBJECT = 2,
302 GRN_DB_BOOL = 3,
303 GRN_DB_INT8 = 4,
304 GRN_DB_UINT8 = 5,
305 GRN_DB_INT16 = 6,
306 GRN_DB_UINT16 = 7,
307 GRN_DB_INT32 = 8,
308 GRN_DB_UINT32 = 9,
309 GRN_DB_INT64 = 10,
310 GRN_DB_UINT64 = 11,
311 GRN_DB_FLOAT = 12,
312 GRN_DB_TIME = 13,
313 GRN_DB_SHORT_TEXT = 14,
314 GRN_DB_TEXT = 15,
315 GRN_DB_LONG_TEXT = 16,
316 GRN_DB_TOKYO_GEO_POINT = 17,
317 GRN_DB_WGS84_GEO_POINT = 18,
318}
319#[derive(Copy, Clone)]
320#[repr(u32)]
321#[derive(Debug)]
322pub enum grn_builtin_tokenizer {
323 GRN_DB_MECAB = 64,
324 GRN_DB_DELIMIT = 65,
325 GRN_DB_UNIGRAM = 66,
326 GRN_DB_BIGRAM = 67,
327 GRN_DB_TRIGRAM = 68,
328}
329#[repr(C)]
330#[derive(Copy, Clone)]
331#[derive(Debug)]
332pub struct grn_expr_var {
333 pub name: *const ::std::os::raw::c_char,
334 pub name_size: ::std::os::raw::c_uint,
335 pub value: grn_obj,
336}
337impl ::std::default::Default for grn_expr_var {
338 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
339}
340pub type grn_plugin_func =
341 ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx) -> grn_rc>;
342#[derive(Copy, Clone)]
343#[repr(u32)]
344#[derive(Debug)]
345pub enum grn_proc_type {
346 GRN_PROC_INVALID = 0,
347 GRN_PROC_TOKENIZER = 1,
348 GRN_PROC_COMMAND = 2,
349 GRN_PROC_FUNCTION = 3,
350 GRN_PROC_HOOK = 4,
351 GRN_PROC_NORMALIZER = 5,
352 GRN_PROC_TOKEN_FILTER = 6,
353 GRN_PROC_SCORER = 7,
354 GRN_PROC_WINDOW_FUNCTION = 8,
355}
356pub type grn_table_cursor = grn_obj;
357#[repr(C)]
358#[derive(Copy, Clone)]
359#[derive(Debug)]
360pub struct grn_posting {
361 pub rid: grn_id,
362 pub sid: uint32_t,
363 pub pos: uint32_t,
364 pub tf: uint32_t,
365 pub weight: uint32_t,
366 pub rest: uint32_t,
367}
368impl ::std::default::Default for grn_posting {
369 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
370}
371#[derive(Copy, Clone, PartialEq, Eq)]
372#[repr(u32)]
373#[derive(Debug)]
374pub enum grn_operator {
375 GRN_OP_PUSH = 0,
376 GRN_OP_POP = 1,
377 GRN_OP_NOP = 2,
378 GRN_OP_CALL = 3,
379 GRN_OP_INTERN = 4,
380 GRN_OP_GET_REF = 5,
381 GRN_OP_GET_VALUE = 6,
382 GRN_OP_AND = 7,
383 GRN_OP_AND_NOT = 8,
384 GRN_OP_OR = 9,
385 GRN_OP_ASSIGN = 10,
386 GRN_OP_STAR_ASSIGN = 11,
387 GRN_OP_SLASH_ASSIGN = 12,
388 GRN_OP_MOD_ASSIGN = 13,
389 GRN_OP_PLUS_ASSIGN = 14,
390 GRN_OP_MINUS_ASSIGN = 15,
391 GRN_OP_SHIFTL_ASSIGN = 16,
392 GRN_OP_SHIFTR_ASSIGN = 17,
393 GRN_OP_SHIFTRR_ASSIGN = 18,
394 GRN_OP_AND_ASSIGN = 19,
395 GRN_OP_XOR_ASSIGN = 20,
396 GRN_OP_OR_ASSIGN = 21,
397 GRN_OP_JUMP = 22,
398 GRN_OP_CJUMP = 23,
399 GRN_OP_COMMA = 24,
400 GRN_OP_BITWISE_OR = 25,
401 GRN_OP_BITWISE_XOR = 26,
402 GRN_OP_BITWISE_AND = 27,
403 GRN_OP_BITWISE_NOT = 28,
404 GRN_OP_EQUAL = 29,
405 GRN_OP_NOT_EQUAL = 30,
406 GRN_OP_LESS = 31,
407 GRN_OP_GREATER = 32,
408 GRN_OP_LESS_EQUAL = 33,
409 GRN_OP_GREATER_EQUAL = 34,
410 GRN_OP_IN = 35,
411 GRN_OP_MATCH = 36,
412 GRN_OP_NEAR = 37,
413 GRN_OP_NEAR2 = 38,
414 GRN_OP_SIMILAR = 39,
415 GRN_OP_TERM_EXTRACT = 40,
416 GRN_OP_SHIFTL = 41,
417 GRN_OP_SHIFTR = 42,
418 GRN_OP_SHIFTRR = 43,
419 GRN_OP_PLUS = 44,
420 GRN_OP_MINUS = 45,
421 GRN_OP_STAR = 46,
422 GRN_OP_SLASH = 47,
423 GRN_OP_MOD = 48,
424 GRN_OP_DELETE = 49,
425 GRN_OP_INCR = 50,
426 GRN_OP_DECR = 51,
427 GRN_OP_INCR_POST = 52,
428 GRN_OP_DECR_POST = 53,
429 GRN_OP_NOT = 54,
430 GRN_OP_ADJUST = 55,
431 GRN_OP_EXACT = 56,
432 GRN_OP_LCP = 57,
433 GRN_OP_PARTIAL = 58,
434 GRN_OP_UNSPLIT = 59,
435 GRN_OP_PREFIX = 60,
436 GRN_OP_SUFFIX = 61,
437 GRN_OP_GEO_DISTANCE1 = 62,
438 GRN_OP_GEO_DISTANCE2 = 63,
439 GRN_OP_GEO_DISTANCE3 = 64,
440 GRN_OP_GEO_DISTANCE4 = 65,
441 GRN_OP_GEO_WITHINP5 = 66,
442 GRN_OP_GEO_WITHINP6 = 67,
443 GRN_OP_GEO_WITHINP8 = 68,
444 GRN_OP_OBJ_SEARCH = 69,
445 GRN_OP_EXPR_GET_VAR = 70,
446 GRN_OP_TABLE_CREATE = 71,
447 GRN_OP_TABLE_SELECT = 72,
448 GRN_OP_TABLE_SORT = 73,
449 GRN_OP_TABLE_GROUP = 74,
450 GRN_OP_JSON_PUT = 75,
451 GRN_OP_GET_MEMBER = 76,
452 GRN_OP_REGEXP = 77,
453 GRN_OP_FUZZY = 78,
454}
455#[derive(Copy, Clone, PartialEq, Eq)]
456#[repr(u32)]
457#[derive(Debug)]
458pub enum grn_info_type {
459 GRN_INFO_ENCODING = 0,
460 GRN_INFO_SOURCE = 1,
461 GRN_INFO_DEFAULT_TOKENIZER = 2,
462 GRN_INFO_ELEMENT_SIZE = 3,
463 GRN_INFO_CURR_MAX = 4,
464 GRN_INFO_MAX_ELEMENT_SIZE = 5,
465 GRN_INFO_SEG_SIZE = 6,
466 GRN_INFO_CHUNK_SIZE = 7,
467 GRN_INFO_MAX_SECTION = 8,
468 GRN_INFO_HOOK_LOCAL_DATA = 9,
469 GRN_INFO_ELEMENT_A = 10,
470 GRN_INFO_ELEMENT_CHUNK = 11,
471 GRN_INFO_ELEMENT_CHUNK_SIZE = 12,
472 GRN_INFO_ELEMENT_BUFFER_FREE = 13,
473 GRN_INFO_ELEMENT_NTERMS = 14,
474 GRN_INFO_ELEMENT_NTERMS_VOID = 15,
475 GRN_INFO_ELEMENT_SIZE_IN_CHUNK = 16,
476 GRN_INFO_ELEMENT_POS_IN_CHUNK = 17,
477 GRN_INFO_ELEMENT_SIZE_IN_BUFFER = 18,
478 GRN_INFO_ELEMENT_POS_IN_BUFFER = 19,
479 GRN_INFO_ELEMENT_ESTIMATE_SIZE = 20,
480 GRN_INFO_NGRAM_UNIT_SIZE = 21,
481 GRN_INFO_PARTIAL_MATCH_THRESHOLD = 22,
482 GRN_INFO_II_SPLIT_THRESHOLD = 23,
483 GRN_INFO_SUPPORT_ZLIB = 24,
484 GRN_INFO_SUPPORT_LZ4 = 25,
485 GRN_INFO_NORMALIZER = 26,
486 GRN_INFO_TOKEN_FILTERS = 27,
487}
488pub type grn_fuzzy_search_optarg = _grn_fuzzy_search_optarg;
489#[repr(C)]
490#[derive(Copy, Clone)]
491#[derive(Debug)]
492pub struct _grn_fuzzy_search_optarg {
493 pub max_distance: ::std::os::raw::c_uint,
494 pub max_expansion: ::std::os::raw::c_uint,
495 pub prefix_match_size: ::std::os::raw::c_uint,
496 pub flags: ::std::os::raw::c_int,
497}
498impl ::std::default::Default for _grn_fuzzy_search_optarg {
499 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
500}
501pub type grn_search_optarg = _grn_search_optarg;
502#[repr(C)]
503#[derive(Copy, Clone)]
504#[derive(Debug)]
505pub struct _grn_search_optarg {
506 pub mode: grn_operator,
507 pub similarity_threshold: ::std::os::raw::c_int,
508 pub max_interval: ::std::os::raw::c_int,
509 pub weight_vector: *mut ::std::os::raw::c_int,
510 pub vector_size: ::std::os::raw::c_int,
511 pub proc_: *mut grn_obj,
512 pub max_size: ::std::os::raw::c_int,
513 pub scorer: *mut grn_obj,
514 pub scorer_args_expr: *mut grn_obj,
515 pub scorer_args_expr_offset: ::std::os::raw::c_uint,
516 pub fuzzy: grn_fuzzy_search_optarg,
517}
518impl ::std::default::Default for _grn_search_optarg {
519 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
520}
521pub type grn_selector_func =
522 ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
523 table: *mut grn_obj,
524 index: *mut grn_obj,
525 nargs: ::std::os::raw::c_int,
526 args: *mut *mut grn_obj,
527 res: *mut grn_obj,
528 op: grn_operator) -> grn_rc>;
529#[derive(Copy, Clone)]
530#[repr(u32)]
531#[derive(Debug)]
532pub enum grn_hook_entry {
533 GRN_HOOK_SET = 0,
534 GRN_HOOK_GET = 1,
535 GRN_HOOK_INSERT = 2,
536 GRN_HOOK_DELETE = 3,
537 GRN_HOOK_SELECT = 4,
538}
539#[repr(C)]
540#[derive(Copy, Clone)]
541#[derive(Debug)]
542pub struct _grn_index_datum {
543 pub index: *mut grn_obj,
544 pub section: ::std::os::raw::c_uint,
545}
546impl ::std::default::Default for _grn_index_datum {
547 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
548}
549pub type grn_index_datum = _grn_index_datum;
550#[repr(C)]
551#[derive(Copy, Clone)]
552#[derive(Debug)]
553pub struct grn_geo_point {
554 pub latitude: ::std::os::raw::c_int,
555 pub longitude: ::std::os::raw::c_int,
556}
557impl ::std::default::Default for grn_geo_point {
558 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
559}
560pub type grn_snip_mapping = _grn_snip_mapping;
561#[repr(C)]
562#[derive(Copy, Clone)]
563#[derive(Debug)]
564pub struct _grn_snip_mapping {
565 pub dummy: *mut ::std::os::raw::c_void,
566}
567impl ::std::default::Default for _grn_snip_mapping {
568 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
569}
570pub type grn_logger_info = _grn_logger_info;
571#[repr(C)]
572#[derive(Copy, Clone)]
573#[derive(Debug)]
574pub struct _grn_logger_info {
575 pub max_level: grn_log_level,
576 pub flags: ::std::os::raw::c_int,
577 pub func: ::std::option::Option<unsafe extern "C" fn(arg1:
578 ::std::os::raw::c_int,
579 arg2:
580 *const ::std::os::raw::c_char,
581 arg3:
582 *const ::std::os::raw::c_char,
583 arg4:
584 *const ::std::os::raw::c_char,
585 arg5:
586 *const ::std::os::raw::c_char,
587 arg6:
588 *mut ::std::os::raw::c_void)>,
589 pub func_arg: *mut ::std::os::raw::c_void,
590}
591impl ::std::default::Default for _grn_logger_info {
592 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
593}
594pub type grn_logger = _grn_logger;
595#[repr(C)]
596#[derive(Copy, Clone)]
597#[derive(Debug)]
598pub struct _grn_logger {
599 pub max_level: grn_log_level,
600 pub flags: ::std::os::raw::c_int,
601 pub user_data: *mut ::std::os::raw::c_void,
602 pub log: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
603 level: grn_log_level,
604 timestamp:
605 *const ::std::os::raw::c_char,
606 title:
607 *const ::std::os::raw::c_char,
608 message:
609 *const ::std::os::raw::c_char,
610 location:
611 *const ::std::os::raw::c_char,
612 user_data:
613 *mut ::std::os::raw::c_void)>,
614 pub reopen: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
615 user_data:
616 *mut ::std::os::raw::c_void)>,
617 pub fin: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
618 user_data:
619 *mut ::std::os::raw::c_void)>,
620}
621impl ::std::default::Default for _grn_logger {
622 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
623}
624pub type grn_query_logger = _grn_query_logger;
625#[repr(C)]
626#[derive(Copy, Clone)]
627#[derive(Debug)]
628pub struct _grn_query_logger {
629 pub flags: ::std::os::raw::c_uint,
630 pub user_data: *mut ::std::os::raw::c_void,
631 pub log: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
632 flag:
633 ::std::os::raw::c_uint,
634 timestamp:
635 *const ::std::os::raw::c_char,
636 info:
637 *const ::std::os::raw::c_char,
638 message:
639 *const ::std::os::raw::c_char,
640 user_data:
641 *mut ::std::os::raw::c_void)>,
642 pub reopen: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
643 user_data:
644 *mut ::std::os::raw::c_void)>,
645 pub fin: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
646 user_data:
647 *mut ::std::os::raw::c_void)>,
648}
649impl ::std::default::Default for _grn_query_logger {
650 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
651}
652#[repr(C)]
653#[derive(Copy, Clone)]
654#[derive(Debug)]
655pub struct grn_str {
656 pub orig: *const ::std::os::raw::c_char,
657 pub norm: *mut ::std::os::raw::c_char,
658 pub checks: *mut ::std::os::raw::c_short,
659 pub ctypes: *mut ::std::os::raw::c_uchar,
660 pub flags: ::std::os::raw::c_int,
661 pub orig_blen: ::std::os::raw::c_uint,
662 pub norm_blen: ::std::os::raw::c_uint,
663 pub length: ::std::os::raw::c_uint,
664 pub encoding: grn_encoding,
665}
666impl ::std::default::Default for grn_str {
667 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
668}
669#[derive(Copy, Clone, PartialEq, Eq)]
670#[repr(u32)]
671#[derive(Debug)]
672pub enum grn_char_type {
673 GRN_CHAR_NULL = 0,
674 GRN_CHAR_ALPHA = 1,
675 GRN_CHAR_DIGIT = 2,
676 GRN_CHAR_SYMBOL = 3,
677 GRN_CHAR_HIRAGANA = 4,
678 GRN_CHAR_KATAKANA = 5,
679 GRN_CHAR_KANJI = 6,
680 GRN_CHAR_OTHERS = 7,
681}
682pub type grn_ctx_info = _grn_ctx_info;
683#[repr(C)]
684#[derive(Copy, Clone)]
685#[derive(Debug)]
686pub struct _grn_ctx_info {
687 pub fd: ::std::os::raw::c_int,
688 pub com_status: ::std::os::raw::c_uint,
689 pub outbuf: *mut grn_obj,
690 pub stat: ::std::os::raw::c_uchar,
691}
692impl ::std::default::Default for _grn_ctx_info {
693 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
694}
695pub type grn_table_delete_optarg = _grn_table_delete_optarg;
696#[repr(C)]
697#[derive(Copy, Clone)]
698#[derive(Debug)]
699pub struct _grn_table_delete_optarg {
700 pub flags: ::std::os::raw::c_int,
701 pub func: ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
702 arg1: *mut grn_obj,
703 arg2: grn_id,
704 arg3:
705 *mut ::std::os::raw::c_void)
706 -> ::std::os::raw::c_int>,
707 pub func_arg: *mut ::std::os::raw::c_void,
708}
709impl ::std::default::Default for _grn_table_delete_optarg {
710 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
711}
712#[repr(C)]
713#[derive(Copy, Clone)]
714#[derive(Debug)]
715pub struct _grn_table_scan_hit {
716 pub id: grn_id,
717 pub offset: ::std::os::raw::c_uint,
718 pub length: ::std::os::raw::c_uint,
719}
720impl ::std::default::Default for _grn_table_scan_hit {
721 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
722}
723#[repr(C)]
724#[derive(Copy, Clone)]
725#[derive(Debug)]
726pub struct grn_timeval {
727 pub tv_sec: int64_t,
728 pub tv_nsec: int32_t,
729}
730impl ::std::default::Default for grn_timeval {
731 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
732}
733pub enum _grn_array { }
734pub type grn_array = _grn_array;
735pub enum _grn_array_cursor { }
736pub type grn_array_cursor = _grn_array_cursor;
737pub enum _grn_dat { }
738pub type grn_dat = _grn_dat;
739pub enum _grn_dat_cursor { }
740pub type grn_dat_cursor = _grn_dat_cursor;
741pub type grn_dat_scan_hit = _grn_table_scan_hit;
742pub type grn_db_create_optarg = _grn_db_create_optarg;
743#[repr(C)]
744#[derive(Copy, Clone)]
745#[derive(Debug)]
746pub struct _grn_db_create_optarg {
747 pub builtin_type_names: *mut *mut ::std::os::raw::c_char,
748 pub n_builtin_type_names: ::std::os::raw::c_int,
749}
750impl ::std::default::Default for _grn_db_create_optarg {
751 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
752}
753pub type grn_expr_flags = ::std::os::raw::c_uint;
754pub enum _grn_file_reader { }
755pub type grn_file_reader = _grn_file_reader;
756pub enum _grn_hash { }
757pub type grn_hash = _grn_hash;
758pub enum _grn_hash_cursor { }
759pub type grn_hash_cursor = _grn_hash_cursor;
760pub enum _grn_ii { }
761pub type grn_ii = _grn_ii;
762pub enum _grn_ii_buffer { }
763pub type grn_ii_buffer = _grn_ii_buffer;
764pub enum _grn_ii_cursor { }
765pub type grn_ii_cursor = _grn_ii_cursor;
766pub type grn_operator_exec_func =
767 ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
768 x: *mut grn_obj,
769 y: *mut grn_obj) -> grn_bool>;
770pub type grn_obj_format = _grn_obj_format;
771#[repr(C)]
772#[derive(Copy, Clone)]
773#[derive(Debug)]
774pub struct _grn_obj_format {
775 pub columns: grn_obj,
776 pub min: *const ::std::os::raw::c_void,
777 pub max: *const ::std::os::raw::c_void,
778 pub min_size: ::std::os::raw::c_uint,
779 pub max_size: ::std::os::raw::c_uint,
780 pub nhits: ::std::os::raw::c_int,
781 pub offset: ::std::os::raw::c_int,
782 pub limit: ::std::os::raw::c_int,
783 pub hits_offset: ::std::os::raw::c_int,
784 pub flags: ::std::os::raw::c_int,
785 pub expression: *mut grn_obj,
786}
787impl ::std::default::Default for _grn_obj_format {
788 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
789}
790pub enum _grn_pat { }
791pub type grn_pat = _grn_pat;
792pub enum _grn_pat_cursor { }
793pub type grn_pat_cursor = _grn_pat_cursor;
794pub type grn_pat_scan_hit = _grn_table_scan_hit;
795#[repr(C)]
796#[derive(Copy, Clone)]
797#[derive(Debug)]
798pub struct _grn_request_timer {
799 pub user_data: *mut ::std::os::raw::c_void,
800 pub register_func: ::std::option::Option<unsafe extern "C" fn(request_id:
801 *const ::std::os::raw::c_char,
802 request_id_size:
803 ::std::os::raw::c_uint,
804 timeout:
805 f64,
806 user_data:
807 *mut ::std::os::raw::c_void)
808 ->
809 *mut ::std::os::raw::c_void>,
810 pub unregister_func: ::std::option::Option<unsafe extern "C" fn(timer_id:
811 *mut ::std::os::raw::c_void,
812 user_data:
813 *mut ::std::os::raw::c_void)>,
814 pub fin_func: ::std::option::Option<unsafe extern "C" fn(user_data:
815 *mut ::std::os::raw::c_void)>,
816}
817impl ::std::default::Default for _grn_request_timer {
818 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
819}
820pub type grn_request_timer = _grn_request_timer;
821pub type grn_table_sort_key = _grn_table_sort_key;
822pub type grn_table_sort_flags = ::std::os::raw::c_uchar;
823#[repr(C)]
824#[derive(Copy, Clone)]
825#[derive(Debug)]
826pub struct _grn_table_sort_key {
827 pub key: *mut grn_obj,
828 pub flags: grn_table_sort_flags,
829 pub offset: ::std::os::raw::c_int,
830}
831impl ::std::default::Default for _grn_table_sort_key {
832 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
833}
834pub type grn_table_group_result = _grn_table_group_result;
835pub type grn_table_group_flags = uint32_t;
836#[repr(C)]
837#[derive(Copy, Clone)]
838#[derive(Debug)]
839pub struct _grn_table_group_result {
840 pub table: *mut grn_obj,
841 pub key_begin: ::std::os::raw::c_uchar,
842 pub key_end: ::std::os::raw::c_uchar,
843 pub limit: ::std::os::raw::c_int,
844 pub flags: grn_table_group_flags,
845 pub op: grn_operator,
846 pub max_n_subrecs: ::std::os::raw::c_uint,
847 pub calc_target: *mut grn_obj,
848}
849impl ::std::default::Default for _grn_table_group_result {
850 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
851}
852pub type grn_thread_get_limit_func =
853 ::std::option::Option<unsafe extern "C" fn(data:
854 *mut ::std::os::raw::c_void)
855 -> uint32_t>;
856pub type grn_thread_set_limit_func =
857 ::std::option::Option<unsafe extern "C" fn(new_limit: uint32_t,
858 data:
859 *mut ::std::os::raw::c_void)>;
860pub enum sigevent { }
861#[derive(Copy, Clone)]
862#[repr(u32)]
863#[derive(Debug)]
864pub enum grn_window_direction {
865 GRN_WINDOW_DIRECTION_ASCENDING = 0,
866 GRN_WINDOW_DIRECTION_DESCENDING = 1,
867}
868pub enum _grn_window { }
869pub type grn_window = _grn_window;
870#[repr(C)]
871#[derive(Copy, Clone)]
872#[derive(Debug)]
873pub struct _grn_window_definition {
874 pub sort_keys: *mut grn_table_sort_key,
875 pub n_sort_keys: size_t,
876}
877impl ::std::default::Default for _grn_window_definition {
878 fn default() -> Self { unsafe { ::std::mem::zeroed() } }
879}
880pub type grn_window_definition = _grn_window_definition;
881pub type grn_window_function_func =
882 ::std::option::Option<unsafe extern "C" fn(ctx: *mut grn_ctx,
883 output_column: *mut grn_obj,
884 window: *mut grn_window,
885 args: *mut grn_obj,
886 n_args: ::std::os::raw::c_int)
887 -> grn_rc>;
888#[link(name = "groonga", kind = "dylib")]
889extern "C" {
890 pub fn grn_init() -> grn_rc;
891 pub fn grn_fin() -> grn_rc;
892 pub fn grn_get_global_error_message() -> *const ::std::os::raw::c_char;
893 pub fn grn_log_level_to_string(level: grn_log_level)
894 -> *const ::std::os::raw::c_char;
895 pub fn grn_log_level_parse(string: *const ::std::os::raw::c_char,
896 level: *mut grn_log_level) -> grn_bool;
897 pub fn grn_ctx_init(ctx: *mut grn_ctx, flags: ::std::os::raw::c_int)
898 -> grn_rc;
899 pub fn grn_ctx_fin(ctx: *mut grn_ctx) -> grn_rc;
900 pub fn grn_ctx_open(flags: ::std::os::raw::c_int) -> *mut grn_ctx;
901 pub fn grn_ctx_close(ctx: *mut grn_ctx) -> grn_rc;
902 pub fn grn_ctx_set_finalizer(ctx: *mut grn_ctx, func: grn_proc_func)
903 -> grn_rc;
904 pub fn grn_get_default_encoding() -> grn_encoding;
905 pub fn grn_set_default_encoding(encoding: grn_encoding) -> grn_rc;
906 pub fn grn_get_version() -> *const ::std::os::raw::c_char;
907 pub fn grn_get_package() -> *const ::std::os::raw::c_char;
908 pub fn grn_get_package_label() -> *const ::std::os::raw::c_char;
909 pub fn grn_get_default_command_version() -> grn_command_version;
910 pub fn grn_set_default_command_version(version: grn_command_version)
911 -> grn_rc;
912 pub fn grn_ctx_get_command_version(ctx: *mut grn_ctx)
913 -> grn_command_version;
914 pub fn grn_ctx_set_command_version(ctx: *mut grn_ctx,
915 version: grn_command_version)
916 -> grn_rc;
917 pub fn grn_ctx_get_match_escalation_threshold(ctx: *mut grn_ctx)
918 -> ::std::os::raw::c_longlong;
919 pub fn grn_ctx_set_match_escalation_threshold(ctx: *mut grn_ctx,
920 threshold:
921 ::std::os::raw::c_longlong)
922 -> grn_rc;
923 pub fn grn_get_default_match_escalation_threshold()
924 -> ::std::os::raw::c_longlong;
925 pub fn grn_set_default_match_escalation_threshold(threshold:
926 ::std::os::raw::c_longlong)
927 -> grn_rc;
928 pub fn grn_get_lock_timeout() -> ::std::os::raw::c_int;
929 pub fn grn_set_lock_timeout(timeout: ::std::os::raw::c_int) -> grn_rc;
930 pub fn grn_cache_open(ctx: *mut grn_ctx) -> *mut grn_cache;
931 pub fn grn_cache_close(ctx: *mut grn_ctx, cache: *mut grn_cache)
932 -> grn_rc;
933 pub fn grn_cache_current_set(ctx: *mut grn_ctx, cache: *mut grn_cache)
934 -> grn_rc;
935 pub fn grn_cache_current_get(ctx: *mut grn_ctx) -> *mut grn_cache;
936 pub fn grn_cache_set_max_n_entries(ctx: *mut grn_ctx,
937 cache: *mut grn_cache,
938 n: ::std::os::raw::c_uint) -> grn_rc;
939 pub fn grn_cache_get_max_n_entries(ctx: *mut grn_ctx,
940 cache: *mut grn_cache)
941 -> ::std::os::raw::c_uint;
942 pub fn grn_encoding_to_string(encoding: grn_encoding)
943 -> *const ::std::os::raw::c_char;
944 pub fn grn_encoding_parse(name: *const ::std::os::raw::c_char)
945 -> grn_encoding;
946 pub fn grn_ctx_use(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_rc;
947 pub fn grn_ctx_db(ctx: *mut grn_ctx) -> *mut grn_obj;
948 pub fn grn_ctx_get(ctx: *mut grn_ctx, name: *const ::std::os::raw::c_char,
949 name_size: ::std::os::raw::c_int) -> *mut grn_obj;
950 pub fn grn_ctx_get_all_tables(ctx: *mut grn_ctx,
951 tables_buffer: *mut grn_obj) -> grn_rc;
952 pub fn grn_ctx_get_all_types(ctx: *mut grn_ctx,
953 types_buffer: *mut grn_obj) -> grn_rc;
954 pub fn grn_ctx_get_all_tokenizers(ctx: *mut grn_ctx,
955 tokenizers_buffer: *mut grn_obj)
956 -> grn_rc;
957 pub fn grn_ctx_get_all_normalizers(ctx: *mut grn_ctx,
958 normalizers_buffer: *mut grn_obj)
959 -> grn_rc;
960 pub fn grn_ctx_get_all_token_filters(ctx: *mut grn_ctx,
961 token_filters_buffer: *mut grn_obj)
962 -> grn_rc;
963 pub fn grn_ctx_at(ctx: *mut grn_ctx, id: grn_id) -> *mut grn_obj;
964 pub fn grn_ctx_is_opened(ctx: *mut grn_ctx, id: grn_id) -> grn_bool;
965 pub fn grn_plugin_register(ctx: *mut grn_ctx,
966 name: *const ::std::os::raw::c_char) -> grn_rc;
967 pub fn grn_plugin_unregister(ctx: *mut grn_ctx,
968 name: *const ::std::os::raw::c_char)
969 -> grn_rc;
970 pub fn grn_plugin_register_by_path(ctx: *mut grn_ctx,
971 path: *const ::std::os::raw::c_char)
972 -> grn_rc;
973 pub fn grn_plugin_unregister_by_path(ctx: *mut grn_ctx,
974 path: *const ::std::os::raw::c_char)
975 -> grn_rc;
976 pub fn grn_plugin_get_system_plugins_dir()
977 -> *const ::std::os::raw::c_char;
978 pub fn grn_plugin_get_suffix() -> *const ::std::os::raw::c_char;
979 pub fn grn_plugin_get_ruby_suffix() -> *const ::std::os::raw::c_char;
980 pub fn grn_plugin_get_names(ctx: *mut grn_ctx, names: *mut grn_obj)
981 -> grn_rc;
982 pub fn grn_proc_create(ctx: *mut grn_ctx,
983 name: *const ::std::os::raw::c_char,
984 name_size: ::std::os::raw::c_int,
985 type_: grn_proc_type, init: grn_proc_func,
986 next: grn_proc_func, fin: grn_proc_func,
987 nvars: ::std::os::raw::c_uint,
988 vars: *mut grn_expr_var) -> *mut grn_obj;
989 pub fn grn_proc_get_info(ctx: *mut grn_ctx, user_data: *mut grn_user_data,
990 vars: *mut *mut grn_expr_var,
991 nvars: *mut ::std::os::raw::c_uint,
992 caller: *mut *mut grn_obj) -> *mut grn_obj;
993 pub fn grn_proc_get_type(ctx: *mut grn_ctx, proc_: *mut grn_obj)
994 -> grn_proc_type;
995 pub fn grn_obj_column(ctx: *mut grn_ctx, table: *mut grn_obj,
996 name: *const ::std::os::raw::c_char,
997 name_size: ::std::os::raw::c_uint) -> *mut grn_obj;
998 pub fn grn_column_create(ctx: *mut grn_ctx, table: *mut grn_obj,
999 name: *const ::std::os::raw::c_char,
1000 name_size: ::std::os::raw::c_uint,
1001 path: *const ::std::os::raw::c_char,
1002 flags: grn_column_flags, type_: *mut grn_obj)
1003 -> *mut grn_obj;
1004 pub fn grn_column_index_update(ctx: *mut grn_ctx, column: *mut grn_obj,
1005 id: grn_id,
1006 section: ::std::os::raw::c_uint,
1007 oldvalue: *mut grn_obj,
1008 newvalue: *mut grn_obj) -> grn_rc;
1009 pub fn grn_column_table(ctx: *mut grn_ctx, column: *mut grn_obj)
1010 -> *mut grn_obj;
1011 pub fn grn_column_truncate(ctx: *mut grn_ctx, column: *mut grn_obj)
1012 -> grn_rc;
1013 pub fn grn_obj_get_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
1014 type_: grn_info_type, valuebuf: *mut grn_obj)
1015 -> *mut grn_obj;
1016 pub fn grn_obj_set_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
1017 type_: grn_info_type, value: *mut grn_obj)
1018 -> grn_rc;
1019 pub fn grn_obj_get_element_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
1020 id: grn_id, type_: grn_info_type,
1021 value: *mut grn_obj) -> *mut grn_obj;
1022 pub fn grn_obj_set_element_info(ctx: *mut grn_ctx, obj: *mut grn_obj,
1023 id: grn_id, type_: grn_info_type,
1024 value: *mut grn_obj) -> grn_rc;
1025 pub fn grn_obj_get_value(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id,
1026 value: *mut grn_obj) -> *mut grn_obj;
1027 pub fn grn_obj_get_values(ctx: *mut grn_ctx, obj: *mut grn_obj,
1028 offset: grn_id,
1029 values: *mut *mut ::std::os::raw::c_void)
1030 -> ::std::os::raw::c_int;
1031 pub fn grn_obj_set_value(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id,
1032 value: *mut grn_obj,
1033 flags: ::std::os::raw::c_int) -> grn_rc;
1034 pub fn grn_obj_remove(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
1035 pub fn grn_obj_remove_dependent(ctx: *mut grn_ctx, obj: *mut grn_obj)
1036 -> grn_rc;
1037 pub fn grn_obj_remove_force(ctx: *mut grn_ctx,
1038 name: *const ::std::os::raw::c_char,
1039 name_size: ::std::os::raw::c_int) -> grn_rc;
1040 pub fn grn_obj_rename(ctx: *mut grn_ctx, obj: *mut grn_obj,
1041 name: *const ::std::os::raw::c_char,
1042 name_size: ::std::os::raw::c_uint) -> grn_rc;
1043 pub fn grn_table_rename(ctx: *mut grn_ctx, table: *mut grn_obj,
1044 name: *const ::std::os::raw::c_char,
1045 name_size: ::std::os::raw::c_uint) -> grn_rc;
1046 pub fn grn_column_rename(ctx: *mut grn_ctx, column: *mut grn_obj,
1047 name: *const ::std::os::raw::c_char,
1048 name_size: ::std::os::raw::c_uint) -> grn_rc;
1049 pub fn grn_obj_close(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
1050 pub fn grn_obj_reinit(ctx: *mut grn_ctx, obj: *mut grn_obj,
1051 domain: grn_id, flags: ::std::os::raw::c_uchar)
1052 -> grn_rc;
1053 pub fn grn_obj_unlink(ctx: *mut grn_ctx, obj: *mut grn_obj);
1054 pub fn grn_obj_user_data(ctx: *mut grn_ctx, obj: *mut grn_obj)
1055 -> *mut grn_user_data;
1056 pub fn grn_obj_set_finalizer(ctx: *mut grn_ctx, obj: *mut grn_obj,
1057 func: grn_proc_func) -> grn_rc;
1058 pub fn grn_obj_path(ctx: *mut grn_ctx, obj: *mut grn_obj)
1059 -> *const ::std::os::raw::c_char;
1060 pub fn grn_obj_name(ctx: *mut grn_ctx, obj: *mut grn_obj,
1061 namebuf: *mut ::std::os::raw::c_char,
1062 buf_size: ::std::os::raw::c_int)
1063 -> ::std::os::raw::c_int;
1064 pub fn grn_column_name(ctx: *mut grn_ctx, obj: *mut grn_obj,
1065 namebuf: *mut ::std::os::raw::c_char,
1066 buf_size: ::std::os::raw::c_int)
1067 -> ::std::os::raw::c_int;
1068 pub fn grn_obj_get_range(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_id;
1069 pub fn grn_obj_expire(ctx: *mut grn_ctx, obj: *mut grn_obj,
1070 threshold: ::std::os::raw::c_int)
1071 -> ::std::os::raw::c_int;
1072 pub fn grn_obj_check(ctx: *mut grn_ctx, obj: *mut grn_obj)
1073 -> ::std::os::raw::c_int;
1074 pub fn grn_obj_lock(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id,
1075 timeout: ::std::os::raw::c_int) -> grn_rc;
1076 pub fn grn_obj_unlock(ctx: *mut grn_ctx, obj: *mut grn_obj, id: grn_id)
1077 -> grn_rc;
1078 pub fn grn_obj_clear_lock(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
1079 pub fn grn_obj_is_locked(ctx: *mut grn_ctx, obj: *mut grn_obj)
1080 -> ::std::os::raw::c_uint;
1081 pub fn grn_obj_flush(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
1082 pub fn grn_obj_flush_recursive(ctx: *mut grn_ctx, obj: *mut grn_obj)
1083 -> grn_rc;
1084 pub fn grn_obj_defrag(ctx: *mut grn_ctx, obj: *mut grn_obj,
1085 threshold: ::std::os::raw::c_int)
1086 -> ::std::os::raw::c_int;
1087 pub fn grn_obj_db(ctx: *mut grn_ctx, obj: *mut grn_obj) -> *mut grn_obj;
1088 pub fn grn_obj_id(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_id;
1089 pub fn grn_obj_search(ctx: *mut grn_ctx, obj: *mut grn_obj,
1090 query: *mut grn_obj, res: *mut grn_obj,
1091 op: grn_operator, optarg: *mut grn_search_optarg)
1092 -> grn_rc;
1093 pub fn grn_proc_set_selector(ctx: *mut grn_ctx, proc_: *mut grn_obj,
1094 selector: grn_selector_func) -> grn_rc;
1095 pub fn grn_proc_set_selector_operator(ctx: *mut grn_ctx,
1096 proc_: *mut grn_obj,
1097 selector_op: grn_operator)
1098 -> grn_rc;
1099 pub fn grn_proc_get_selector_operator(ctx: *mut grn_ctx,
1100 proc_: *mut grn_obj)
1101 -> grn_operator;
1102 pub fn grn_vector_size(ctx: *mut grn_ctx, vector: *mut grn_obj)
1103 -> ::std::os::raw::c_uint;
1104 pub fn grn_vector_add_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
1105 str: *const ::std::os::raw::c_char,
1106 str_len: ::std::os::raw::c_uint,
1107 weight: ::std::os::raw::c_uint,
1108 domain: grn_id) -> grn_rc;
1109 pub fn grn_vector_get_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
1110 offset: ::std::os::raw::c_uint,
1111 str: *mut *const ::std::os::raw::c_char,
1112 weight: *mut ::std::os::raw::c_uint,
1113 domain: *mut grn_id)
1114 -> ::std::os::raw::c_uint;
1115 pub fn grn_vector_pop_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
1116 str: *mut *const ::std::os::raw::c_char,
1117 weight: *mut ::std::os::raw::c_uint,
1118 domain: *mut grn_id)
1119 -> ::std::os::raw::c_uint;
1120 pub fn grn_uvector_size(ctx: *mut grn_ctx, uvector: *mut grn_obj)
1121 -> ::std::os::raw::c_uint;
1122 pub fn grn_uvector_element_size(ctx: *mut grn_ctx, uvector: *mut grn_obj)
1123 -> ::std::os::raw::c_uint;
1124 pub fn grn_uvector_add_element(ctx: *mut grn_ctx, vector: *mut grn_obj,
1125 id: grn_id, weight: ::std::os::raw::c_uint)
1126 -> grn_rc;
1127 pub fn grn_uvector_get_element(ctx: *mut grn_ctx, uvector: *mut grn_obj,
1128 offset: ::std::os::raw::c_uint,
1129 weight: *mut ::std::os::raw::c_uint)
1130 -> grn_id;
1131 pub fn grn_proc_call_next(ctx: *mut grn_ctx, exec_info: *mut grn_obj,
1132 in_: *mut grn_obj, out: *mut grn_obj)
1133 -> ::std::os::raw::c_int;
1134 pub fn grn_proc_get_ctx_local_data(ctx: *mut grn_ctx,
1135 exec_info: *mut grn_obj)
1136 -> *mut ::std::os::raw::c_void;
1137 pub fn grn_proc_get_hook_local_data(ctx: *mut grn_ctx,
1138 exec_info: *mut grn_obj)
1139 -> *mut ::std::os::raw::c_void;
1140 pub fn grn_obj_add_hook(ctx: *mut grn_ctx, obj: *mut grn_obj,
1141 entry: grn_hook_entry,
1142 offset: ::std::os::raw::c_int,
1143 proc_: *mut grn_obj, data: *mut grn_obj)
1144 -> grn_rc;
1145 pub fn grn_obj_get_nhooks(ctx: *mut grn_ctx, obj: *mut grn_obj,
1146 entry: grn_hook_entry) -> ::std::os::raw::c_int;
1147 pub fn grn_obj_get_hook(ctx: *mut grn_ctx, obj: *mut grn_obj,
1148 entry: grn_hook_entry,
1149 offset: ::std::os::raw::c_int, data: *mut grn_obj)
1150 -> *mut grn_obj;
1151 pub fn grn_obj_delete_hook(ctx: *mut grn_ctx, obj: *mut grn_obj,
1152 entry: grn_hook_entry,
1153 offset: ::std::os::raw::c_int) -> grn_rc;
1154 pub fn grn_obj_open(ctx: *mut grn_ctx, type_: ::std::os::raw::c_uchar,
1155 flags: grn_obj_flags, domain: grn_id) -> *mut grn_obj;
1156 pub fn grn_column_index(ctx: *mut grn_ctx, column: *mut grn_obj,
1157 op: grn_operator, indexbuf: *mut *mut grn_obj,
1158 buf_size: ::std::os::raw::c_int,
1159 section: *mut ::std::os::raw::c_int)
1160 -> ::std::os::raw::c_int;
1161 pub fn grn_column_find_index_data(ctx: *mut grn_ctx, column: *mut grn_obj,
1162 op: grn_operator,
1163 index_data: *mut grn_index_datum,
1164 n_index_data: ::std::os::raw::c_uint)
1165 -> ::std::os::raw::c_uint;
1166 pub fn grn_column_get_all_index_data(ctx: *mut grn_ctx,
1167 column: *mut grn_obj,
1168 index_data: *mut grn_index_datum,
1169 n_index_data: uint32_t) -> uint32_t;
1170 pub fn grn_obj_delete_by_id(ctx: *mut grn_ctx, db: *mut grn_obj,
1171 id: grn_id, removep: grn_bool) -> grn_rc;
1172 pub fn grn_obj_path_by_id(ctx: *mut grn_ctx, db: *mut grn_obj, id: grn_id,
1173 buffer: *mut ::std::os::raw::c_char) -> grn_rc;
1174 pub fn grn_geo_select_in_rectangle(ctx: *mut grn_ctx, index: *mut grn_obj,
1175 top_left_point: *mut grn_obj,
1176 bottom_right_point: *mut grn_obj,
1177 res: *mut grn_obj, op: grn_operator)
1178 -> grn_rc;
1179 pub fn grn_geo_estimate_size_in_rectangle(ctx: *mut grn_ctx,
1180 index: *mut grn_obj,
1181 top_left_point: *mut grn_obj,
1182 bottom_right_point:
1183 *mut grn_obj)
1184 -> ::std::os::raw::c_uint;
1185 pub fn grn_geo_estimate_in_rectangle(ctx: *mut grn_ctx,
1186 index: *mut grn_obj,
1187 top_left_point: *mut grn_obj,
1188 bottom_right_point: *mut grn_obj)
1189 -> ::std::os::raw::c_int;
1190 pub fn grn_geo_cursor_open_in_rectangle(ctx: *mut grn_ctx,
1191 index: *mut grn_obj,
1192 top_left_point: *mut grn_obj,
1193 bottom_right_point: *mut grn_obj,
1194 offset: ::std::os::raw::c_int,
1195 limit: ::std::os::raw::c_int)
1196 -> *mut grn_obj;
1197 pub fn grn_geo_cursor_next(ctx: *mut grn_ctx, cursor: *mut grn_obj)
1198 -> *mut grn_posting;
1199 pub fn grn_snip_open(ctx: *mut grn_ctx, flags: ::std::os::raw::c_int,
1200 width: ::std::os::raw::c_uint,
1201 max_results: ::std::os::raw::c_uint,
1202 defaultopentag: *const ::std::os::raw::c_char,
1203 defaultopentag_len: ::std::os::raw::c_uint,
1204 defaultclosetag: *const ::std::os::raw::c_char,
1205 defaultclosetag_len: ::std::os::raw::c_uint,
1206 mapping: *mut grn_snip_mapping) -> *mut grn_obj;
1207 pub fn grn_snip_add_cond(ctx: *mut grn_ctx, snip: *mut grn_obj,
1208 keyword: *const ::std::os::raw::c_char,
1209 keyword_len: ::std::os::raw::c_uint,
1210 opentag: *const ::std::os::raw::c_char,
1211 opentag_len: ::std::os::raw::c_uint,
1212 closetag: *const ::std::os::raw::c_char,
1213 closetag_len: ::std::os::raw::c_uint) -> grn_rc;
1214 pub fn grn_snip_set_normalizer(ctx: *mut grn_ctx, snip: *mut grn_obj,
1215 normalizer: *mut grn_obj) -> grn_rc;
1216 pub fn grn_snip_get_normalizer(ctx: *mut grn_ctx, snip: *mut grn_obj)
1217 -> *mut grn_obj;
1218 pub fn grn_snip_exec(ctx: *mut grn_ctx, snip: *mut grn_obj,
1219 string: *const ::std::os::raw::c_char,
1220 string_len: ::std::os::raw::c_uint,
1221 nresults: *mut ::std::os::raw::c_uint,
1222 max_tagged_len: *mut ::std::os::raw::c_uint)
1223 -> grn_rc;
1224 pub fn grn_snip_get_result(ctx: *mut grn_ctx, snip: *mut grn_obj,
1225 index: ::std::os::raw::c_uint,
1226 result: *mut ::std::os::raw::c_char,
1227 result_len: *mut ::std::os::raw::c_uint)
1228 -> grn_rc;
1229 pub fn grn_logger_info_set(ctx: *mut grn_ctx,
1230 info: *const grn_logger_info) -> grn_rc;
1231 pub fn grn_logger_set(ctx: *mut grn_ctx, logger: *const grn_logger)
1232 -> grn_rc;
1233 pub fn grn_logger_set_max_level(ctx: *mut grn_ctx,
1234 max_level: grn_log_level);
1235 pub fn grn_logger_get_max_level(ctx: *mut grn_ctx) -> grn_log_level;
1236 pub fn grn_logger_put(ctx: *mut grn_ctx, level: grn_log_level,
1237 file: *const ::std::os::raw::c_char,
1238 line: ::std::os::raw::c_int,
1239 func: *const ::std::os::raw::c_char,
1240 fmt: *const ::std::os::raw::c_char, ...);
1241 pub fn grn_logger_reopen(ctx: *mut grn_ctx);
1247 pub fn grn_logger_pass(ctx: *mut grn_ctx, level: grn_log_level)
1248 -> grn_bool;
1249 pub fn grn_default_logger_set_max_level(level: grn_log_level);
1250 pub fn grn_default_logger_get_max_level() -> grn_log_level;
1251 pub fn grn_default_logger_set_path(path: *const ::std::os::raw::c_char);
1252 pub fn grn_default_logger_get_path() -> *const ::std::os::raw::c_char;
1253 pub fn grn_default_logger_set_rotate_threshold_size(threshold: off_t);
1254 pub fn grn_default_logger_get_rotate_threshold_size() -> off_t;
1255 pub fn grn_query_logger_set(ctx: *mut grn_ctx,
1256 logger: *const grn_query_logger) -> grn_rc;
1257 pub fn grn_query_logger_put(ctx: *mut grn_ctx,
1258 flag: ::std::os::raw::c_uint,
1259 mark: *const ::std::os::raw::c_char,
1260 format: *const ::std::os::raw::c_char, ...);
1261 pub fn grn_query_logger_reopen(ctx: *mut grn_ctx);
1262 pub fn grn_query_logger_pass(ctx: *mut grn_ctx,
1263 flag: ::std::os::raw::c_uint) -> grn_bool;
1264 pub fn grn_default_query_logger_set_flags(flags: ::std::os::raw::c_uint);
1265 pub fn grn_default_query_logger_get_flags() -> ::std::os::raw::c_uint;
1266 pub fn grn_default_query_logger_set_path(path:
1267 *const ::std::os::raw::c_char);
1268 pub fn grn_default_query_logger_get_path()
1269 -> *const ::std::os::raw::c_char;
1270 pub fn grn_default_query_logger_set_rotate_threshold_size(threshold:
1271 off_t);
1272 pub fn grn_default_query_logger_get_rotate_threshold_size() -> off_t;
1273 pub fn grn_bulk_reinit(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1274 size: ::std::os::raw::c_uint) -> grn_rc;
1275 pub fn grn_bulk_resize(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1276 newsize: ::std::os::raw::c_uint) -> grn_rc;
1277 pub fn grn_bulk_write(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1278 str: *const ::std::os::raw::c_char,
1279 len: ::std::os::raw::c_uint) -> grn_rc;
1280 pub fn grn_bulk_write_from(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1281 str: *const ::std::os::raw::c_char,
1282 from: ::std::os::raw::c_uint,
1283 len: ::std::os::raw::c_uint) -> grn_rc;
1284 pub fn grn_bulk_reserve(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1285 len: ::std::os::raw::c_uint) -> grn_rc;
1286 pub fn grn_bulk_space(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1287 len: ::std::os::raw::c_uint) -> grn_rc;
1288 pub fn grn_bulk_truncate(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1289 len: ::std::os::raw::c_uint) -> grn_rc;
1290 pub fn grn_bulk_fin(ctx: *mut grn_ctx, bulk: *mut grn_obj) -> grn_rc;
1291 pub fn grn_text_itoa(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1292 i: ::std::os::raw::c_int) -> grn_rc;
1293 pub fn grn_text_itoa_padded(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1294 i: ::std::os::raw::c_int,
1295 ch: ::std::os::raw::c_char,
1296 len: ::std::os::raw::c_uint) -> grn_rc;
1297 pub fn grn_text_lltoa(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1298 i: ::std::os::raw::c_longlong) -> grn_rc;
1299 pub fn grn_text_ftoa(ctx: *mut grn_ctx, bulk: *mut grn_obj, d: f64)
1300 -> grn_rc;
1301 pub fn grn_text_itoh(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1302 i: ::std::os::raw::c_int,
1303 len: ::std::os::raw::c_uint) -> grn_rc;
1304 pub fn grn_text_itob(ctx: *mut grn_ctx, bulk: *mut grn_obj, id: grn_id)
1305 -> grn_rc;
1306 pub fn grn_text_lltob32h(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1307 i: ::std::os::raw::c_longlong) -> grn_rc;
1308 pub fn grn_text_benc(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1309 v: ::std::os::raw::c_uint) -> grn_rc;
1310 pub fn grn_text_esc(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1311 s: *const ::std::os::raw::c_char,
1312 len: ::std::os::raw::c_uint) -> grn_rc;
1313 pub fn grn_text_urlenc(ctx: *mut grn_ctx, buf: *mut grn_obj,
1314 str: *const ::std::os::raw::c_char,
1315 len: ::std::os::raw::c_uint) -> grn_rc;
1316 pub fn grn_text_urldec(ctx: *mut grn_ctx, buf: *mut grn_obj,
1317 s: *const ::std::os::raw::c_char,
1318 e: *const ::std::os::raw::c_char,
1319 d: ::std::os::raw::c_char)
1320 -> *const ::std::os::raw::c_char;
1321 pub fn grn_text_escape_xml(ctx: *mut grn_ctx, buf: *mut grn_obj,
1322 s: *const ::std::os::raw::c_char,
1323 len: ::std::os::raw::c_uint) -> grn_rc;
1324 pub fn grn_text_time2rfc1123(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1325 sec: ::std::os::raw::c_int) -> grn_rc;
1326 pub fn grn_text_printf(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1327 format: *const ::std::os::raw::c_char, ...)
1328 -> grn_rc;
1329 pub fn grn_ctx_recv_handler_set(arg1: *mut grn_ctx,
1333 func:
1334 ::std::option::Option<unsafe extern "C" fn(arg1:
1335 *mut grn_ctx,
1336 arg2:
1337 ::std::os::raw::c_int,
1338 arg3:
1339 *mut ::std::os::raw::c_void)>,
1340 func_arg: *mut ::std::os::raw::c_void);
1341 pub fn grn_str_open(ctx: *mut grn_ctx, str: *const ::std::os::raw::c_char,
1342 str_len: ::std::os::raw::c_uint,
1343 flags: ::std::os::raw::c_int) -> *mut grn_str;
1344 pub fn grn_str_close(ctx: *mut grn_ctx, nstr: *mut grn_str) -> grn_rc;
1345 pub fn grn_string_open(ctx: *mut grn_ctx,
1346 string: *const ::std::os::raw::c_char,
1347 length_in_bytes: ::std::os::raw::c_uint,
1348 normalizer: *mut grn_obj,
1349 flags: ::std::os::raw::c_int) -> *mut grn_obj;
1350 pub fn grn_string_get_original(ctx: *mut grn_ctx, string: *mut grn_obj,
1351 original:
1352 *mut *const ::std::os::raw::c_char,
1353 length_in_bytes:
1354 *mut ::std::os::raw::c_uint) -> grn_rc;
1355 pub fn grn_string_get_flags(ctx: *mut grn_ctx, string: *mut grn_obj)
1356 -> ::std::os::raw::c_int;
1357 pub fn grn_string_get_normalized(ctx: *mut grn_ctx, string: *mut grn_obj,
1358 normalized:
1359 *mut *const ::std::os::raw::c_char,
1360 length_in_bytes:
1361 *mut ::std::os::raw::c_uint,
1362 n_characters:
1363 *mut ::std::os::raw::c_uint)
1364 -> grn_rc;
1365 pub fn grn_string_set_normalized(ctx: *mut grn_ctx, string: *mut grn_obj,
1366 normalized: *mut ::std::os::raw::c_char,
1367 length_in_bytes: ::std::os::raw::c_uint,
1368 n_characters: ::std::os::raw::c_uint)
1369 -> grn_rc;
1370 pub fn grn_string_get_checks(ctx: *mut grn_ctx, string: *mut grn_obj)
1371 -> *const ::std::os::raw::c_short;
1372 pub fn grn_string_set_checks(ctx: *mut grn_ctx, string: *mut grn_obj,
1373 checks: *mut ::std::os::raw::c_short)
1374 -> grn_rc;
1375 pub fn grn_string_get_types(ctx: *mut grn_ctx, string: *mut grn_obj)
1376 -> *const ::std::os::raw::c_uchar;
1377 pub fn grn_string_set_types(ctx: *mut grn_ctx, string: *mut grn_obj,
1378 types: *mut ::std::os::raw::c_uchar)
1379 -> grn_rc;
1380 pub fn grn_string_get_encoding(ctx: *mut grn_ctx, string: *mut grn_obj)
1381 -> grn_encoding;
1382 pub fn grn_charlen(ctx: *mut grn_ctx, str: *const ::std::os::raw::c_char,
1383 end: *const ::std::os::raw::c_char)
1384 -> ::std::os::raw::c_int;
1385 pub fn grn_ctx_push(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
1386 pub fn grn_ctx_pop(ctx: *mut grn_ctx) -> *mut grn_obj;
1387 pub fn grn_obj_columns(ctx: *mut grn_ctx, table: *mut grn_obj,
1388 str: *const ::std::os::raw::c_char,
1389 str_size: ::std::os::raw::c_uint,
1390 res: *mut grn_obj) -> ::std::os::raw::c_int;
1391 pub fn grn_load(ctx: *mut grn_ctx, input_type: grn_content_type,
1392 table: *const ::std::os::raw::c_char,
1393 table_len: ::std::os::raw::c_uint,
1394 columns: *const ::std::os::raw::c_char,
1395 columns_len: ::std::os::raw::c_uint,
1396 values: *const ::std::os::raw::c_char,
1397 values_len: ::std::os::raw::c_uint,
1398 ifexists: *const ::std::os::raw::c_char,
1399 ifexists_len: ::std::os::raw::c_uint,
1400 each: *const ::std::os::raw::c_char,
1401 each_len: ::std::os::raw::c_uint) -> grn_rc;
1402 pub fn grn_ctx_connect(ctx: *mut grn_ctx,
1403 host: *const ::std::os::raw::c_char,
1404 port: ::std::os::raw::c_int,
1405 flags: ::std::os::raw::c_int) -> grn_rc;
1406 pub fn grn_ctx_send(ctx: *mut grn_ctx, str: *const ::std::os::raw::c_char,
1407 str_len: ::std::os::raw::c_uint,
1408 flags: ::std::os::raw::c_int)
1409 -> ::std::os::raw::c_uint;
1410 pub fn grn_ctx_recv(ctx: *mut grn_ctx,
1411 str: *mut *mut ::std::os::raw::c_char,
1412 str_len: *mut ::std::os::raw::c_uint,
1413 flags: *mut ::std::os::raw::c_int)
1414 -> ::std::os::raw::c_uint;
1415 pub fn grn_ctx_info_get(ctx: *mut grn_ctx, info: *mut grn_ctx_info)
1416 -> grn_rc;
1417 pub fn grn_set_segv_handler() -> grn_rc;
1418 pub fn grn_set_int_handler() -> grn_rc;
1419 pub fn grn_set_term_handler() -> grn_rc;
1420 pub fn grn_array_create(ctx: *mut grn_ctx,
1421 path: *const ::std::os::raw::c_char,
1422 value_size: ::std::os::raw::c_uint,
1423 flags: ::std::os::raw::c_uint) -> *mut grn_array;
1424 pub fn grn_array_open(ctx: *mut grn_ctx,
1425 path: *const ::std::os::raw::c_char)
1426 -> *mut grn_array;
1427 pub fn grn_array_close(ctx: *mut grn_ctx, array: *mut grn_array)
1428 -> grn_rc;
1429 pub fn grn_array_add(ctx: *mut grn_ctx, array: *mut grn_array,
1430 value: *mut *mut ::std::os::raw::c_void) -> grn_id;
1431 pub fn grn_array_push(ctx: *mut grn_ctx, array: *mut grn_array,
1432 func:
1433 ::std::option::Option<unsafe extern "C" fn(ctx:
1434 *mut grn_ctx,
1435 array:
1436 *mut grn_array,
1437 id:
1438 grn_id,
1439 func_arg:
1440 *mut ::std::os::raw::c_void)>,
1441 func_arg: *mut ::std::os::raw::c_void) -> grn_id;
1442 pub fn grn_array_pull(ctx: *mut grn_ctx, array: *mut grn_array,
1443 blockp: grn_bool,
1444 func:
1445 ::std::option::Option<unsafe extern "C" fn(ctx:
1446 *mut grn_ctx,
1447 array:
1448 *mut grn_array,
1449 id:
1450 grn_id,
1451 func_arg:
1452 *mut ::std::os::raw::c_void)>,
1453 func_arg: *mut ::std::os::raw::c_void) -> grn_id;
1454 pub fn grn_array_unblock(ctx: *mut grn_ctx, array: *mut grn_array);
1455 pub fn grn_array_get_value(ctx: *mut grn_ctx, array: *mut grn_array,
1456 id: grn_id,
1457 valuebuf: *mut ::std::os::raw::c_void)
1458 -> ::std::os::raw::c_int;
1459 pub fn grn_array_set_value(ctx: *mut grn_ctx, array: *mut grn_array,
1460 id: grn_id,
1461 value: *const ::std::os::raw::c_void,
1462 flags: ::std::os::raw::c_int) -> grn_rc;
1463 pub fn grn_array_cursor_open(ctx: *mut grn_ctx, array: *mut grn_array,
1464 min: grn_id, max: grn_id,
1465 offset: ::std::os::raw::c_int,
1466 limit: ::std::os::raw::c_int,
1467 flags: ::std::os::raw::c_int)
1468 -> *mut grn_array_cursor;
1469 pub fn grn_array_cursor_next(ctx: *mut grn_ctx,
1470 cursor: *mut grn_array_cursor) -> grn_id;
1471 pub fn grn_array_cursor_get_value(ctx: *mut grn_ctx,
1472 cursor: *mut grn_array_cursor,
1473 value: *mut *mut ::std::os::raw::c_void)
1474 -> ::std::os::raw::c_int;
1475 pub fn grn_array_cursor_set_value(ctx: *mut grn_ctx,
1476 cursor: *mut grn_array_cursor,
1477 value: *const ::std::os::raw::c_void,
1478 flags: ::std::os::raw::c_int) -> grn_rc;
1479 pub fn grn_array_cursor_delete(ctx: *mut grn_ctx,
1480 cursor: *mut grn_array_cursor,
1481 optarg: *mut grn_table_delete_optarg)
1482 -> grn_rc;
1483 pub fn grn_array_cursor_close(ctx: *mut grn_ctx,
1484 cursor: *mut grn_array_cursor);
1485 pub fn grn_array_delete_by_id(ctx: *mut grn_ctx, array: *mut grn_array,
1486 id: grn_id,
1487 optarg: *mut grn_table_delete_optarg)
1488 -> grn_rc;
1489 pub fn grn_array_next(ctx: *mut grn_ctx, array: *mut grn_array,
1490 id: grn_id) -> grn_id;
1491 pub fn _grn_array_get_value(ctx: *mut grn_ctx, array: *mut grn_array,
1492 id: grn_id) -> *mut ::std::os::raw::c_void;
1493 pub fn grn_column_get_flags(ctx: *mut grn_ctx, column: *mut grn_obj)
1494 -> grn_column_flags;
1495 pub fn grn_config_set(ctx: *mut grn_ctx,
1496 key: *const ::std::os::raw::c_char,
1497 key_size: int32_t,
1498 value: *const ::std::os::raw::c_char,
1499 value_size: int32_t) -> grn_rc;
1500 pub fn grn_config_get(ctx: *mut grn_ctx,
1501 key: *const ::std::os::raw::c_char,
1502 key_size: int32_t,
1503 value: *mut *const ::std::os::raw::c_char,
1504 value_size: *mut uint32_t) -> grn_rc;
1505 pub fn grn_config_delete(ctx: *mut grn_ctx,
1506 key: *const ::std::os::raw::c_char,
1507 key_size: int32_t) -> grn_rc;
1508 pub fn grn_config_cursor_open(ctx: *mut grn_ctx) -> *mut grn_obj;
1509 pub fn grn_config_cursor_next(ctx: *mut grn_ctx, cursor: *mut grn_obj)
1510 -> grn_bool;
1511 pub fn grn_config_cursor_get_key(ctx: *mut grn_ctx, cursor: *mut grn_obj,
1512 key: *mut *const ::std::os::raw::c_char)
1513 -> uint32_t;
1514 pub fn grn_config_cursor_get_value(ctx: *mut grn_ctx,
1515 cursor: *mut grn_obj,
1516 value:
1517 *mut *const ::std::os::raw::c_char)
1518 -> uint32_t;
1519 pub fn grn_conf_set(ctx: *mut grn_ctx, key: *const ::std::os::raw::c_char,
1520 key_size: int32_t,
1521 value: *const ::std::os::raw::c_char,
1522 value_size: int32_t) -> grn_rc;
1523 pub fn grn_conf_get(ctx: *mut grn_ctx, key: *const ::std::os::raw::c_char,
1524 key_size: int32_t,
1525 value: *mut *const ::std::os::raw::c_char,
1526 value_size: *mut uint32_t) -> grn_rc;
1527 pub fn grn_dat_scan(ctx: *mut grn_ctx, dat: *mut grn_dat,
1528 str: *const ::std::os::raw::c_char,
1529 str_size: ::std::os::raw::c_uint,
1530 scan_hits: *mut grn_dat_scan_hit,
1531 max_num_scan_hits: ::std::os::raw::c_uint,
1532 str_rest: *mut *const ::std::os::raw::c_char)
1533 -> ::std::os::raw::c_int;
1534 pub fn grn_dat_lcp_search(ctx: *mut grn_ctx, dat: *mut grn_dat,
1535 key: *const ::std::os::raw::c_void,
1536 key_size: ::std::os::raw::c_uint) -> grn_id;
1537 pub fn grn_dat_create(ctx: *mut grn_ctx,
1538 path: *const ::std::os::raw::c_char,
1539 key_size: ::std::os::raw::c_uint,
1540 value_size: ::std::os::raw::c_uint,
1541 flags: ::std::os::raw::c_uint) -> *mut grn_dat;
1542 pub fn grn_dat_open(ctx: *mut grn_ctx,
1543 path: *const ::std::os::raw::c_char) -> *mut grn_dat;
1544 pub fn grn_dat_close(ctx: *mut grn_ctx, dat: *mut grn_dat) -> grn_rc;
1545 pub fn grn_dat_remove(ctx: *mut grn_ctx,
1546 path: *const ::std::os::raw::c_char) -> grn_rc;
1547 pub fn grn_dat_get(ctx: *mut grn_ctx, dat: *mut grn_dat,
1548 key: *const ::std::os::raw::c_void,
1549 key_size: ::std::os::raw::c_uint,
1550 value: *mut *mut ::std::os::raw::c_void) -> grn_id;
1551 pub fn grn_dat_add(ctx: *mut grn_ctx, dat: *mut grn_dat,
1552 key: *const ::std::os::raw::c_void,
1553 key_size: ::std::os::raw::c_uint,
1554 value: *mut *mut ::std::os::raw::c_void,
1555 added: *mut ::std::os::raw::c_int) -> grn_id;
1556 pub fn grn_dat_get_key(ctx: *mut grn_ctx, dat: *mut grn_dat, id: grn_id,
1557 keybuf: *mut ::std::os::raw::c_void,
1558 bufsize: ::std::os::raw::c_int)
1559 -> ::std::os::raw::c_int;
1560 pub fn grn_dat_get_key2(ctx: *mut grn_ctx, dat: *mut grn_dat, id: grn_id,
1561 bulk: *mut grn_obj) -> ::std::os::raw::c_int;
1562 pub fn grn_dat_delete_by_id(ctx: *mut grn_ctx, dat: *mut grn_dat,
1563 id: grn_id,
1564 optarg: *mut grn_table_delete_optarg)
1565 -> grn_rc;
1566 pub fn grn_dat_delete(ctx: *mut grn_ctx, dat: *mut grn_dat,
1567 key: *const ::std::os::raw::c_void,
1568 key_size: ::std::os::raw::c_uint,
1569 optarg: *mut grn_table_delete_optarg) -> grn_rc;
1570 pub fn grn_dat_update_by_id(ctx: *mut grn_ctx, dat: *mut grn_dat,
1571 src_key_id: grn_id,
1572 dest_key: *const ::std::os::raw::c_void,
1573 dest_key_size: ::std::os::raw::c_uint)
1574 -> grn_rc;
1575 pub fn grn_dat_update(ctx: *mut grn_ctx, dat: *mut grn_dat,
1576 src_key: *const ::std::os::raw::c_void,
1577 src_key_size: ::std::os::raw::c_uint,
1578 dest_key: *const ::std::os::raw::c_void,
1579 dest_key_size: ::std::os::raw::c_uint) -> grn_rc;
1580 pub fn grn_dat_size(ctx: *mut grn_ctx, dat: *mut grn_dat)
1581 -> ::std::os::raw::c_uint;
1582 pub fn grn_dat_cursor_open(ctx: *mut grn_ctx, dat: *mut grn_dat,
1583 min: *const ::std::os::raw::c_void,
1584 min_size: ::std::os::raw::c_uint,
1585 max: *const ::std::os::raw::c_void,
1586 max_size: ::std::os::raw::c_uint,
1587 offset: ::std::os::raw::c_int,
1588 limit: ::std::os::raw::c_int,
1589 flags: ::std::os::raw::c_int)
1590 -> *mut grn_dat_cursor;
1591 pub fn grn_dat_cursor_next(ctx: *mut grn_ctx, c: *mut grn_dat_cursor)
1592 -> grn_id;
1593 pub fn grn_dat_cursor_close(ctx: *mut grn_ctx, c: *mut grn_dat_cursor);
1594 pub fn grn_dat_cursor_get_key(ctx: *mut grn_ctx, c: *mut grn_dat_cursor,
1595 key: *mut *const ::std::os::raw::c_void)
1596 -> ::std::os::raw::c_int;
1597 pub fn grn_dat_cursor_delete(ctx: *mut grn_ctx, c: *mut grn_dat_cursor,
1598 optarg: *mut grn_table_delete_optarg)
1599 -> grn_rc;
1600 pub fn grn_db_create(ctx: *mut grn_ctx,
1601 path: *const ::std::os::raw::c_char,
1602 optarg: *mut grn_db_create_optarg) -> *mut grn_obj;
1603 pub fn grn_db_open(ctx: *mut grn_ctx, path: *const ::std::os::raw::c_char)
1604 -> *mut grn_obj;
1605 pub fn grn_db_touch(ctx: *mut grn_ctx, db: *mut grn_obj);
1606 pub fn grn_db_recover(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_rc;
1607 pub fn grn_db_unmap(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_rc;
1608 pub fn grn_db_get_last_modified(ctx: *mut grn_ctx, db: *mut grn_obj)
1609 -> uint32_t;
1610 pub fn grn_db_is_dirty(ctx: *mut grn_ctx, db: *mut grn_obj) -> grn_bool;
1611 pub fn grn_dump_table_create_flags(ctx: *mut grn_ctx,
1612 flags: grn_table_flags,
1613 buffer: *mut grn_obj) -> grn_rc;
1614 pub fn grn_dump_column_create_flags(ctx: *mut grn_ctx,
1615 flags: grn_column_flags,
1616 buffer: *mut grn_obj) -> grn_rc;
1617 pub fn grn_rc_to_string(rc: grn_rc) -> *const ::std::os::raw::c_char;
1618 pub fn grn_expr_create(ctx: *mut grn_ctx,
1619 name: *const ::std::os::raw::c_char,
1620 name_size: ::std::os::raw::c_uint) -> *mut grn_obj;
1621 pub fn grn_expr_close(ctx: *mut grn_ctx, expr: *mut grn_obj) -> grn_rc;
1622 pub fn grn_expr_add_var(ctx: *mut grn_ctx, expr: *mut grn_obj,
1623 name: *const ::std::os::raw::c_char,
1624 name_size: ::std::os::raw::c_uint)
1625 -> *mut grn_obj;
1626 pub fn grn_expr_get_var(ctx: *mut grn_ctx, expr: *mut grn_obj,
1627 name: *const ::std::os::raw::c_char,
1628 name_size: ::std::os::raw::c_uint)
1629 -> *mut grn_obj;
1630 pub fn grn_expr_get_var_by_offset(ctx: *mut grn_ctx, expr: *mut grn_obj,
1631 offset: ::std::os::raw::c_uint)
1632 -> *mut grn_obj;
1633 pub fn grn_expr_clear_vars(ctx: *mut grn_ctx, expr: *mut grn_obj)
1634 -> grn_rc;
1635 pub fn grn_expr_take_obj(ctx: *mut grn_ctx, expr: *mut grn_obj,
1636 obj: *mut grn_obj);
1637 pub fn grn_expr_append_obj(ctx: *mut grn_ctx, expr: *mut grn_obj,
1638 obj: *mut grn_obj, op: grn_operator,
1639 nargs: ::std::os::raw::c_int) -> *mut grn_obj;
1640 pub fn grn_expr_append_const(ctx: *mut grn_ctx, expr: *mut grn_obj,
1641 obj: *mut grn_obj, op: grn_operator,
1642 nargs: ::std::os::raw::c_int)
1643 -> *mut grn_obj;
1644 pub fn grn_expr_append_const_str(ctx: *mut grn_ctx, expr: *mut grn_obj,
1645 str: *const ::std::os::raw::c_char,
1646 str_size: ::std::os::raw::c_uint,
1647 op: grn_operator,
1648 nargs: ::std::os::raw::c_int)
1649 -> *mut grn_obj;
1650 pub fn grn_expr_append_const_int(ctx: *mut grn_ctx, expr: *mut grn_obj,
1651 i: ::std::os::raw::c_int,
1652 op: grn_operator,
1653 nargs: ::std::os::raw::c_int)
1654 -> *mut grn_obj;
1655 pub fn grn_expr_append_op(ctx: *mut grn_ctx, expr: *mut grn_obj,
1656 op: grn_operator, nargs: ::std::os::raw::c_int)
1657 -> grn_rc;
1658 pub fn grn_expr_get_keywords(ctx: *mut grn_ctx, expr: *mut grn_obj,
1659 keywords: *mut grn_obj) -> grn_rc;
1660 pub fn grn_expr_syntax_escape(ctx: *mut grn_ctx,
1661 query: *const ::std::os::raw::c_char,
1662 query_size: ::std::os::raw::c_int,
1663 target_characters:
1664 *const ::std::os::raw::c_char,
1665 escape_character: ::std::os::raw::c_char,
1666 escaped_query: *mut grn_obj) -> grn_rc;
1667 pub fn grn_expr_syntax_escape_query(ctx: *mut grn_ctx,
1668 query: *const ::std::os::raw::c_char,
1669 query_size: ::std::os::raw::c_int,
1670 escaped_query: *mut grn_obj)
1671 -> grn_rc;
1672 pub fn grn_expr_syntax_expand_query(ctx: *mut grn_ctx,
1673 query: *const ::std::os::raw::c_char,
1674 query_size: ::std::os::raw::c_int,
1675 flags: grn_expr_flags,
1676 expander: *mut grn_obj,
1677 expanded_query: *mut grn_obj)
1678 -> grn_rc;
1679 pub fn grn_expr_compile(ctx: *mut grn_ctx, expr: *mut grn_obj) -> grn_rc;
1680 pub fn grn_expr_rewrite(ctx: *mut grn_ctx, expr: *mut grn_obj)
1681 -> *mut grn_obj;
1682 pub fn grn_expr_dump_plan(ctx: *mut grn_ctx, expr: *mut grn_obj,
1683 buffer: *mut grn_obj) -> grn_rc;
1684 pub fn grn_expr_exec(ctx: *mut grn_ctx, expr: *mut grn_obj,
1685 nargs: ::std::os::raw::c_int) -> *mut grn_obj;
1686 pub fn grn_expr_alloc(ctx: *mut grn_ctx, expr: *mut grn_obj,
1687 domain: grn_id, flags: ::std::os::raw::c_uchar)
1688 -> *mut grn_obj;
1689 pub fn grn_expr_parse(ctx: *mut grn_ctx, expr: *mut grn_obj,
1690 str: *const ::std::os::raw::c_char,
1691 str_size: ::std::os::raw::c_uint,
1692 default_column: *mut grn_obj,
1693 default_mode: grn_operator,
1694 default_op: grn_operator, flags: grn_expr_flags)
1695 -> grn_rc;
1696 pub fn grn_expr_snip(ctx: *mut grn_ctx, expr: *mut grn_obj,
1697 flags: ::std::os::raw::c_int,
1698 width: ::std::os::raw::c_uint,
1699 max_results: ::std::os::raw::c_uint,
1700 n_tags: ::std::os::raw::c_uint,
1701 opentags: *mut *const ::std::os::raw::c_char,
1702 opentag_lens: *mut ::std::os::raw::c_uint,
1703 closetags: *mut *const ::std::os::raw::c_char,
1704 closetag_lens: *mut ::std::os::raw::c_uint,
1705 mapping: *mut grn_snip_mapping) -> *mut grn_obj;
1706 pub fn grn_expr_snip_add_conditions(ctx: *mut grn_ctx, expr: *mut grn_obj,
1707 snip: *mut grn_obj,
1708 n_tags: ::std::os::raw::c_uint,
1709 opentags:
1710 *mut *const ::std::os::raw::c_char,
1711 opentag_lens:
1712 *mut ::std::os::raw::c_uint,
1713 closetags:
1714 *mut *const ::std::os::raw::c_char,
1715 closetag_lens:
1716 *mut ::std::os::raw::c_uint)
1717 -> grn_rc;
1718 pub fn grn_expr_estimate_size(ctx: *mut grn_ctx, expr: *mut grn_obj)
1719 -> ::std::os::raw::c_uint;
1720 pub fn grn_file_reader_open(ctx: *mut grn_ctx,
1721 path: *const ::std::os::raw::c_char)
1722 -> *mut grn_file_reader;
1723 pub fn grn_file_reader_close(ctx: *mut grn_ctx,
1724 reader: *mut grn_file_reader);
1725 pub fn grn_file_reader_read_line(ctx: *mut grn_ctx,
1726 reader: *mut grn_file_reader,
1727 buffer: *mut grn_obj) -> grn_rc;
1728 pub fn grn_geo_table_sort(ctx: *mut grn_ctx, table: *mut grn_obj,
1729 offset: ::std::os::raw::c_int,
1730 limit: ::std::os::raw::c_int,
1731 result: *mut grn_obj, column: *mut grn_obj,
1732 geo_point: *mut grn_obj)
1733 -> ::std::os::raw::c_int;
1734 pub fn grn_hash_create(ctx: *mut grn_ctx,
1735 path: *const ::std::os::raw::c_char,
1736 key_size: ::std::os::raw::c_uint,
1737 value_size: ::std::os::raw::c_uint,
1738 flags: ::std::os::raw::c_uint) -> *mut grn_hash;
1739 pub fn grn_hash_open(ctx: *mut grn_ctx,
1740 path: *const ::std::os::raw::c_char)
1741 -> *mut grn_hash;
1742 pub fn grn_hash_close(ctx: *mut grn_ctx, hash: *mut grn_hash) -> grn_rc;
1743 pub fn grn_hash_add(ctx: *mut grn_ctx, hash: *mut grn_hash,
1744 key: *const ::std::os::raw::c_void,
1745 key_size: ::std::os::raw::c_uint,
1746 value: *mut *mut ::std::os::raw::c_void,
1747 added: *mut ::std::os::raw::c_int) -> grn_id;
1748 pub fn grn_hash_get(ctx: *mut grn_ctx, hash: *mut grn_hash,
1749 key: *const ::std::os::raw::c_void,
1750 key_size: ::std::os::raw::c_uint,
1751 value: *mut *mut ::std::os::raw::c_void) -> grn_id;
1752 pub fn grn_hash_get_key(ctx: *mut grn_ctx, hash: *mut grn_hash,
1753 id: grn_id, keybuf: *mut ::std::os::raw::c_void,
1754 bufsize: ::std::os::raw::c_int)
1755 -> ::std::os::raw::c_int;
1756 pub fn grn_hash_get_key2(ctx: *mut grn_ctx, hash: *mut grn_hash,
1757 id: grn_id, bulk: *mut grn_obj)
1758 -> ::std::os::raw::c_int;
1759 pub fn grn_hash_get_value(ctx: *mut grn_ctx, hash: *mut grn_hash,
1760 id: grn_id,
1761 valuebuf: *mut ::std::os::raw::c_void)
1762 -> ::std::os::raw::c_int;
1763 pub fn grn_hash_set_value(ctx: *mut grn_ctx, hash: *mut grn_hash,
1764 id: grn_id,
1765 value: *const ::std::os::raw::c_void,
1766 flags: ::std::os::raw::c_int) -> grn_rc;
1767 pub fn grn_hash_delete_by_id(ctx: *mut grn_ctx, hash: *mut grn_hash,
1768 id: grn_id,
1769 optarg: *mut grn_table_delete_optarg)
1770 -> grn_rc;
1771 pub fn grn_hash_delete(ctx: *mut grn_ctx, hash: *mut grn_hash,
1772 key: *const ::std::os::raw::c_void,
1773 key_size: ::std::os::raw::c_uint,
1774 optarg: *mut grn_table_delete_optarg) -> grn_rc;
1775 pub fn grn_hash_size(ctx: *mut grn_ctx, hash: *mut grn_hash) -> uint32_t;
1776 pub fn grn_hash_cursor_open(ctx: *mut grn_ctx, hash: *mut grn_hash,
1777 min: *const ::std::os::raw::c_void,
1778 min_size: ::std::os::raw::c_uint,
1779 max: *const ::std::os::raw::c_void,
1780 max_size: ::std::os::raw::c_uint,
1781 offset: ::std::os::raw::c_int,
1782 limit: ::std::os::raw::c_int,
1783 flags: ::std::os::raw::c_int)
1784 -> *mut grn_hash_cursor;
1785 pub fn grn_hash_cursor_next(ctx: *mut grn_ctx, c: *mut grn_hash_cursor)
1786 -> grn_id;
1787 pub fn grn_hash_cursor_close(ctx: *mut grn_ctx, c: *mut grn_hash_cursor);
1788 pub fn grn_hash_cursor_get_key(ctx: *mut grn_ctx, c: *mut grn_hash_cursor,
1789 key: *mut *mut ::std::os::raw::c_void)
1790 -> ::std::os::raw::c_int;
1791 pub fn grn_hash_cursor_get_value(ctx: *mut grn_ctx,
1792 c: *mut grn_hash_cursor,
1793 value: *mut *mut ::std::os::raw::c_void)
1794 -> ::std::os::raw::c_int;
1795 pub fn grn_hash_cursor_set_value(ctx: *mut grn_ctx,
1796 c: *mut grn_hash_cursor,
1797 value: *const ::std::os::raw::c_void,
1798 flags: ::std::os::raw::c_int) -> grn_rc;
1799 pub fn grn_hash_cursor_get_key_value(ctx: *mut grn_ctx,
1800 c: *mut grn_hash_cursor,
1801 key:
1802 *mut *mut ::std::os::raw::c_void,
1803 key_size:
1804 *mut ::std::os::raw::c_uint,
1805 value:
1806 *mut *mut ::std::os::raw::c_void)
1807 -> ::std::os::raw::c_int;
1808 pub fn grn_hash_cursor_delete(ctx: *mut grn_ctx, c: *mut grn_hash_cursor,
1809 optarg: *mut grn_table_delete_optarg)
1810 -> grn_rc;
1811 pub fn grn_id_is_builtin(ctx: *mut grn_ctx, id: grn_id) -> grn_bool;
1812 pub fn grn_ii_estimate_size(ctx: *mut grn_ctx, ii: *mut grn_ii,
1813 tid: grn_id) -> uint32_t;
1814 pub fn grn_ii_estimate_size_for_query(ctx: *mut grn_ctx, ii: *mut grn_ii,
1815 query:
1816 *const ::std::os::raw::c_char,
1817 query_len: ::std::os::raw::c_uint,
1818 optarg: *mut grn_search_optarg)
1819 -> uint32_t;
1820 pub fn grn_ii_estimate_size_for_lexicon_cursor(ctx: *mut grn_ctx,
1821 ii: *mut grn_ii,
1822 lexicon_cursor:
1823 *mut grn_table_cursor)
1824 -> uint32_t;
1825 pub fn grn_ii_buffer_open(ctx: *mut grn_ctx, ii: *mut grn_ii,
1826 update_buffer_size: ::std::os::raw::c_ulonglong)
1827 -> *mut grn_ii_buffer;
1828 pub fn grn_ii_buffer_append(ctx: *mut grn_ctx,
1829 ii_buffer: *mut grn_ii_buffer, rid: grn_id,
1830 section: ::std::os::raw::c_uint,
1831 value: *mut grn_obj) -> grn_rc;
1832 pub fn grn_ii_buffer_commit(ctx: *mut grn_ctx,
1833 ii_buffer: *mut grn_ii_buffer) -> grn_rc;
1834 pub fn grn_ii_buffer_close(ctx: *mut grn_ctx,
1835 ii_buffer: *mut grn_ii_buffer) -> grn_rc;
1836 pub fn grn_ii_cursor_open(ctx: *mut grn_ctx, ii: *mut grn_ii, tid: grn_id,
1837 min: grn_id, max: grn_id,
1838 nelements: ::std::os::raw::c_int,
1839 flags: ::std::os::raw::c_int)
1840 -> *mut grn_ii_cursor;
1841 pub fn grn_ii_cursor_next(ctx: *mut grn_ctx, c: *mut grn_ii_cursor)
1842 -> *mut grn_posting;
1843 pub fn grn_ii_cursor_close(ctx: *mut grn_ctx, c: *mut grn_ii_cursor)
1844 -> grn_rc;
1845 pub fn grn_obj_is_true(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
1846 pub fn grn_obj_is_builtin(ctx: *mut grn_ctx, obj: *mut grn_obj)
1847 -> grn_bool;
1848 pub fn grn_obj_is_table(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
1849 pub fn grn_obj_is_column(ctx: *mut grn_ctx, obj: *mut grn_obj)
1850 -> grn_bool;
1851 pub fn grn_obj_is_reference_column(ctx: *mut grn_ctx, obj: *mut grn_obj)
1852 -> grn_bool;
1853 pub fn grn_obj_is_index_column(ctx: *mut grn_ctx, obj: *mut grn_obj)
1854 -> grn_bool;
1855 pub fn grn_obj_is_accessor(ctx: *mut grn_ctx, obj: *mut grn_obj)
1856 -> grn_bool;
1857 pub fn grn_obj_is_key_accessor(ctx: *mut grn_ctx, obj: *mut grn_obj)
1858 -> grn_bool;
1859 pub fn grn_obj_is_type(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
1860 pub fn grn_obj_is_text_family_type(ctx: *mut grn_ctx, obj: *mut grn_obj)
1861 -> grn_bool;
1862 pub fn grn_obj_is_proc(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
1863 pub fn grn_obj_is_tokenizer_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
1864 -> grn_bool;
1865 pub fn grn_obj_is_function_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
1866 -> grn_bool;
1867 pub fn grn_obj_is_selector_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
1868 -> grn_bool;
1869 pub fn grn_obj_is_selector_only_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
1870 -> grn_bool;
1871 pub fn grn_obj_is_normalizer_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
1872 -> grn_bool;
1873 pub fn grn_obj_is_token_filter_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
1874 -> grn_bool;
1875 pub fn grn_obj_is_scorer_proc(ctx: *mut grn_ctx, obj: *mut grn_obj)
1876 -> grn_bool;
1877 pub fn grn_obj_is_window_function_proc(ctx: *mut grn_ctx,
1878 obj: *mut grn_obj) -> grn_bool;
1879 pub fn grn_obj_cast(ctx: *mut grn_ctx, src: *mut grn_obj,
1880 dest: *mut grn_obj, add_record_if_not_exist: grn_bool)
1881 -> grn_rc;
1882 pub fn grn_obj_reindex(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_rc;
1883 pub fn grn_obj_touch(ctx: *mut grn_ctx, obj: *mut grn_obj,
1884 tv: *mut grn_timeval);
1885 pub fn grn_obj_get_last_modified(ctx: *mut grn_ctx, obj: *mut grn_obj)
1886 -> uint32_t;
1887 pub fn grn_obj_is_dirty(ctx: *mut grn_ctx, obj: *mut grn_obj) -> grn_bool;
1888 pub fn grn_obj_type_to_string(type_: uint8_t)
1889 -> *const ::std::os::raw::c_char;
1890 pub fn grn_obj_name_is_column(ctx: *mut grn_ctx,
1891 name: *const ::std::os::raw::c_char,
1892 name_len: ::std::os::raw::c_int)
1893 -> grn_bool;
1894 pub fn grn_operator_to_string(op: grn_operator)
1895 -> *const ::std::os::raw::c_char;
1896 pub fn grn_operator_exec_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
1897 y: *mut grn_obj) -> grn_bool;
1898 pub fn grn_operator_exec_not_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
1899 y: *mut grn_obj) -> grn_bool;
1900 pub fn grn_operator_exec_less(ctx: *mut grn_ctx, x: *mut grn_obj,
1901 y: *mut grn_obj) -> grn_bool;
1902 pub fn grn_operator_exec_greater(ctx: *mut grn_ctx, x: *mut grn_obj,
1903 y: *mut grn_obj) -> grn_bool;
1904 pub fn grn_operator_exec_less_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
1905 y: *mut grn_obj) -> grn_bool;
1906 pub fn grn_operator_exec_greater_equal(ctx: *mut grn_ctx, x: *mut grn_obj,
1907 y: *mut grn_obj) -> grn_bool;
1908 pub fn grn_operator_exec_match(ctx: *mut grn_ctx, target: *mut grn_obj,
1909 sub_text: *mut grn_obj) -> grn_bool;
1910 pub fn grn_operator_exec_prefix(ctx: *mut grn_ctx, target: *mut grn_obj,
1911 prefix: *mut grn_obj) -> grn_bool;
1912 pub fn grn_operator_exec_regexp(ctx: *mut grn_ctx, target: *mut grn_obj,
1913 pattern: *mut grn_obj) -> grn_bool;
1914 pub fn grn_output_obj(ctx: *mut grn_ctx, outbuf: *mut grn_obj,
1915 output_type: grn_content_type, obj: *mut grn_obj,
1916 format: *mut grn_obj_format);
1917 pub fn grn_output_envelope(ctx: *mut grn_ctx, rc: grn_rc,
1918 head: *mut grn_obj, body: *mut grn_obj,
1919 foot: *mut grn_obj,
1920 file: *const ::std::os::raw::c_char,
1921 line: ::std::os::raw::c_int);
1922 pub fn grn_ctx_output_flush(ctx: *mut grn_ctx,
1923 flags: ::std::os::raw::c_int);
1924 pub fn grn_ctx_output_array_open(ctx: *mut grn_ctx,
1925 name: *const ::std::os::raw::c_char,
1926 nelements: ::std::os::raw::c_int);
1927 pub fn grn_ctx_output_array_close(ctx: *mut grn_ctx);
1928 pub fn grn_ctx_output_map_open(ctx: *mut grn_ctx,
1929 name: *const ::std::os::raw::c_char,
1930 nelements: ::std::os::raw::c_int);
1931 pub fn grn_ctx_output_map_close(ctx: *mut grn_ctx);
1932 pub fn grn_ctx_output_null(ctx: *mut grn_ctx);
1933 pub fn grn_ctx_output_int32(ctx: *mut grn_ctx,
1934 value: ::std::os::raw::c_int);
1935 pub fn grn_ctx_output_int64(ctx: *mut grn_ctx, value: int64_t);
1936 pub fn grn_ctx_output_uint64(ctx: *mut grn_ctx, value: uint64_t);
1937 pub fn grn_ctx_output_float(ctx: *mut grn_ctx, value: f64);
1938 pub fn grn_ctx_output_cstr(ctx: *mut grn_ctx,
1939 value: *const ::std::os::raw::c_char);
1940 pub fn grn_ctx_output_str(ctx: *mut grn_ctx,
1941 value: *const ::std::os::raw::c_char,
1942 value_len: ::std::os::raw::c_uint);
1943 pub fn grn_ctx_output_bool(ctx: *mut grn_ctx, value: grn_bool);
1944 pub fn grn_ctx_output_obj(ctx: *mut grn_ctx, value: *mut grn_obj,
1945 format: *mut grn_obj_format);
1946 pub fn grn_ctx_output_result_set_open(ctx: *mut grn_ctx,
1947 result_set: *mut grn_obj,
1948 format: *mut grn_obj_format,
1949 n_additional_elements: uint32_t);
1950 pub fn grn_ctx_output_result_set_close(ctx: *mut grn_ctx,
1951 result_set: *mut grn_obj,
1952 format: *mut grn_obj_format);
1953 pub fn grn_ctx_output_result_set(ctx: *mut grn_ctx,
1954 result_set: *mut grn_obj,
1955 format: *mut grn_obj_format);
1956 pub fn grn_ctx_output_table_columns(ctx: *mut grn_ctx,
1957 table: *mut grn_obj,
1958 format: *mut grn_obj_format);
1959 pub fn grn_ctx_output_table_records(ctx: *mut grn_ctx,
1960 table: *mut grn_obj,
1961 format: *mut grn_obj_format);
1962 pub fn grn_ctx_get_output_type(ctx: *mut grn_ctx) -> grn_content_type;
1963 pub fn grn_ctx_set_output_type(ctx: *mut grn_ctx, type_: grn_content_type)
1964 -> grn_rc;
1965 pub fn grn_ctx_get_mime_type(ctx: *mut grn_ctx)
1966 -> *const ::std::os::raw::c_char;
1967 pub fn grn_text_otoj(ctx: *mut grn_ctx, bulk: *mut grn_obj,
1968 obj: *mut grn_obj, format: *mut grn_obj_format)
1969 -> grn_rc;
1970 pub fn grn_pat_create(ctx: *mut grn_ctx,
1971 path: *const ::std::os::raw::c_char,
1972 key_size: ::std::os::raw::c_uint,
1973 value_size: ::std::os::raw::c_uint,
1974 flags: ::std::os::raw::c_uint) -> *mut grn_pat;
1975 pub fn grn_pat_open(ctx: *mut grn_ctx,
1976 path: *const ::std::os::raw::c_char) -> *mut grn_pat;
1977 pub fn grn_pat_close(ctx: *mut grn_ctx, pat: *mut grn_pat) -> grn_rc;
1978 pub fn grn_pat_remove(ctx: *mut grn_ctx,
1979 path: *const ::std::os::raw::c_char) -> grn_rc;
1980 pub fn grn_pat_get(ctx: *mut grn_ctx, pat: *mut grn_pat,
1981 key: *const ::std::os::raw::c_void,
1982 key_size: ::std::os::raw::c_uint,
1983 value: *mut *mut ::std::os::raw::c_void) -> grn_id;
1984 pub fn grn_pat_add(ctx: *mut grn_ctx, pat: *mut grn_pat,
1985 key: *const ::std::os::raw::c_void,
1986 key_size: ::std::os::raw::c_uint,
1987 value: *mut *mut ::std::os::raw::c_void,
1988 added: *mut ::std::os::raw::c_int) -> grn_id;
1989 pub fn grn_pat_get_key(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
1990 keybuf: *mut ::std::os::raw::c_void,
1991 bufsize: ::std::os::raw::c_int)
1992 -> ::std::os::raw::c_int;
1993 pub fn grn_pat_get_key2(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
1994 bulk: *mut grn_obj) -> ::std::os::raw::c_int;
1995 pub fn grn_pat_get_value(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
1996 valuebuf: *mut ::std::os::raw::c_void)
1997 -> ::std::os::raw::c_int;
1998 pub fn grn_pat_set_value(ctx: *mut grn_ctx, pat: *mut grn_pat, id: grn_id,
1999 value: *const ::std::os::raw::c_void,
2000 flags: ::std::os::raw::c_int) -> grn_rc;
2001 pub fn grn_pat_delete_by_id(ctx: *mut grn_ctx, pat: *mut grn_pat,
2002 id: grn_id,
2003 optarg: *mut grn_table_delete_optarg)
2004 -> grn_rc;
2005 pub fn grn_pat_delete(ctx: *mut grn_ctx, pat: *mut grn_pat,
2006 key: *const ::std::os::raw::c_void,
2007 key_size: ::std::os::raw::c_uint,
2008 optarg: *mut grn_table_delete_optarg) -> grn_rc;
2009 pub fn grn_pat_delete_with_sis(ctx: *mut grn_ctx, pat: *mut grn_pat,
2010 id: grn_id,
2011 optarg: *mut grn_table_delete_optarg)
2012 -> ::std::os::raw::c_int;
2013 pub fn grn_pat_scan(ctx: *mut grn_ctx, pat: *mut grn_pat,
2014 str: *const ::std::os::raw::c_char,
2015 str_len: ::std::os::raw::c_uint,
2016 sh: *mut grn_pat_scan_hit,
2017 sh_size: ::std::os::raw::c_uint,
2018 rest: *mut *const ::std::os::raw::c_char)
2019 -> ::std::os::raw::c_int;
2020 pub fn grn_pat_prefix_search(ctx: *mut grn_ctx, pat: *mut grn_pat,
2021 key: *const ::std::os::raw::c_void,
2022 key_size: ::std::os::raw::c_uint,
2023 h: *mut grn_hash) -> grn_rc;
2024 pub fn grn_pat_suffix_search(ctx: *mut grn_ctx, pat: *mut grn_pat,
2025 key: *const ::std::os::raw::c_void,
2026 key_size: ::std::os::raw::c_uint,
2027 h: *mut grn_hash) -> grn_rc;
2028 pub fn grn_pat_lcp_search(ctx: *mut grn_ctx, pat: *mut grn_pat,
2029 key: *const ::std::os::raw::c_void,
2030 key_size: ::std::os::raw::c_uint) -> grn_id;
2031 pub fn grn_pat_size(ctx: *mut grn_ctx, pat: *mut grn_pat)
2032 -> ::std::os::raw::c_uint;
2033 pub fn grn_pat_cursor_open(ctx: *mut grn_ctx, pat: *mut grn_pat,
2034 min: *const ::std::os::raw::c_void,
2035 min_size: ::std::os::raw::c_uint,
2036 max: *const ::std::os::raw::c_void,
2037 max_size: ::std::os::raw::c_uint,
2038 offset: ::std::os::raw::c_int,
2039 limit: ::std::os::raw::c_int,
2040 flags: ::std::os::raw::c_int)
2041 -> *mut grn_pat_cursor;
2042 pub fn grn_pat_cursor_next(ctx: *mut grn_ctx, c: *mut grn_pat_cursor)
2043 -> grn_id;
2044 pub fn grn_pat_cursor_close(ctx: *mut grn_ctx, c: *mut grn_pat_cursor);
2045 pub fn grn_pat_cursor_get_key(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
2046 key: *mut *mut ::std::os::raw::c_void)
2047 -> ::std::os::raw::c_int;
2048 pub fn grn_pat_cursor_get_value(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
2049 value: *mut *mut ::std::os::raw::c_void)
2050 -> ::std::os::raw::c_int;
2051 pub fn grn_pat_cursor_get_key_value(ctx: *mut grn_ctx,
2052 c: *mut grn_pat_cursor,
2053 key: *mut *mut ::std::os::raw::c_void,
2054 key_size: *mut ::std::os::raw::c_uint,
2055 value:
2056 *mut *mut ::std::os::raw::c_void)
2057 -> ::std::os::raw::c_int;
2058 pub fn grn_pat_cursor_set_value(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
2059 value: *const ::std::os::raw::c_void,
2060 flags: ::std::os::raw::c_int) -> grn_rc;
2061 pub fn grn_pat_cursor_delete(ctx: *mut grn_ctx, c: *mut grn_pat_cursor,
2062 optarg: *mut grn_table_delete_optarg)
2063 -> grn_rc;
2064 pub fn grn_request_canceler_register(ctx: *mut grn_ctx,
2065 request_id:
2066 *const ::std::os::raw::c_char,
2067 size: ::std::os::raw::c_uint);
2068 pub fn grn_request_canceler_unregister(ctx: *mut grn_ctx,
2069 request_id:
2070 *const ::std::os::raw::c_char,
2071 size: ::std::os::raw::c_uint);
2072 pub fn grn_request_canceler_cancel(request_id:
2073 *const ::std::os::raw::c_char,
2074 size: ::std::os::raw::c_uint)
2075 -> grn_bool;
2076 pub fn grn_request_canceler_cancel_all() -> grn_bool;
2077 pub fn grn_request_timer_set(timer: *mut grn_request_timer);
2078 pub fn grn_request_timer_register(request_id:
2079 *const ::std::os::raw::c_char,
2080 request_id_size: ::std::os::raw::c_uint,
2081 timeout: f64)
2082 -> *mut ::std::os::raw::c_void;
2083 pub fn grn_request_timer_unregister(timer_id:
2084 *mut ::std::os::raw::c_void);
2085 pub fn grn_get_default_request_timeout() -> f64;
2086 pub fn grn_set_default_request_timeout(timeout: f64);
2087 pub fn grn_table_create(ctx: *mut grn_ctx,
2088 name: *const ::std::os::raw::c_char,
2089 name_size: ::std::os::raw::c_uint,
2090 path: *const ::std::os::raw::c_char,
2091 flags: grn_table_flags, key_type: *mut grn_obj,
2092 value_type: *mut grn_obj) -> *mut grn_obj;
2093 pub fn grn_table_add(ctx: *mut grn_ctx, table: *mut grn_obj,
2094 key: *const ::std::os::raw::c_void,
2095 key_size: ::std::os::raw::c_uint,
2096 added: *mut ::std::os::raw::c_int) -> grn_id;
2097 pub fn grn_table_get(ctx: *mut grn_ctx, table: *mut grn_obj,
2098 key: *const ::std::os::raw::c_void,
2099 key_size: ::std::os::raw::c_uint) -> grn_id;
2100 pub fn grn_table_at(ctx: *mut grn_ctx, table: *mut grn_obj, id: grn_id)
2101 -> grn_id;
2102 pub fn grn_table_lcp_search(ctx: *mut grn_ctx, table: *mut grn_obj,
2103 key: *const ::std::os::raw::c_void,
2104 key_size: ::std::os::raw::c_uint) -> grn_id;
2105 pub fn grn_table_get_key(ctx: *mut grn_ctx, table: *mut grn_obj,
2106 id: grn_id, keybuf: *mut ::std::os::raw::c_void,
2107 buf_size: ::std::os::raw::c_int)
2108 -> ::std::os::raw::c_int;
2109 pub fn grn_table_delete(ctx: *mut grn_ctx, table: *mut grn_obj,
2110 key: *const ::std::os::raw::c_void,
2111 key_size: ::std::os::raw::c_uint) -> grn_rc;
2112 pub fn grn_table_delete_by_id(ctx: *mut grn_ctx, table: *mut grn_obj,
2113 id: grn_id) -> grn_rc;
2114 pub fn grn_table_update_by_id(ctx: *mut grn_ctx, table: *mut grn_obj,
2115 id: grn_id,
2116 dest_key: *const ::std::os::raw::c_void,
2117 dest_key_size: ::std::os::raw::c_uint)
2118 -> grn_rc;
2119 pub fn grn_table_update(ctx: *mut grn_ctx, table: *mut grn_obj,
2120 src_key: *const ::std::os::raw::c_void,
2121 src_key_size: ::std::os::raw::c_uint,
2122 dest_key: *const ::std::os::raw::c_void,
2123 dest_key_size: ::std::os::raw::c_uint) -> grn_rc;
2124 pub fn grn_table_truncate(ctx: *mut grn_ctx, table: *mut grn_obj)
2125 -> grn_rc;
2126 pub fn grn_table_cursor_open(ctx: *mut grn_ctx, table: *mut grn_obj,
2127 min: *const ::std::os::raw::c_void,
2128 min_size: ::std::os::raw::c_uint,
2129 max: *const ::std::os::raw::c_void,
2130 max_size: ::std::os::raw::c_uint,
2131 offset: ::std::os::raw::c_int,
2132 limit: ::std::os::raw::c_int,
2133 flags: ::std::os::raw::c_int)
2134 -> *mut grn_table_cursor;
2135 pub fn grn_table_cursor_close(ctx: *mut grn_ctx,
2136 tc: *mut grn_table_cursor) -> grn_rc;
2137 pub fn grn_table_cursor_next(ctx: *mut grn_ctx, tc: *mut grn_table_cursor)
2138 -> grn_id;
2139 pub fn grn_table_cursor_get_key(ctx: *mut grn_ctx,
2140 tc: *mut grn_table_cursor,
2141 key: *mut *mut ::std::os::raw::c_void)
2142 -> ::std::os::raw::c_int;
2143 pub fn grn_table_cursor_get_value(ctx: *mut grn_ctx,
2144 tc: *mut grn_table_cursor,
2145 value: *mut *mut ::std::os::raw::c_void)
2146 -> ::std::os::raw::c_int;
2147 pub fn grn_table_cursor_set_value(ctx: *mut grn_ctx,
2148 tc: *mut grn_table_cursor,
2149 value: *const ::std::os::raw::c_void,
2150 flags: ::std::os::raw::c_int) -> grn_rc;
2151 pub fn grn_table_cursor_delete(ctx: *mut grn_ctx,
2152 tc: *mut grn_table_cursor) -> grn_rc;
2153 pub fn grn_table_cursor_table(ctx: *mut grn_ctx,
2154 tc: *mut grn_table_cursor) -> *mut grn_obj;
2155 pub fn grn_index_cursor_open(ctx: *mut grn_ctx, tc: *mut grn_table_cursor,
2156 index: *mut grn_obj, rid_min: grn_id,
2157 rid_max: grn_id,
2158 flags: ::std::os::raw::c_int)
2159 -> *mut grn_obj;
2160 pub fn grn_index_cursor_next(ctx: *mut grn_ctx, ic: *mut grn_obj,
2161 tid: *mut grn_id) -> *mut grn_posting;
2162 pub fn grn_table_sort(ctx: *mut grn_ctx, table: *mut grn_obj,
2163 offset: ::std::os::raw::c_int,
2164 limit: ::std::os::raw::c_int, result: *mut grn_obj,
2165 keys: *mut grn_table_sort_key,
2166 n_keys: ::std::os::raw::c_int)
2167 -> ::std::os::raw::c_int;
2168 pub fn grn_table_group(ctx: *mut grn_ctx, table: *mut grn_obj,
2169 keys: *mut grn_table_sort_key,
2170 n_keys: ::std::os::raw::c_int,
2171 results: *mut grn_table_group_result,
2172 n_results: ::std::os::raw::c_int) -> grn_rc;
2173 pub fn grn_table_setoperation(ctx: *mut grn_ctx, table1: *mut grn_obj,
2174 table2: *mut grn_obj, res: *mut grn_obj,
2175 op: grn_operator) -> grn_rc;
2176 pub fn grn_table_difference(ctx: *mut grn_ctx, table1: *mut grn_obj,
2177 table2: *mut grn_obj, res1: *mut grn_obj,
2178 res2: *mut grn_obj) -> grn_rc;
2179 pub fn grn_table_columns(ctx: *mut grn_ctx, table: *mut grn_obj,
2180 name: *const ::std::os::raw::c_char,
2181 name_size: ::std::os::raw::c_uint,
2182 res: *mut grn_obj) -> ::std::os::raw::c_int;
2183 pub fn grn_table_size(ctx: *mut grn_ctx, table: *mut grn_obj)
2184 -> ::std::os::raw::c_uint;
2185 pub fn grn_table_select(ctx: *mut grn_ctx, table: *mut grn_obj,
2186 expr: *mut grn_obj, res: *mut grn_obj,
2187 op: grn_operator) -> *mut grn_obj;
2188 pub fn grn_table_sort_key_from_str(ctx: *mut grn_ctx,
2189 str: *const ::std::os::raw::c_char,
2190 str_size: ::std::os::raw::c_uint,
2191 table: *mut grn_obj,
2192 nkeys: *mut ::std::os::raw::c_uint)
2193 -> *mut grn_table_sort_key;
2194 pub fn grn_table_sort_key_close(ctx: *mut grn_ctx,
2195 keys: *mut grn_table_sort_key,
2196 nkeys: ::std::os::raw::c_uint) -> grn_rc;
2197 pub fn grn_table_is_grouped(ctx: *mut grn_ctx, table: *mut grn_obj)
2198 -> grn_bool;
2199 pub fn grn_table_max_n_subrecs(ctx: *mut grn_ctx, table: *mut grn_obj)
2200 -> ::std::os::raw::c_uint;
2201 pub fn grn_table_create_for_group(ctx: *mut grn_ctx,
2202 name: *const ::std::os::raw::c_char,
2203 name_size: ::std::os::raw::c_uint,
2204 path: *const ::std::os::raw::c_char,
2205 group_key: *mut grn_obj,
2206 value_type: *mut grn_obj,
2207 max_n_subrecs: ::std::os::raw::c_uint)
2208 -> *mut grn_obj;
2209 pub fn grn_table_get_subrecs(ctx: *mut grn_ctx, table: *mut grn_obj,
2210 id: grn_id, subrecbuf: *mut grn_id,
2211 scorebuf: *mut ::std::os::raw::c_int,
2212 buf_size: ::std::os::raw::c_int)
2213 -> ::std::os::raw::c_uint;
2214 pub fn grn_table_tokenize(ctx: *mut grn_ctx, table: *mut grn_obj,
2215 str: *const ::std::os::raw::c_char,
2216 str_len: ::std::os::raw::c_uint,
2217 buf: *mut grn_obj, addp: grn_bool)
2218 -> *mut grn_obj;
2219 pub fn grn_thread_get_limit() -> uint32_t;
2220 pub fn grn_thread_set_limit(new_limit: uint32_t);
2221 pub fn grn_thread_set_get_limit_func(func: grn_thread_get_limit_func,
2222 data: *mut ::std::os::raw::c_void);
2223 pub fn grn_thread_set_set_limit_func(func: grn_thread_set_limit_func,
2224 data: *mut ::std::os::raw::c_void);
2225 pub fn grn_type_id_is_builtin(ctx: *mut grn_ctx, id: grn_id) -> grn_bool;
2232 pub fn grn_type_id_is_number_family(ctx: *mut grn_ctx, id: grn_id)
2233 -> grn_bool;
2234 pub fn grn_type_id_is_text_family(ctx: *mut grn_ctx, id: grn_id)
2235 -> grn_bool;
2236 pub fn grn_type_create(ctx: *mut grn_ctx,
2237 name: *const ::std::os::raw::c_char,
2238 name_size: ::std::os::raw::c_uint,
2239 flags: grn_obj_flags, size: ::std::os::raw::c_uint)
2240 -> *mut grn_obj;
2241 pub fn grn_type_size(ctx: *mut grn_ctx, type_: *mut grn_obj) -> uint32_t;
2242 pub fn grn_inspect(ctx: *mut grn_ctx, buffer: *mut grn_obj,
2243 obj: *mut grn_obj) -> *mut grn_obj;
2244 pub fn grn_inspect_indented(ctx: *mut grn_ctx, buffer: *mut grn_obj,
2245 obj: *mut grn_obj,
2246 indent: *const ::std::os::raw::c_char)
2247 -> *mut grn_obj;
2248 pub fn grn_inspect_name(ctx: *mut grn_ctx, buffer: *mut grn_obj,
2249 obj: *mut grn_obj) -> *mut grn_obj;
2250 pub fn grn_inspect_encoding(ctx: *mut grn_ctx, buffer: *mut grn_obj,
2251 encoding: grn_encoding) -> *mut grn_obj;
2252 pub fn grn_inspect_type(ctx: *mut grn_ctx, buffer: *mut grn_obj,
2253 type_: ::std::os::raw::c_uchar) -> *mut grn_obj;
2254 pub fn grn_p(ctx: *mut grn_ctx, obj: *mut grn_obj);
2255 pub fn grn_p_geo_point(ctx: *mut grn_ctx, point: *mut grn_geo_point);
2256 pub fn grn_p_ii_values(ctx: *mut grn_ctx, obj: *mut grn_obj);
2257 pub fn grn_window_next(ctx: *mut grn_ctx, window: *mut grn_window)
2258 -> grn_id;
2259 pub fn grn_window_rewind(ctx: *mut grn_ctx, window: *mut grn_window)
2260 -> grn_rc;
2261 pub fn grn_window_set_direction(ctx: *mut grn_ctx,
2262 window: *mut grn_window,
2263 direction: grn_window_direction)
2264 -> grn_rc;
2265 pub fn grn_window_get_table(ctx: *mut grn_ctx, window: *mut grn_window)
2266 -> *mut grn_obj;
2267 pub fn grn_window_function_create(ctx: *mut grn_ctx,
2268 name: *const ::std::os::raw::c_char,
2269 name_size: ::std::os::raw::c_int,
2270 func: grn_window_function_func)
2271 -> *mut grn_obj;
2272 pub fn grn_table_apply_window_function(ctx: *mut grn_ctx,
2273 table: *mut grn_obj,
2274 output_column: *mut grn_obj,
2275 definition:
2276 *mut grn_window_definition,
2277 window_function_call: *mut grn_obj)
2278 -> grn_rc;
2279 pub fn grn_windows_event_logger_set(ctx: *mut grn_ctx,
2280 event_source_name:
2281 *const ::std::os::raw::c_char)
2282 -> grn_rc;
2283}