mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-05-17 20:37:12 +02:00
Code Issues Projects Releases Packages Wiki Activity

Update Mroonga to the latest version on 2017-10-10T23:15:25+0900

Browse source
This commit is contained in:
Kentoku 2017-10-10 23:15:25 +09:00
commit 13167e6489
1795 changed files with 171698 additions and 108720 deletions
Download patch file Download diff file Expand all files Collapse all files

4
storage/mroonga/vendor/groonga/include/Makefile.am vendored
View file

@ -1,6 +1,8 @@
SUBDIRS = groonga
pkginclude_HEADERS = groonga.h
pkginclude_HEADERS = \
groonga.h \
groonga.hpp
EXTRA_DIST = \
CMakeLists.txt

43
storage/mroonga/vendor/groonga/include/groonga.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2014-2015 Brazil
Copyright(C) 2014-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,16 +15,39 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_H
#define GROONGA_H
#pragma once
#include "groonga/portability.h"
#include "groonga/groonga.h"
#include "groonga/obj.h"
#include "groonga/ii.h"
#include "groonga/expr.h"
#include "groonga/output.h"
#include "groonga/util.h"
#include "groonga/request_canceler.h"
#endif /* GROONGA_H */
#include "groonga/accessor.h"
#include "groonga/array.h"
#include "groonga/arrow.h"
#include "groonga/cache.h"
#include "groonga/column.h"
#include "groonga/config.h"
#include "groonga/dat.h"
#include "groonga/db.h"
#include "groonga/dump.h"
#include "groonga/error.h"
#include "groonga/expr.h"
#include "groonga/file_reader.h"
#include "groonga/geo.h"
#include "groonga/hash.h"
#include "groonga/id.h"
#include "groonga/ii.h"
#include "groonga/obj.h"
#include "groonga/operator.h"
#include "groonga/output.h"
#include "groonga/pat.h"
#include "groonga/request_canceler.h"
#include "groonga/request_timer.h"
#include "groonga/table.h"
#include "groonga/thread.h"
#include "groonga/time.h"
#include "groonga/type.h"
#include "groonga/util.h"
#include "groonga/window_function.h"
#include "groonga/windows.h"
#include "groonga/windows_event_logger.h"

21
storage/mroonga/vendor/groonga/include/groonga.hpp vendored Normal file
View file

@ -0,0 +1,21 @@
/*
Copyright(C) 2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include "groonga.h"

27
storage/mroonga/vendor/groonga/include/groonga/Makefile.am vendored
View file

@ -1,18 +1,43 @@
groonga_includedir = $(pkgincludedir)/groonga
groonga_include_HEADERS = \
accessor.h \
array.h \
arrow.h \
arrow.hpp \
cache.h \
column.h \
command.h \
config.h \
dat.h \
db.h \
dump.h \
error.h \
expr.h \
file_reader.h \
hash.h \
geo.h \
groonga.h \
id.h \
ii.h \
obj.h \
operator.h \
output.h \
pat.h \
plugin.h \
portability.h \
request_canceler.h \
request_timer.h \
scorer.h \
table.h \
thread.h \
time.h \
token.h \
tokenizer.h \
token_filter.h \
type.h \
nfkc.h \
normalizer.h \
util.h
util.h \
window_function.h \
windows.h \
windows_event_logger.h

34
storage/mroonga/vendor/groonga/include/groonga/accessor.h vendored Normal file
View file

@ -0,0 +1,34 @@
/*
Copyright(C) 2012-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API grn_rc grn_accessor_resolve(grn_ctx *ctx,
grn_obj *accessor,
int deep,
grn_obj *base_res,
grn_obj *res,
grn_operator op);
#ifdef __cplusplus
}
#endif

89
storage/mroonga/vendor/groonga/include/groonga/array.h vendored Normal file
View file

@ -0,0 +1,89 @@
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _grn_array grn_array;
typedef struct _grn_array_cursor grn_array_cursor;
GRN_API grn_array *grn_array_create(grn_ctx *ctx, const char *path,
unsigned int value_size, unsigned int flags);
GRN_API grn_array *grn_array_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_array_close(grn_ctx *ctx, grn_array *array);
GRN_API grn_id grn_array_add(grn_ctx *ctx, grn_array *array, void **value);
GRN_API grn_id grn_array_push(grn_ctx *ctx, grn_array *array,
void (*func)(grn_ctx *ctx, grn_array *array,
grn_id id, void *func_arg),
void *func_arg);
GRN_API grn_id grn_array_pull(grn_ctx *ctx, grn_array *array, grn_bool blockp,
void (*func)(grn_ctx *ctx, grn_array *array,
grn_id id, void *func_arg),
void *func_arg);
GRN_API void grn_array_unblock(grn_ctx *ctx, grn_array *array);
GRN_API int grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id, void *valuebuf);
GRN_API grn_rc grn_array_set_value(grn_ctx *ctx, grn_array *array, grn_id id,
const void *value, int flags);
GRN_API grn_array_cursor *grn_array_cursor_open(grn_ctx *ctx, grn_array *array,
grn_id min, grn_id max,
int offset, int limit, int flags);
GRN_API grn_id grn_array_cursor_next(grn_ctx *ctx, grn_array_cursor *cursor);
GRN_API int grn_array_cursor_get_value(grn_ctx *ctx, grn_array_cursor *cursor, void **value);
GRN_API grn_rc grn_array_cursor_set_value(grn_ctx *ctx, grn_array_cursor *cursor,
const void *value, int flags);
GRN_API grn_rc grn_array_cursor_delete(grn_ctx *ctx, grn_array_cursor *cursor,
grn_table_delete_optarg *optarg);
GRN_API void grn_array_cursor_close(grn_ctx *ctx, grn_array_cursor *cursor);
GRN_API grn_rc grn_array_delete_by_id(grn_ctx *ctx, grn_array *array, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_id grn_array_next(grn_ctx *ctx, grn_array *array, grn_id id);
GRN_API void *_grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id);
#define GRN_ARRAY_EACH(ctx,array,head,tail,id,value,block) do {\
grn_array_cursor *_sc = grn_array_cursor_open(ctx, array, head, tail, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_array_cursor_next(ctx, _sc))) {\
grn_array_cursor_get_value(ctx, _sc, (void **)(value));\
block\
}\
grn_array_cursor_close(ctx, _sc); \
}\
} while (0)
#define GRN_ARRAY_EACH_BEGIN(ctx, array, cursor, head, tail, id) do {\
grn_array_cursor *cursor;\
cursor = grn_array_cursor_open((ctx), (array), (head), (tail), 0, -1, 0);\
if (cursor) {\
grn_id id;\
while ((id = grn_array_cursor_next(ctx, cursor))) {
#define GRN_ARRAY_EACH_END(ctx, cursor)\
}\
grn_array_cursor_close(ctx, cursor);\
}\
} while (0)
#ifdef __cplusplus
}
#endif

38
storage/mroonga/vendor/groonga/include/groonga/arrow.h vendored Normal file
View file

@ -0,0 +1,38 @@
/*
Copyright(C) 2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API grn_rc grn_arrow_load(grn_ctx *ctx,
grn_obj *table,
const char *path);
GRN_API grn_rc grn_arrow_dump(grn_ctx *ctx,
grn_obj *table,
const char *path);
GRN_API grn_rc grn_arrow_dump_columns(grn_ctx *ctx,
grn_obj *table,
grn_obj *columns,
const char *path);
#ifdef __cplusplus
}
#endif

21
storage/mroonga/vendor/groonga/include/groonga/arrow.hpp vendored Normal file
View file

@ -0,0 +1,21 @@
/*
Copyright(C) 2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <groonga.hpp>

49
storage/mroonga/vendor/groonga/include/groonga/cache.h vendored Normal file
View file

@ -0,0 +1,49 @@
/*
Copyright(C) 2013-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#define GRN_CACHE_DEFAULT_MAX_N_ENTRIES 100
typedef struct _grn_cache grn_cache;
GRN_API void grn_set_default_cache_base_path(const char *base_path);
GRN_API const char *grn_get_default_cache_base_path(void);
GRN_API grn_cache *grn_cache_open(grn_ctx *ctx);
GRN_API grn_cache *grn_persistent_cache_open(grn_ctx *ctx,
const char *base_path);
GRN_API grn_rc grn_cache_close(grn_ctx *ctx, grn_cache *cache);
GRN_API grn_rc grn_cache_current_set(grn_ctx *ctx, grn_cache *cache);
GRN_API grn_cache *grn_cache_current_get(grn_ctx *ctx);
GRN_API grn_rc grn_cache_default_reopen(void);
GRN_API grn_rc grn_cache_set_max_n_entries(grn_ctx *ctx,
grn_cache *cache,
unsigned int n);
GRN_API unsigned int grn_cache_get_max_n_entries(grn_ctx *ctx,
grn_cache *cache);
#ifdef __cplusplus
}
#endif

29
storage/mroonga/vendor/groonga/include/groonga/column.h vendored Normal file
View file

@ -0,0 +1,29 @@
/*
Copyright(C) 2009-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API grn_column_flags grn_column_get_flags(grn_ctx *ctx, grn_obj *column);
#ifdef __cplusplus
}
#endif

8
storage/mroonga/vendor/groonga/include/groonga/command.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2015 Brazil
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_COMMAND_H
#define GROONGA_COMMAND_H
#pragma once
#include <groonga/plugin.h>
@ -77,5 +77,3 @@ GRN_PLUGIN_EXPORT grn_rc grn_command_run(grn_ctx *ctx,
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* GROONGA_COMMAND_H */

65
storage/mroonga/vendor/groonga/include/groonga/config.h vendored Normal file
View file

@ -0,0 +1,65 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 2.1 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#define GRN_CONFIG_MAX_KEY_SIZE GRN_TABLE_MAX_KEY_SIZE
#define GRN_CONFIG_MAX_VALUE_SIZE \
(GRN_CONFIG_VALUE_SPACE_SIZE - sizeof(uint32_t) - 1) /* 1 is for '\0' */
#define GRN_CONFIG_VALUE_SPACE_SIZE (4 * 1024)
GRN_API grn_rc grn_config_set(grn_ctx *ctx,
const char *key, int32_t key_size,
const char *value, int32_t value_size);
GRN_API grn_rc grn_config_get(grn_ctx *ctx,
const char *key, int32_t key_size,
const char **value, uint32_t *value_size);
GRN_API grn_rc grn_config_delete(grn_ctx *ctx,
const char *key, int32_t key_size);
GRN_API grn_obj *grn_config_cursor_open(grn_ctx *ctx);
GRN_API grn_bool grn_config_cursor_next(grn_ctx *ctx, grn_obj *cursor);
GRN_API uint32_t grn_config_cursor_get_key(grn_ctx *ctx,
grn_obj *cursor,
const char **key);
GRN_API uint32_t grn_config_cursor_get_value(grn_ctx *ctx,
grn_obj *cursor,
const char **value);
/* Deprecated since 5.1.2. Use GRN_CONFIG_* instead. */
#define GRN_CONF_MAX_KEY_SIZE GRN_CONFIG_MAX_KEY_SIZE
#define GRN_CONF_MAX_VALUE_SIZE GRN_CONFIG_MAX_VALUE_SIZE
#define GRN_CONF_VALUE_SPACE_SIZE GRN_CONFIG_VALUE_SPACE_SIZE
GRN_API grn_rc grn_conf_set(grn_ctx *ctx,
const char *key, int32_t key_size,
const char *value, int32_t value_size);
GRN_API grn_rc grn_conf_get(grn_ctx *ctx,
const char *key, int32_t key_size,
const char **value, uint32_t *value_size);
#ifdef __cplusplus
}
#endif

100
storage/mroonga/vendor/groonga/include/groonga/dat.h vendored Normal file
View file

@ -0,0 +1,100 @@
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _grn_dat grn_dat;
typedef struct _grn_dat_cursor grn_dat_cursor;
typedef struct _grn_table_scan_hit grn_dat_scan_hit;
GRN_API int grn_dat_scan(grn_ctx *ctx, grn_dat *dat, const char *str,
unsigned int str_size, grn_dat_scan_hit *scan_hits,
unsigned int max_num_scan_hits, const char **str_rest);
GRN_API grn_id grn_dat_lcp_search(grn_ctx *ctx, grn_dat *dat,
const void *key, unsigned int key_size);
GRN_API grn_dat *grn_dat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_dat *grn_dat_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_dat_close(grn_ctx *ctx, grn_dat *dat);
GRN_API grn_rc grn_dat_remove(grn_ctx *ctx, const char *path);
GRN_API grn_id grn_dat_get(grn_ctx *ctx, grn_dat *dat, const void *key,
unsigned int key_size, void **value);
GRN_API grn_id grn_dat_add(grn_ctx *ctx, grn_dat *dat, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API int grn_dat_get_key(grn_ctx *ctx, grn_dat *dat, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_dat_get_key2(grn_ctx *ctx, grn_dat *dat, grn_id id, grn_obj *bulk);
GRN_API grn_rc grn_dat_delete_by_id(grn_ctx *ctx, grn_dat *dat, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_dat_delete(grn_ctx *ctx, grn_dat *dat, const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_dat_update_by_id(grn_ctx *ctx, grn_dat *dat, grn_id src_key_id,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_dat_update(grn_ctx *ctx, grn_dat *dat,
const void *src_key, unsigned int src_key_size,
const void *dest_key, unsigned int dest_key_size);
GRN_API unsigned int grn_dat_size(grn_ctx *ctx, grn_dat *dat);
GRN_API grn_dat_cursor *grn_dat_cursor_open(grn_ctx *ctx, grn_dat *dat,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_dat_cursor_next(grn_ctx *ctx, grn_dat_cursor *c);
GRN_API void grn_dat_cursor_close(grn_ctx *ctx, grn_dat_cursor *c);
GRN_API int grn_dat_cursor_get_key(grn_ctx *ctx, grn_dat_cursor *c, const void **key);
GRN_API grn_rc grn_dat_cursor_delete(grn_ctx *ctx, grn_dat_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_DAT_EACH(ctx,dat,id,key,key_size,block) do {\
grn_dat_cursor *_sc = grn_dat_cursor_open(ctx, dat, NULL, 0, NULL, 0, 0, -1, 0);\
if (_sc) {\
grn_id id;\
unsigned int *_ks = (key_size);\
if (_ks) {\
while ((id = grn_dat_cursor_next(ctx, _sc))) {\
int _ks_raw = grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
*(_ks) = (unsigned int)_ks_raw;\
block\
}\
} else {\
while ((id = grn_dat_cursor_next(ctx, _sc))) {\
grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
block\
}\
}\
grn_dat_cursor_close(ctx, _sc);\
}\
} while (0)
#ifdef __cplusplus
}
#endif

68
storage/mroonga/vendor/groonga/include/groonga/db.h vendored Normal file
View file

@ -0,0 +1,68 @@
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _grn_db_create_optarg grn_db_create_optarg;
struct _grn_db_create_optarg {
char **builtin_type_names;
int n_builtin_type_names;
};
GRN_API grn_obj *grn_db_create(grn_ctx *ctx, const char *path, grn_db_create_optarg *optarg);
#define GRN_DB_OPEN_OR_CREATE(ctx,path,optarg,db) \
(((db) = grn_db_open((ctx), (path))) || (db = grn_db_create((ctx), (path), (optarg))))
GRN_API grn_obj *grn_db_open(grn_ctx *ctx, const char *path);
GRN_API void grn_db_touch(grn_ctx *ctx, grn_obj *db);
GRN_API grn_rc grn_db_recover(grn_ctx *ctx, grn_obj *db);
GRN_API grn_rc grn_db_unmap(grn_ctx *ctx, grn_obj *db);
GRN_API uint32_t grn_db_get_last_modified(grn_ctx *ctx, grn_obj *db);
GRN_API grn_bool grn_db_is_dirty(grn_ctx *ctx, grn_obj *db);
#define GRN_DB_EACH_BEGIN_FLAGS(ctx, cursor, id, flags) \
GRN_TABLE_EACH_BEGIN_FLAGS(ctx, \
grn_ctx_db((ctx)), \
cursor, \
id, \
flags)
#define GRN_DB_EACH_BEGIN_BY_ID(ctx, cursor, id) \
GRN_DB_EACH_BEGIN_FLAGS(ctx, \
cursor, \
id, \
GRN_CURSOR_BY_ID | GRN_CURSOR_ASCENDING)
#define GRN_DB_EACH_BEGIN_BY_KEY(ctx, cursor, id) \
GRN_DB_EACH_BEGIN_FLAGS(ctx, \
cursor, \
id, \
GRN_CURSOR_BY_KEY | GRN_CURSOR_ASCENDING)
#define GRN_DB_EACH_END(ctx, cursor) \
GRN_TABLE_EACH_END(ctx, cursor)
#ifdef __cplusplus
}
#endif

34
storage/mroonga/vendor/groonga/include/groonga/dump.h vendored Normal file
View file

@ -0,0 +1,34 @@
/*
Copyright(C) 2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API grn_rc grn_dump_table_create_flags(grn_ctx *ctx,
grn_table_flags flags,
grn_obj *buffer);
GRN_API grn_rc grn_dump_column_create_flags(grn_ctx *ctx,
grn_column_flags flags,
grn_obj *buffer);
#ifdef __cplusplus
}
#endif

29
storage/mroonga/vendor/groonga/include/groonga/error.h vendored Normal file
View file

@ -0,0 +1,29 @@
/*
Copyright(C) 2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API const char *grn_rc_to_string(grn_rc rc);
#ifdef __cplusplus
}
#endif

47
storage/mroonga/vendor/groonga/include/groonga/expr.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2009-2014 Brazil
Copyright(C) 2009-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,13 +15,25 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_EXPR_H
#define GROONGA_EXPR_H
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef unsigned int grn_expr_flags;
#define GRN_EXPR_SYNTAX_QUERY (0x00)
#define GRN_EXPR_SYNTAX_SCRIPT (0x01)
#define GRN_EXPR_SYNTAX_OUTPUT_COLUMNS (0x20)
#define GRN_EXPR_SYNTAX_ADJUSTER (0x40)
#define GRN_EXPR_ALLOW_PRAGMA (0x02)
#define GRN_EXPR_ALLOW_COLUMN (0x04)
#define GRN_EXPR_ALLOW_UPDATE (0x08)
#define GRN_EXPR_ALLOW_LEADING_NOT (0x10)
#define GRN_EXPR_QUERY_NO_SYNTAX_ERROR (0x80)
GRN_API grn_obj *grn_expr_create(grn_ctx *ctx, const char *name, unsigned int name_size);
GRN_API grn_rc grn_expr_close(grn_ctx *ctx, grn_obj *expr);
GRN_API grn_obj *grn_expr_add_var(grn_ctx *ctx, grn_obj *expr,
@ -31,6 +43,7 @@ GRN_API grn_obj *grn_expr_get_var(grn_ctx *ctx, grn_obj *expr,
GRN_API grn_obj *grn_expr_get_var_by_offset(grn_ctx *ctx, grn_obj *expr, unsigned int offset);
GRN_API grn_rc grn_expr_clear_vars(grn_ctx *ctx, grn_obj *expr);
GRN_API void grn_expr_take_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj);
GRN_API grn_obj *grn_expr_append_obj(grn_ctx *ctx, grn_obj *expr, grn_obj *obj,
grn_operator op, int nargs);
@ -53,13 +66,26 @@ GRN_API grn_rc grn_expr_syntax_escape(grn_ctx *ctx,
GRN_API grn_rc grn_expr_syntax_escape_query(grn_ctx *ctx,
const char *query, int query_size,
grn_obj *escaped_query);
GRN_API grn_rc grn_expr_syntax_expand_query(grn_ctx *ctx,
const char *query, int query_size,
grn_expr_flags flags,
grn_obj *expander,
grn_obj *expanded_query);
GRN_API grn_rc grn_expr_syntax_expand_query_by_table(grn_ctx *ctx,
const char *query,
int query_size,
grn_expr_flags flags,
grn_obj *term_column,
grn_obj *expanded_term_column,
grn_obj *expanded_query);
GRN_API grn_rc grn_expr_compile(grn_ctx *ctx, grn_obj *expr);
GRN_API grn_obj *grn_expr_rewrite(grn_ctx *ctx, grn_obj *expr);
GRN_API grn_rc grn_expr_dump_plan(grn_ctx *ctx, grn_obj *expr, grn_obj *buffer);
GRN_API grn_obj *grn_expr_exec(grn_ctx *ctx, grn_obj *expr, int nargs);
GRN_API grn_obj *grn_expr_alloc(grn_ctx *ctx, grn_obj *expr,
grn_id domain, grn_obj_flags flags);
grn_id domain, unsigned char flags);
#define GRN_EXPR_CREATE_FOR_QUERY(ctx,table,expr,var) do {\
if (((expr) = grn_expr_create((ctx), NULL, 0)) &&\
@ -70,17 +96,6 @@ GRN_API grn_obj *grn_expr_alloc(grn_ctx *ctx, grn_obj *expr,
}\
} while (0)
typedef unsigned int grn_expr_flags;
#define GRN_EXPR_SYNTAX_QUERY (0x00)
#define GRN_EXPR_SYNTAX_SCRIPT (0x01)
#define GRN_EXPR_SYNTAX_OUTPUT_COLUMNS (0x20)
#define GRN_EXPR_SYNTAX_ADJUSTER (0x40)
#define GRN_EXPR_ALLOW_PRAGMA (0x02)
#define GRN_EXPR_ALLOW_COLUMN (0x04)
#define GRN_EXPR_ALLOW_UPDATE (0x08)
#define GRN_EXPR_ALLOW_LEADING_NOT (0x10)
GRN_API grn_rc grn_expr_parse(grn_ctx *ctx, grn_obj *expr,
const char *str, unsigned int str_size,
grn_obj *default_column, grn_operator default_mode,
@ -106,5 +121,3 @@ GRN_API unsigned int grn_expr_estimate_size(grn_ctx *ctx, grn_obj *expr);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_EXPR_H */

37
storage/mroonga/vendor/groonga/include/groonga/file_reader.h vendored Normal file
View file

@ -0,0 +1,37 @@
/*
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _grn_file_reader grn_file_reader;
GRN_API grn_file_reader *grn_file_reader_open(grn_ctx *ctx, const char *path);
GRN_API void grn_file_reader_close(grn_ctx *ctx,
grn_file_reader *reader);
GRN_API grn_rc grn_file_reader_read_line(grn_ctx *ctx,
grn_file_reader *reader,
grn_obj *buffer);
#ifdef __cplusplus
}
#endif

36
storage/mroonga/vendor/groonga/include/groonga/geo.h vendored Normal file
View file

@ -0,0 +1,36 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API int grn_geo_table_sort(grn_ctx *ctx,
grn_obj *table,
int offset,
int limit,
grn_obj *result,
grn_obj *column,
grn_obj *geo_point);
#ifdef __cplusplus
}
#endif

703
storage/mroonga/vendor/groonga/include/groonga/groonga.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2009-2015 Brazil
Copyright(C) 2009-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,11 +15,13 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_GROONGA_H
#define GROONGA_GROONGA_H
#pragma once
#include <stdarg.h>
#include <sys/types.h>
#include <stdint.h>
#include <string.h>
#ifdef __cplusplus
extern "C" {
@ -34,7 +36,7 @@ extern "C" {
#endif /* GRN_API */
typedef unsigned int grn_id;
typedef unsigned char grn_bool;
typedef uint8_t grn_bool;
#define GRN_ID_NIL (0x00)
#define GRN_ID_MAX (0x3fffffff)
@ -122,12 +124,17 @@ typedef enum {
GRN_TOKEN_FILTER_ERROR = -73,
GRN_COMMAND_ERROR = -74,
GRN_PLUGIN_ERROR = -75,
GRN_SCORER_ERROR = -76
GRN_SCORER_ERROR = -76,
GRN_CANCEL = -77,
GRN_WINDOW_FUNCTION_ERROR = -78,
GRN_ZSTD_ERROR = -79
} grn_rc;
GRN_API grn_rc grn_init(void);
GRN_API grn_rc grn_fin(void);
GRN_API const char *grn_get_global_error_message(void);
typedef enum {
GRN_ENC_DEFAULT = 0,
GRN_ENC_NONE,
@ -141,12 +148,13 @@ typedef enum {
typedef enum {
GRN_COMMAND_VERSION_DEFAULT = 0,
GRN_COMMAND_VERSION_1,
GRN_COMMAND_VERSION_2
GRN_COMMAND_VERSION_2,
GRN_COMMAND_VERSION_3
} grn_command_version;
#define GRN_COMMAND_VERSION_MIN GRN_COMMAND_VERSION_1
#define GRN_COMMAND_VERSION_STABLE GRN_COMMAND_VERSION_1
#define GRN_COMMAND_VERSION_MAX GRN_COMMAND_VERSION_2
#define GRN_COMMAND_VERSION_MAX GRN_COMMAND_VERSION_3
typedef enum {
GRN_LOG_NONE = 0,
@ -161,6 +169,9 @@ typedef enum {
GRN_LOG_DUMP
} grn_log_level;
GRN_API const char *grn_log_level_to_string(grn_log_level level);
GRN_API grn_bool grn_log_level_parse(const char *string, grn_log_level *level);
/* query log flags */
#define GRN_QUERY_LOG_NONE (0x00)
#define GRN_QUERY_LOG_COMMAND (0x01<<0)
@ -237,6 +248,10 @@ GRN_API grn_ctx *grn_ctx_open(int flags);
GRN_API grn_rc grn_ctx_close(grn_ctx *ctx);
GRN_API grn_rc grn_ctx_set_finalizer(grn_ctx *ctx, grn_proc_func *func);
GRN_API grn_rc grn_ctx_push_temporary_open_space(grn_ctx *ctx);
GRN_API grn_rc grn_ctx_pop_temporary_open_space(grn_ctx *ctx);
GRN_API grn_rc grn_ctx_merge_temporary_open_space(grn_ctx *ctx);
GRN_API grn_encoding grn_get_default_encoding(void);
GRN_API grn_rc grn_set_default_encoding(grn_encoding encoding);
@ -246,6 +261,7 @@ GRN_API grn_rc grn_set_default_encoding(grn_encoding encoding);
GRN_API const char *grn_get_version(void);
GRN_API const char *grn_get_package(void);
GRN_API const char *grn_get_package_label(void);
GRN_API grn_command_version grn_get_default_command_version(void);
GRN_API grn_rc grn_set_default_command_version(grn_command_version version);
@ -259,22 +275,6 @@ GRN_API grn_rc grn_set_default_match_escalation_threshold(long long int threshol
GRN_API int grn_get_lock_timeout(void);
GRN_API grn_rc grn_set_lock_timeout(int timeout);
/* cache */
#define GRN_CACHE_DEFAULT_MAX_N_ENTRIES 100
typedef struct _grn_cache grn_cache;
GRN_API grn_cache *grn_cache_open(grn_ctx *ctx);
GRN_API grn_rc grn_cache_close(grn_ctx *ctx, grn_cache *cache);
GRN_API grn_rc grn_cache_current_set(grn_ctx *ctx, grn_cache *cache);
GRN_API grn_cache *grn_cache_current_get(grn_ctx *ctx);
GRN_API grn_rc grn_cache_set_max_n_entries(grn_ctx *ctx,
grn_cache *cache,
unsigned int n);
GRN_API unsigned int grn_cache_get_max_n_entries(grn_ctx *ctx,
grn_cache *cache);
/* grn_encoding */
GRN_API const char *grn_encoding_to_string(grn_encoding encoding);
@ -282,7 +282,13 @@ GRN_API grn_encoding grn_encoding_parse(const char *name);
/* obj */
typedef unsigned short int grn_obj_flags;
typedef uint16_t grn_obj_flags;
typedef uint32_t grn_table_flags;
typedef uint32_t grn_column_flags;
/* flags for grn_obj_flags and grn_table_flags */
#define GRN_OBJ_FLAGS_MASK (0xffff)
#define GRN_OBJ_TABLE_TYPE_MASK (0x07)
#define GRN_OBJ_TABLE_HASH_KEY (0x00)
@ -310,6 +316,7 @@ typedef unsigned short int grn_obj_flags;
#define GRN_OBJ_COMPRESS_LZ4 (0x02<<4)
/* Just for backward compatibility. We'll remove it at 5.0.0. */
#define GRN_OBJ_COMPRESS_LZO GRN_OBJ_COMPRESS_LZ4
#define GRN_OBJ_COMPRESS_ZSTD (0x03<<4)
#define GRN_OBJ_WITH_SECTION (0x01<<7)
#define GRN_OBJ_WITH_WEIGHT (0x01<<8)
@ -327,6 +334,8 @@ typedef unsigned short int grn_obj_flags;
#define GRN_OBJ_UNIT_USERDEF_SECTION (0x07<<8)
#define GRN_OBJ_UNIT_USERDEF_POSITION (0x08<<8)
/* Don't use (0x01<<12) because it's used internally. */
#define GRN_OBJ_NO_SUBREC (0x00<<13)
#define GRN_OBJ_WITH_SUBREC (0x01<<13)
@ -335,6 +344,15 @@ typedef unsigned short int grn_obj_flags;
#define GRN_OBJ_TEMPORARY (0x00<<15)
#define GRN_OBJ_PERSISTENT (0x01<<15)
/* flags only for grn_table_flags */
#define GRN_OBJ_KEY_LARGE (0x01<<16)
/* flags only for grn_column_flags */
#define GRN_OBJ_INDEX_SMALL (0x01<<16)
#define GRN_OBJ_INDEX_MEDIUM (0x01<<17)
/* obj types */
#define GRN_VOID (0x00)
@ -355,6 +373,7 @@ typedef unsigned short int grn_obj_flags;
#define GRN_CURSOR_TABLE_NO_KEY (0x13)
#define GRN_CURSOR_COLUMN_INDEX (0x18)
#define GRN_CURSOR_COLUMN_GEO_INDEX (0x1a)
#define GRN_CURSOR_CONFIG (0x1f)
#define GRN_TYPE (0x20)
#define GRN_PROC (0x21)
#define GRN_EXPR (0x22)
@ -402,6 +421,7 @@ struct _grn_obj {
#define GRN_OBJ_REFER (0x01<<0)
#define GRN_OBJ_OUTPLACE (0x01<<1)
#define GRN_OBJ_OWN (0x01<<5)
#define GRN_OBJ_INIT(obj,obj_type,obj_flags,obj_domain) do { \
(obj)->header.type = (obj_type);\
@ -415,26 +435,17 @@ struct _grn_obj {
#define GRN_OBJ_FIN(ctx,obj) (grn_obj_close((ctx), (obj)))
typedef struct _grn_db_create_optarg grn_db_create_optarg;
struct _grn_db_create_optarg {
char **builtin_type_names;
int n_builtin_type_names;
};
GRN_API grn_obj *grn_db_create(grn_ctx *ctx, const char *path, grn_db_create_optarg *optarg);
#define GRN_DB_OPEN_OR_CREATE(ctx,path,optarg,db) \
(((db) = grn_db_open((ctx), (path))) || (db = grn_db_create((ctx), (path), (optarg))))
GRN_API grn_obj *grn_db_open(grn_ctx *ctx, const char *path);
GRN_API void grn_db_touch(grn_ctx *ctx, grn_obj *db);
GRN_API grn_rc grn_db_recover(grn_ctx *ctx, grn_obj *db);
GRN_API grn_rc grn_ctx_use(grn_ctx *ctx, grn_obj *db);
GRN_API grn_obj *grn_ctx_db(grn_ctx *ctx);
GRN_API grn_obj *grn_ctx_get(grn_ctx *ctx, const char *name, int name_size);
GRN_API grn_rc grn_ctx_get_all_tables(grn_ctx *ctx, grn_obj *tables_buffer);
GRN_API grn_rc grn_ctx_get_all_types(grn_ctx *ctx, grn_obj *types_buffer);
GRN_API grn_rc grn_ctx_get_all_tokenizers(grn_ctx *ctx,
grn_obj *tokenizers_buffer);
GRN_API grn_rc grn_ctx_get_all_normalizers(grn_ctx *ctx,
grn_obj *normalizers_buffer);
GRN_API grn_rc grn_ctx_get_all_token_filters(grn_ctx *ctx,
grn_obj *token_filters_buffer);
typedef enum {
GRN_DB_VOID = 0,
@ -467,9 +478,7 @@ typedef enum {
} grn_builtin_tokenizer;
GRN_API grn_obj *grn_ctx_at(grn_ctx *ctx, grn_id id);
GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,
grn_obj_flags flags, unsigned int size);
GRN_API grn_bool grn_ctx_is_opened(grn_ctx *ctx, grn_id id);
GRN_API grn_rc grn_plugin_register(grn_ctx *ctx, const char *name);
GRN_API grn_rc grn_plugin_unregister(grn_ctx *ctx, const char *name);
@ -478,6 +487,7 @@ GRN_API grn_rc grn_plugin_unregister_by_path(grn_ctx *ctx, const char *path);
GRN_API const char *grn_plugin_get_system_plugins_dir(void);
GRN_API const char *grn_plugin_get_suffix(void);
GRN_API const char *grn_plugin_get_ruby_suffix(void);
GRN_API grn_rc grn_plugin_get_names(grn_ctx *ctx, grn_obj *names);
typedef struct {
const char *name;
@ -495,7 +505,8 @@ typedef enum {
GRN_PROC_HOOK,
GRN_PROC_NORMALIZER,
GRN_PROC_TOKEN_FILTER,
GRN_PROC_SCORER
GRN_PROC_SCORER,
GRN_PROC_WINDOW_FUNCTION
} grn_proc_type;
GRN_API grn_obj *grn_proc_create(grn_ctx *ctx,
@ -506,136 +517,17 @@ GRN_API grn_obj *grn_proc_get_info(grn_ctx *ctx, grn_user_data *user_data,
grn_expr_var **vars, unsigned int *nvars, grn_obj **caller);
GRN_API grn_proc_type grn_proc_get_type(grn_ctx *ctx, grn_obj *proc);
/*-------------------------------------------------------------
* API for table
*/
#define GRN_TABLE_MAX_KEY_SIZE (0x1000)
GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
const char *name, unsigned int name_size,
const char *path, grn_obj_flags flags,
grn_obj *key_type, grn_obj *value_type);
#define GRN_TABLE_OPEN_OR_CREATE(ctx,name,name_size,path,flags,key_type,value_type,table) \
(((table) = grn_ctx_get((ctx), (name), (name_size))) ||\
((table) = grn_table_create((ctx), (name), (name_size), (path), (flags), (key_type), (value_type))))
/* TODO: int *added -> grn_bool *added */
GRN_API grn_id grn_table_add(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size, int *added);
GRN_API grn_id grn_table_get(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API grn_id grn_table_at(grn_ctx *ctx, grn_obj *table, grn_id id);
GRN_API grn_id grn_table_lcp_search(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API int grn_table_get_key(grn_ctx *ctx, grn_obj *table,
grn_id id, void *keybuf, int buf_size);
GRN_API grn_rc grn_table_delete(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API grn_rc grn_table_delete_by_id(grn_ctx *ctx, grn_obj *table, grn_id id);
GRN_API grn_rc grn_table_update_by_id(grn_ctx *ctx, grn_obj *table, grn_id id,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_table_update(grn_ctx *ctx, grn_obj *table,
const void *src_key, unsigned int src_key_size,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_table_truncate(grn_ctx *ctx, grn_obj *table);
typedef grn_obj grn_table_cursor;
#define GRN_CURSOR_ASCENDING (0x00<<0)
#define GRN_CURSOR_DESCENDING (0x01<<0)
#define GRN_CURSOR_GE (0x00<<1)
#define GRN_CURSOR_GT (0x01<<1)
#define GRN_CURSOR_LE (0x00<<2)
#define GRN_CURSOR_LT (0x01<<2)
#define GRN_CURSOR_BY_KEY (0x00<<3)
#define GRN_CURSOR_BY_ID (0x01<<3)
#define GRN_CURSOR_PREFIX (0x01<<4)
#define GRN_CURSOR_SIZE_BY_BIT (0x01<<5)
#define GRN_CURSOR_RK (0x01<<6)
GRN_API grn_table_cursor *grn_table_cursor_open(grn_ctx *ctx, grn_obj *table,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_rc grn_table_cursor_close(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API grn_id grn_table_cursor_next(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API int grn_table_cursor_get_key(grn_ctx *ctx, grn_table_cursor *tc, void **key);
GRN_API int grn_table_cursor_get_value(grn_ctx *ctx, grn_table_cursor *tc, void **value);
GRN_API grn_rc grn_table_cursor_set_value(grn_ctx *ctx, grn_table_cursor *tc,
const void *value, int flags);
GRN_API grn_rc grn_table_cursor_delete(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API grn_obj *grn_table_cursor_table(grn_ctx *ctx, grn_table_cursor *tc);
typedef struct {
grn_id rid;
grn_id sid;
unsigned int pos;
unsigned int tf;
unsigned int weight;
unsigned int rest;
uint32_t sid;
uint32_t pos;
uint32_t tf;
uint32_t weight;
uint32_t rest;
} grn_posting;
GRN_API grn_obj *grn_index_cursor_open(grn_ctx *ctx, grn_table_cursor *tc, grn_obj *index,
grn_id rid_min, grn_id rid_max, int flags);
GRN_API grn_posting *grn_index_cursor_next(grn_ctx *ctx, grn_obj *ic, grn_id *tid);
#define GRN_TABLE_EACH(ctx,table,head,tail,id,key,key_size,value,block) do {\
(ctx)->errlvl = GRN_LOG_NOTICE;\
(ctx)->rc = GRN_SUCCESS;\
if ((ctx)->seqno & 1) {\
(ctx)->subno++;\
} else {\
(ctx)->seqno++;\
}\
if (table) {\
switch ((table)->header.type) {\
case GRN_TABLE_PAT_KEY :\
GRN_PAT_EACH((ctx), (grn_pat *)(table), (id), (key), (key_size), (value), block);\
break;\
case GRN_TABLE_DAT_KEY :\
GRN_DAT_EACH((ctx), (grn_dat *)(table), (id), (key), (key_size), block);\
break;\
case GRN_TABLE_HASH_KEY :\
GRN_HASH_EACH((ctx), (grn_hash *)(table), (id), (key), (key_size), (value), block);\
break;\
case GRN_TABLE_NO_KEY :\
GRN_ARRAY_EACH((ctx), (grn_array *)(table), (head), (tail), (id), (value), block);\
break;\
}\
}\
if ((ctx)->subno) {\
(ctx)->subno--;\
} else {\
(ctx)->seqno++;\
}\
} while (0)
typedef struct _grn_table_sort_key grn_table_sort_key;
typedef unsigned char grn_table_sort_flags;
#define GRN_TABLE_SORT_ASC (0x00<<0)
#define GRN_TABLE_SORT_DESC (0x01<<0)
struct _grn_table_sort_key {
grn_obj *key;
grn_table_sort_flags flags;
int offset;
};
GRN_API int grn_table_sort(grn_ctx *ctx, grn_obj *table, int offset, int limit,
grn_obj *result, grn_table_sort_key *keys, int n_keys);
typedef struct _grn_table_group_result grn_table_group_result;
typedef unsigned int grn_table_group_flags;
#define GRN_TABLE_GROUP_CALC_COUNT (0x01<<3)
#define GRN_TABLE_GROUP_CALC_MAX (0x01<<4)
#define GRN_TABLE_GROUP_CALC_MIN (0x01<<5)
#define GRN_TABLE_GROUP_CALC_SUM (0x01<<6)
#define GRN_TABLE_GROUP_CALC_AVG (0x01<<7)
typedef enum {
GRN_OP_PUSH = 0,
GRN_OP_POP,
@ -716,53 +608,13 @@ typedef enum {
GRN_OP_TABLE_GROUP,
GRN_OP_JSON_PUT,
GRN_OP_GET_MEMBER,
GRN_OP_REGEXP
GRN_OP_REGEXP,
GRN_OP_FUZZY
} grn_operator;
GRN_API const char *grn_operator_to_string(grn_operator op);
GRN_API grn_bool grn_operator_exec_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_not_equal(grn_ctx *ctx,
grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_less(grn_ctx *ctx, grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_greater(grn_ctx *ctx, grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_less_equal(grn_ctx *ctx,
grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_greater_equal(grn_ctx *ctx,
grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_match(grn_ctx *ctx,
grn_obj *target, grn_obj *sub_text);
GRN_API grn_bool grn_operator_exec_prefix(grn_ctx *ctx,
grn_obj *target, grn_obj *prefix);
GRN_API grn_bool grn_operator_exec_regexp(grn_ctx *ctx,
grn_obj *target, grn_obj *pattern);
struct _grn_table_group_result {
grn_obj *table;
unsigned char key_begin;
unsigned char key_end;
int limit;
grn_table_group_flags flags;
grn_operator op;
unsigned int max_n_subrecs;
grn_obj *calc_target;
};
GRN_API grn_rc grn_table_group(grn_ctx *ctx, grn_obj *table,
grn_table_sort_key *keys, int n_keys,
grn_table_group_result *results, int n_results);
GRN_API grn_rc grn_table_setoperation(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
grn_obj *res, grn_operator op);
GRN_API grn_rc grn_table_difference(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
grn_obj *res1, grn_obj *res2);
GRN_API int grn_table_columns(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size,
grn_obj *res);
GRN_API grn_obj *grn_obj_column(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size);
GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
/*-------------------------------------------------------------
* API for column
*/
@ -788,7 +640,7 @@ GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
GRN_API grn_obj *grn_column_create(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size,
const char *path, grn_obj_flags flags, grn_obj *type);
const char *path, grn_column_flags flags, grn_obj *type);
#define GRN_COLUMN_OPEN_OR_CREATE(ctx,table,name,name_size,path,flags,type,column) \
(((column) = grn_obj_column((ctx), (table), (name), (name_size))) ||\
@ -839,7 +691,9 @@ typedef enum {
/* Just for backward compatibility. We'll remove it at 5.0.0. */
#define GRN_INFO_SUPPORT_LZO GRN_INFO_SUPPORT_LZ4
GRN_INFO_NORMALIZER,
GRN_INFO_TOKEN_FILTERS
GRN_INFO_TOKEN_FILTERS,
GRN_INFO_SUPPORT_ZSTD,
GRN_INFO_SUPPORT_ARROW
} grn_info_type;
GRN_API grn_obj *grn_obj_get_info(grn_ctx *ctx, grn_obj *obj, grn_info_type type, grn_obj *valuebuf);
@ -875,6 +729,10 @@ GRN_API int grn_obj_get_values(grn_ctx *ctx, grn_obj *obj, grn_id offset, void *
GRN_API grn_rc grn_obj_set_value(grn_ctx *ctx, grn_obj *obj, grn_id id, grn_obj *value, int flags);
GRN_API grn_rc grn_obj_remove(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_rc grn_obj_remove_dependent(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_rc grn_obj_remove_force(grn_ctx *ctx,
const char *name,
int name_size);
GRN_API grn_rc grn_obj_rename(grn_ctx *ctx, grn_obj *obj,
const char *name, unsigned int name_size);
GRN_API grn_rc grn_table_rename(grn_ctx *ctx, grn_obj *table,
@ -915,6 +773,27 @@ GRN_API grn_obj *grn_obj_db(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_id grn_obj_id(grn_ctx *ctx, grn_obj *obj);
/* Flags for grn_fuzzy_search_optarg::flags. */
#define GRN_TABLE_FUZZY_SEARCH_WITH_TRANSPOSITION (0x01)
typedef struct _grn_fuzzy_search_optarg grn_fuzzy_search_optarg;
struct _grn_fuzzy_search_optarg {
unsigned int max_distance;
unsigned int max_expansion;
unsigned int prefix_match_size;
int flags;
};
#define GRN_MATCH_INFO_GET_MIN_RECORD_ID (0x01)
typedef struct _grn_match_info grn_match_info;
struct _grn_match_info {
int flags;
grn_id min;
};
typedef struct _grn_search_optarg grn_search_optarg;
struct _grn_search_optarg {
@ -928,6 +807,8 @@ struct _grn_search_optarg {
grn_obj *scorer;
grn_obj *scorer_args_expr;
unsigned int scorer_args_expr_offset;
grn_fuzzy_search_optarg fuzzy;
grn_match_info match_info;
};
GRN_API grn_rc grn_obj_search(grn_ctx *ctx, grn_obj *obj, grn_obj *query,
@ -939,6 +820,16 @@ typedef grn_rc grn_selector_func(grn_ctx *ctx, grn_obj *table, grn_obj *index,
GRN_API grn_rc grn_proc_set_selector(grn_ctx *ctx, grn_obj *proc,
grn_selector_func selector);
GRN_API grn_rc grn_proc_set_selector_operator(grn_ctx *ctx,
grn_obj *proc,
grn_operator selector_op);
GRN_API grn_operator grn_proc_get_selector_operator(grn_ctx *ctx,
grn_obj *proc);
GRN_API grn_rc grn_proc_set_is_stable(grn_ctx *ctx,
grn_obj *proc,
grn_bool is_stable);
GRN_API grn_bool grn_proc_is_stable(grn_ctx *ctx, grn_obj *proc);
/*-------------------------------------------------------------
* grn_vector
@ -953,6 +844,10 @@ GRN_API grn_rc grn_vector_add_element(grn_ctx *ctx, grn_obj *vector,
GRN_API unsigned int grn_vector_get_element(grn_ctx *ctx, grn_obj *vector,
unsigned int offset, const char **str,
unsigned int *weight, grn_id *domain);
GRN_API unsigned int grn_vector_pop_element(grn_ctx *ctx, grn_obj *vector,
const char **str,
unsigned int *weight,
grn_id *domain);
/*-------------------------------------------------------------
* grn_uvector
@ -1008,6 +903,11 @@ GRN_API unsigned int grn_column_find_index_data(grn_ctx *ctx, grn_obj *column,
grn_operator op,
grn_index_datum *index_data,
unsigned int n_index_data);
/* @since 5.1.2. */
GRN_API uint32_t grn_column_get_all_index_data(grn_ctx *ctx,
grn_obj *column,
grn_index_datum *index_data,
uint32_t n_index_data);
GRN_API grn_rc grn_obj_delete_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, grn_bool removep);
GRN_API grn_rc grn_obj_path_by_id(grn_ctx *ctx, grn_obj *db, grn_id id, char *buffer);
@ -1123,6 +1023,7 @@ GRN_API grn_rc grn_snip_get_result(grn_ctx *ctx, grn_obj *snip, const unsigned i
#define GRN_LOG_TITLE (0x01<<1)
#define GRN_LOG_MESSAGE (0x01<<2)
#define GRN_LOG_LOCATION (0x01<<3)
#define GRN_LOG_PID (0x01<<4)
/* Deprecated since 2.1.2. Use grn_logger instead. */
typedef struct _grn_logger_info grn_logger_info;
@ -1163,8 +1064,34 @@ GRN_API grn_log_level grn_logger_get_max_level(grn_ctx *ctx);
# define GRN_ATTRIBUTE_PRINTF(fmt_pos)
#endif /* __GNUC__ */
#if defined(__clang__)
# if __has_attribute(__alloc_size__)
# define HAVE_ALLOC_SIZE_ATTRIBUTE
# endif /* __has_attribute(__alloc_size__) */
#elif defined(__GNUC__) && \
((__GNUC__ >= 5) || (__GNUC__ > 4 && __GNUC_MINOR__ >= 3))
# define HAVE_ALLOC_SIZE_ATTRIBUTE
#endif /* __clang__ */
#ifdef HAVE_ALLOC_SIZE_ATTRIBUTE
# define GRN_ATTRIBUTE_ALLOC_SIZE(size) \
__attribute__ ((alloc_size(size)))
# define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size) \
__attribute__ ((alloc_size(n, size)))
#else
# define GRN_ATTRIBUTE_ALLOC_SIZE(size)
# define GRN_ATTRIBUTE_ALLOC_SIZE_N(n, size)
#endif /* HAVE_ALLOC_SIZE_ATTRIBUTE */
GRN_API void grn_logger_put(grn_ctx *ctx, grn_log_level level,
const char *file, int line, const char *func, const char *fmt, ...) GRN_ATTRIBUTE_PRINTF(6);
GRN_API void grn_logger_putv(grn_ctx *ctx,
grn_log_level level,
const char *file,
int line,
const char *func,
const char *fmt,
va_list ap);
GRN_API void grn_logger_reopen(grn_ctx *ctx);
GRN_API grn_bool grn_logger_pass(grn_ctx *ctx, grn_log_level level);
@ -1175,6 +1102,8 @@ GRN_API grn_bool grn_logger_pass(grn_ctx *ctx, grn_log_level level);
GRN_API void grn_default_logger_set_max_level(grn_log_level level);
GRN_API grn_log_level grn_default_logger_get_max_level(void);
GRN_API void grn_default_logger_set_flags(int flags);
GRN_API int grn_default_logger_get_flags(void);
GRN_API void grn_default_logger_set_path(const char *path);
GRN_API const char *grn_default_logger_get_path(void);
GRN_API void grn_default_logger_set_rotate_threshold_size(off_t threshold);
@ -1198,7 +1127,15 @@ struct _grn_query_logger {
void (*fin)(grn_ctx *ctx, void *user_data);
};
GRN_API grn_bool grn_query_log_flags_parse(const char *string,
int string_size,
unsigned int *flags);
GRN_API grn_rc grn_query_logger_set(grn_ctx *ctx, const grn_query_logger *logger);
GRN_API void grn_query_logger_set_flags(grn_ctx *ctx, unsigned int flags);
GRN_API void grn_query_logger_add_flags(grn_ctx *ctx, unsigned int flags);
GRN_API void grn_query_logger_remove_flags(grn_ctx *ctx, unsigned int flags);
GRN_API unsigned int grn_query_logger_get_flags(grn_ctx *ctx);
GRN_API void grn_query_logger_put(grn_ctx *ctx, unsigned int flag,
const char *mark,
@ -1246,6 +1183,13 @@ GRN_API off_t grn_default_query_logger_get_rotate_threshold_size(void);
}\
}\
} while (0)
#define GRN_BULK_INCR_LEN(bulk,len) do {\
if (GRN_BULK_OUTP(bulk)) {\
(bulk)->u.b.curr += (len);\
} else {\
(bulk)->header.flags += (grn_obj_flags)(len);\
}\
} while (0)
#define GRN_BULK_WSIZE(bulk) \
(GRN_BULK_OUTP(bulk)\
? ((bulk)->u.b.tail - (bulk)->u.b.head)\
@ -1356,6 +1300,10 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
#define GRN_TEXT_VALUE(obj) GRN_BULK_HEAD(obj)
#define GRN_TEXT_LEN(obj) GRN_BULK_VSIZE(obj)
#define GRN_TEXT_EQUAL_CSTRING(bulk, string)\
(GRN_TEXT_LEN(bulk) == strlen(string) &&\
memcmp(GRN_TEXT_VALUE(bulk), string, GRN_TEXT_LEN(bulk)) == 0)
#define GRN_BOOL_INIT(obj,flags) \
GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_BOOL)
#define GRN_INT8_INIT(obj,flags) \
@ -1381,7 +1329,8 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
#define GRN_RECORD_INIT GRN_VALUE_FIX_SIZE_INIT
#define GRN_PTR_INIT(obj,flags,domain)\
GRN_OBJ_INIT((obj), ((flags) & GRN_OBJ_VECTOR) ? GRN_PVECTOR : GRN_PTR,\
((flags) & GRN_OBJ_DO_SHALLOW_COPY), (domain))
((flags) & (GRN_OBJ_DO_SHALLOW_COPY | GRN_OBJ_OWN)),\
(domain))
#define GRN_TOKYO_GEO_POINT_INIT(obj,flags) \
GRN_VALUE_FIX_SIZE_INIT(obj, flags, GRN_DB_TOKYO_GEO_POINT)
#define GRN_WGS84_GEO_POINT_INIT(obj,flags) \
@ -1512,17 +1461,6 @@ GRN_API void grn_ctx_recv_handler_set(grn_ctx *,
(offset) * sizeof(grn_obj *), sizeof(grn_obj *));\
} while (0)
#define GRN_TIME_USEC_PER_SEC 1000000
#define GRN_TIME_PACK(sec, usec) ((long long int)(sec) * GRN_TIME_USEC_PER_SEC + (usec))
#define GRN_TIME_UNPACK(time_value, sec, usec) do {\
sec = (time_value) / GRN_TIME_USEC_PER_SEC;\
usec = (time_value) % GRN_TIME_USEC_PER_SEC;\
} while (0)
GRN_API void grn_time_now(grn_ctx *ctx, grn_obj *obj);
#define GRN_TIME_NOW(ctx,obj) (grn_time_now((ctx), (obj)))
#define GRN_BOOL_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
#define GRN_INT8_VALUE(obj) (*((signed char *)GRN_BULK_HEAD(obj)))
#define GRN_UINT8_VALUE(obj) (*((unsigned char *)GRN_BULK_HEAD(obj)))
@ -1601,6 +1539,28 @@ GRN_API void grn_time_now(grn_ctx *ctx, grn_obj *obj);
grn_bulk_write((ctx), (obj), (char *)&_val, sizeof(grn_obj *));\
} while (0)
#define GRN_BULK_POP(obj, value, type, default) do {\
if (GRN_BULK_VSIZE(obj) >= sizeof(type)) {\
GRN_BULK_INCR_LEN((obj), -(sizeof(type)));\
value = *(type *)(GRN_BULK_CURR(obj));\
} else {\
value = default;\
}\
} while (0)
#define GRN_BOOL_POP(obj, value) GRN_BULK_POP(obj, value, unsigned char, 0)
#define GRN_INT8_POP(obj, value) GRN_BULK_POP(obj, value, int8_t, 0)
#define GRN_UINT8_POP(obj, value) GRN_BULK_POP(obj, value, uint8_t, 0)
#define GRN_INT16_POP(obj, value) GRN_BULK_POP(obj, value, int16_t, 0)
#define GRN_UINT16_POP(obj, value) GRN_BULK_POP(obj, value, uint16_t, 0)
#define GRN_INT32_POP(obj, value) GRN_BULK_POP(obj, value, int32_t, 0)
#define GRN_UINT32_POP(obj, value) GRN_BULK_POP(obj, value, uint32_t, 0)
#define GRN_INT64_POP(obj, value) GRN_BULK_POP(obj, value, int64_t, 0)
#define GRN_UINT64_POP(obj, value) GRN_BULK_POP(obj, value, uint64_t, 0)
#define GRN_FLOAT_POP(obj, value) GRN_BULK_POP(obj, value, double, 0.0)
#define GRN_TIME_POP GRN_INT64_POP
#define GRN_RECORD_POP(obj, value) GRN_BULK_POP(obj, value, grn_id, GRN_ID_NIL)
#define GRN_PTR_POP(obj, value) GRN_BULK_POP(obj, value, grn_obj *, NULL)
/* grn_str: deprecated. use grn_string instead. */
typedef struct {
@ -1680,38 +1640,9 @@ GRN_API int grn_charlen(grn_ctx *ctx, const char *str, const char *end);
GRN_API grn_rc grn_ctx_push(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_obj *grn_ctx_pop(grn_ctx *ctx);
GRN_API grn_obj *grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
grn_obj *res, grn_operator op);
GRN_API int grn_obj_columns(grn_ctx *ctx, grn_obj *table,
const char *str, unsigned int str_size, grn_obj *res);
GRN_API grn_table_sort_key *grn_table_sort_key_from_str(grn_ctx *ctx,
const char *str, unsigned int str_size,
grn_obj *table, unsigned int *nkeys);
GRN_API grn_rc grn_table_sort_key_close(grn_ctx *ctx,
grn_table_sort_key *keys, unsigned int nkeys);
GRN_API grn_bool grn_table_is_grouped(grn_ctx *ctx, grn_obj *table);
GRN_API unsigned int grn_table_max_n_subrecs(grn_ctx *ctx, grn_obj *table);
GRN_API grn_obj *grn_table_create_for_group(grn_ctx *ctx,
const char *name,
unsigned int name_size,
const char *path,
grn_obj *group_key,
grn_obj *value_type,
unsigned int max_n_subrecs);
GRN_API unsigned int grn_table_get_subrecs(grn_ctx *ctx, grn_obj *table,
grn_id id, grn_id *subrecbuf,
int *scorebuf, int buf_size);
GRN_API grn_obj *grn_table_tokenize(grn_ctx *ctx, grn_obj *table,
const char *str, unsigned int str_len,
grn_obj *buf, grn_bool addp);
GRN_API grn_rc grn_load(grn_ctx *ctx, grn_content_type input_type,
const char *table, unsigned int table_len,
const char *columns, unsigned int columns_len,
@ -1744,28 +1675,6 @@ GRN_API grn_rc grn_set_segv_handler(void);
GRN_API grn_rc grn_set_int_handler(void);
GRN_API grn_rc grn_set_term_handler(void);
/* hash */
typedef struct _grn_hash grn_hash;
typedef struct _grn_hash_cursor grn_hash_cursor;
GRN_API grn_hash *grn_hash_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_hash *grn_hash_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_hash_close(grn_ctx *ctx, grn_hash *hash);
GRN_API grn_id grn_hash_add(grn_ctx *ctx, grn_hash *hash, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API grn_id grn_hash_get(grn_ctx *ctx, grn_hash *hash, const void *key,
unsigned int key_size, void **value);
GRN_API int grn_hash_get_key(grn_ctx *ctx, grn_hash *hash, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_hash_get_key2(grn_ctx *ctx, grn_hash *hash, grn_id id, grn_obj *bulk);
GRN_API int grn_hash_get_value(grn_ctx *ctx, grn_hash *hash, grn_id id, void *valuebuf);
GRN_API grn_rc grn_hash_set_value(grn_ctx *ctx, grn_hash *hash, grn_id id,
const void *value, int flags);
typedef struct _grn_table_delete_optarg grn_table_delete_optarg;
@ -1775,253 +1684,17 @@ struct _grn_table_delete_optarg {
void *func_arg;
};
GRN_API grn_rc grn_hash_delete_by_id(grn_ctx *ctx, grn_hash *hash, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_hash_delete(grn_ctx *ctx, grn_hash *hash,
const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API grn_hash_cursor *grn_hash_cursor_open(grn_ctx *ctx, grn_hash *hash,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_hash_cursor_next(grn_ctx *ctx, grn_hash_cursor *c);
GRN_API void grn_hash_cursor_close(grn_ctx *ctx, grn_hash_cursor *c);
GRN_API int grn_hash_cursor_get_key(grn_ctx *ctx, grn_hash_cursor *c, void **key);
GRN_API int grn_hash_cursor_get_value(grn_ctx *ctx, grn_hash_cursor *c, void **value);
GRN_API grn_rc grn_hash_cursor_set_value(grn_ctx *ctx, grn_hash_cursor *c,
const void *value, int flags);
GRN_API int grn_hash_cursor_get_key_value(grn_ctx *ctx, grn_hash_cursor *c,
void **key, unsigned int *key_size, void **value);
GRN_API grn_rc grn_hash_cursor_delete(grn_ctx *ctx, grn_hash_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_HASH_EACH(ctx,hash,id,key,key_size,value,block) do {\
grn_hash_cursor *_sc = grn_hash_cursor_open(ctx, hash, NULL, 0, NULL, 0, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_hash_cursor_next(ctx, _sc))) {\
grn_hash_cursor_get_key_value(ctx, _sc, (void **)(key),\
(key_size), (void **)(value));\
block\
}\
grn_hash_cursor_close(ctx, _sc);\
}\
} while (0)
/* array */
typedef struct _grn_array grn_array;
typedef struct _grn_array_cursor grn_array_cursor;
GRN_API grn_array *grn_array_create(grn_ctx *ctx, const char *path,
unsigned int value_size, unsigned int flags);
GRN_API grn_array *grn_array_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_array_close(grn_ctx *ctx, grn_array *array);
GRN_API grn_id grn_array_add(grn_ctx *ctx, grn_array *array, void **value);
GRN_API grn_id grn_array_push(grn_ctx *ctx, grn_array *array,
void (*func)(grn_ctx *ctx, grn_array *array,
grn_id id, void *func_arg),
void *func_arg);
GRN_API grn_id grn_array_pull(grn_ctx *ctx, grn_array *array, grn_bool blockp,
void (*func)(grn_ctx *ctx, grn_array *array,
grn_id id, void *func_arg),
void *func_arg);
GRN_API void grn_array_unblock(grn_ctx *ctx, grn_array *array);
GRN_API int grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id, void *valuebuf);
GRN_API grn_rc grn_array_set_value(grn_ctx *ctx, grn_array *array, grn_id id,
const void *value, int flags);
GRN_API grn_array_cursor *grn_array_cursor_open(grn_ctx *ctx, grn_array *array,
grn_id min, grn_id max,
int offset, int limit, int flags);
GRN_API grn_id grn_array_cursor_next(grn_ctx *ctx, grn_array_cursor *cursor);
GRN_API int grn_array_cursor_get_value(grn_ctx *ctx, grn_array_cursor *cursor, void **value);
GRN_API grn_rc grn_array_cursor_set_value(grn_ctx *ctx, grn_array_cursor *cursor,
const void *value, int flags);
GRN_API grn_rc grn_array_cursor_delete(grn_ctx *ctx, grn_array_cursor *cursor,
grn_table_delete_optarg *optarg);
GRN_API void grn_array_cursor_close(grn_ctx *ctx, grn_array_cursor *cursor);
GRN_API grn_rc grn_array_delete_by_id(grn_ctx *ctx, grn_array *array, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_id grn_array_next(grn_ctx *ctx, grn_array *array, grn_id id);
GRN_API void *_grn_array_get_value(grn_ctx *ctx, grn_array *array, grn_id id);
#define GRN_ARRAY_EACH(ctx,array,head,tail,id,value,block) do {\
grn_array_cursor *_sc = grn_array_cursor_open(ctx, array, head, tail, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_array_cursor_next(ctx, _sc))) {\
grn_array_cursor_get_value(ctx, _sc, (void **)(value));\
block\
}\
grn_array_cursor_close(ctx, _sc); \
}\
} while (0)
/* pat */
typedef struct _grn_pat grn_pat;
typedef struct _grn_pat_cursor grn_pat_cursor;
GRN_API grn_pat *grn_pat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_pat *grn_pat_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_pat_close(grn_ctx *ctx, grn_pat *pat);
GRN_API grn_rc grn_pat_remove(grn_ctx *ctx, const char *path);
GRN_API grn_id grn_pat_get(grn_ctx *ctx, grn_pat *pat, const void *key,
unsigned int key_size, void **value);
GRN_API grn_id grn_pat_add(grn_ctx *ctx, grn_pat *pat, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API int grn_pat_get_key(grn_ctx *ctx, grn_pat *pat, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_pat_get_key2(grn_ctx *ctx, grn_pat *pat, grn_id id, grn_obj *bulk);
GRN_API int grn_pat_get_value(grn_ctx *ctx, grn_pat *pat, grn_id id, void *valuebuf);
GRN_API grn_rc grn_pat_set_value(grn_ctx *ctx, grn_pat *pat, grn_id id,
const void *value, int flags);
GRN_API grn_rc grn_pat_delete_by_id(grn_ctx *ctx, grn_pat *pat, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_pat_delete(grn_ctx *ctx, grn_pat *pat, const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API int grn_pat_delete_with_sis(grn_ctx *ctx, grn_pat *pat, grn_id id,
grn_table_delete_optarg *optarg);
typedef struct _grn_table_scan_hit grn_pat_scan_hit;
typedef struct _grn_table_scan_hit grn_dat_scan_hit;
struct _grn_table_scan_hit {
grn_id id;
unsigned int offset;
unsigned int length;
};
GRN_API int grn_pat_scan(grn_ctx *ctx, grn_pat *pat, const char *str, unsigned int str_len,
grn_pat_scan_hit *sh, unsigned int sh_size, const char **rest);
GRN_API grn_rc grn_pat_prefix_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size, grn_hash *h);
GRN_API grn_rc grn_pat_suffix_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size, grn_hash *h);
GRN_API grn_id grn_pat_lcp_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size);
GRN_API unsigned int grn_pat_size(grn_ctx *ctx, grn_pat *pat);
GRN_API grn_pat_cursor *grn_pat_cursor_open(grn_ctx *ctx, grn_pat *pat,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_pat_cursor_next(grn_ctx *ctx, grn_pat_cursor *c);
GRN_API void grn_pat_cursor_close(grn_ctx *ctx, grn_pat_cursor *c);
GRN_API int grn_pat_cursor_get_key(grn_ctx *ctx, grn_pat_cursor *c, void **key);
GRN_API int grn_pat_cursor_get_value(grn_ctx *ctx, grn_pat_cursor *c, void **value);
GRN_API int grn_pat_cursor_get_key_value(grn_ctx *ctx, grn_pat_cursor *c,
void **key, unsigned int *key_size, void **value);
GRN_API grn_rc grn_pat_cursor_set_value(grn_ctx *ctx, grn_pat_cursor *c,
const void *value, int flags);
GRN_API grn_rc grn_pat_cursor_delete(grn_ctx *ctx, grn_pat_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_PAT_EACH(ctx,pat,id,key,key_size,value,block) do { \
grn_pat_cursor *_sc = grn_pat_cursor_open(ctx, pat, NULL, 0, NULL, 0, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_pat_cursor_next(ctx, _sc))) {\
grn_pat_cursor_get_key_value(ctx, _sc, (void **)(key),\
(key_size), (void **)(value));\
block\
}\
grn_pat_cursor_close(ctx, _sc);\
}\
} while (0)
/* dat */
typedef struct _grn_dat grn_dat;
typedef struct _grn_dat_cursor grn_dat_cursor;
GRN_API int grn_dat_scan(grn_ctx *ctx, grn_dat *dat, const char *str,
unsigned int str_size, grn_dat_scan_hit *scan_hits,
unsigned int max_num_scan_hits, const char **str_rest);
GRN_API grn_id grn_dat_lcp_search(grn_ctx *ctx, grn_dat *dat,
const void *key, unsigned int key_size);
GRN_API grn_dat *grn_dat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_dat *grn_dat_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_dat_close(grn_ctx *ctx, grn_dat *dat);
GRN_API grn_rc grn_dat_remove(grn_ctx *ctx, const char *path);
GRN_API grn_id grn_dat_get(grn_ctx *ctx, grn_dat *dat, const void *key,
unsigned int key_size, void **value);
GRN_API grn_id grn_dat_add(grn_ctx *ctx, grn_dat *dat, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API int grn_dat_get_key(grn_ctx *ctx, grn_dat *dat, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_dat_get_key2(grn_ctx *ctx, grn_dat *dat, grn_id id, grn_obj *bulk);
GRN_API grn_rc grn_dat_delete_by_id(grn_ctx *ctx, grn_dat *dat, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_dat_delete(grn_ctx *ctx, grn_dat *dat, const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_dat_update_by_id(grn_ctx *ctx, grn_dat *dat, grn_id src_key_id,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_dat_update(grn_ctx *ctx, grn_dat *dat,
const void *src_key, unsigned int src_key_size,
const void *dest_key, unsigned int dest_key_size);
GRN_API unsigned int grn_dat_size(grn_ctx *ctx, grn_dat *dat);
GRN_API grn_dat_cursor *grn_dat_cursor_open(grn_ctx *ctx, grn_dat *dat,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_dat_cursor_next(grn_ctx *ctx, grn_dat_cursor *c);
GRN_API void grn_dat_cursor_close(grn_ctx *ctx, grn_dat_cursor *c);
GRN_API int grn_dat_cursor_get_key(grn_ctx *ctx, grn_dat_cursor *c, const void **key);
GRN_API grn_rc grn_dat_cursor_delete(grn_ctx *ctx, grn_dat_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_DAT_EACH(ctx,dat,id,key,key_size,block) do {\
grn_dat_cursor *_sc = grn_dat_cursor_open(ctx, dat, NULL, 0, NULL, 0, 0, -1, 0);\
if (_sc) {\
grn_id id;\
unsigned int *_ks = (key_size);\
if (_ks) {\
while ((id = grn_dat_cursor_next(ctx, _sc))) {\
int _ks_raw = grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
*(_ks) = (unsigned int)_ks_raw;\
block\
}\
} else {\
while ((id = grn_dat_cursor_next(ctx, _sc))) {\
grn_dat_cursor_get_key(ctx, _sc, (const void **)(key));\
block\
}\
}\
grn_dat_cursor_close(ctx, _sc);\
}\
} while (0)
typedef struct {
int64_t tv_sec;
int32_t tv_nsec;
} grn_timeval;
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_GROONGA_H */

104
storage/mroonga/vendor/groonga/include/groonga/hash.h vendored Normal file
View file

@ -0,0 +1,104 @@
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#define GRN_HASH_TINY (0x01<<6)
typedef struct _grn_hash grn_hash;
typedef struct _grn_hash_cursor grn_hash_cursor;
GRN_API grn_hash *grn_hash_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_hash *grn_hash_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_hash_close(grn_ctx *ctx, grn_hash *hash);
GRN_API grn_id grn_hash_add(grn_ctx *ctx, grn_hash *hash, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API grn_id grn_hash_get(grn_ctx *ctx, grn_hash *hash, const void *key,
unsigned int key_size, void **value);
GRN_API int grn_hash_get_key(grn_ctx *ctx, grn_hash *hash, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_hash_get_key2(grn_ctx *ctx, grn_hash *hash, grn_id id, grn_obj *bulk);
GRN_API int grn_hash_get_value(grn_ctx *ctx, grn_hash *hash, grn_id id, void *valuebuf);
GRN_API grn_rc grn_hash_set_value(grn_ctx *ctx, grn_hash *hash, grn_id id,
const void *value, int flags);
GRN_API grn_rc grn_hash_delete_by_id(grn_ctx *ctx, grn_hash *hash, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_hash_delete(grn_ctx *ctx, grn_hash *hash,
const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API uint32_t grn_hash_size(grn_ctx *ctx, grn_hash *hash);
GRN_API grn_hash_cursor *grn_hash_cursor_open(grn_ctx *ctx, grn_hash *hash,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_hash_cursor_next(grn_ctx *ctx, grn_hash_cursor *c);
GRN_API void grn_hash_cursor_close(grn_ctx *ctx, grn_hash_cursor *c);
GRN_API int grn_hash_cursor_get_key(grn_ctx *ctx, grn_hash_cursor *c, void **key);
GRN_API int grn_hash_cursor_get_value(grn_ctx *ctx, grn_hash_cursor *c, void **value);
GRN_API grn_rc grn_hash_cursor_set_value(grn_ctx *ctx, grn_hash_cursor *c,
const void *value, int flags);
GRN_API int grn_hash_cursor_get_key_value(grn_ctx *ctx, grn_hash_cursor *c,
void **key, unsigned int *key_size, void **value);
GRN_API grn_rc grn_hash_cursor_delete(grn_ctx *ctx, grn_hash_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_HASH_EACH(ctx,hash,id,key,key_size,value,block) do {\
grn_hash_cursor *_sc = grn_hash_cursor_open(ctx, hash, NULL, 0, NULL, 0, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_hash_cursor_next(ctx, _sc))) {\
grn_hash_cursor_get_key_value(ctx, _sc, (void **)(key),\
(key_size), (void **)(value));\
block\
}\
grn_hash_cursor_close(ctx, _sc);\
}\
} while (0)
#define GRN_HASH_EACH_BEGIN(ctx, hash, cursor, id) do {\
grn_hash_cursor *cursor;\
cursor = grn_hash_cursor_open((ctx), (hash),\
NULL, 0, NULL, 0,\
0, -1, GRN_CURSOR_BY_ID);\
if (cursor) {\
grn_id id;\
while ((id = grn_hash_cursor_next((ctx), cursor)) != GRN_ID_NIL) {
#define GRN_HASH_EACH_END(ctx, cursor)\
}\
grn_hash_cursor_close((ctx), cursor);\
}\
} while(0)
#ifdef __cplusplus
}
#endif

31
storage/mroonga/vendor/groonga/include/groonga/id.h vendored Normal file
View file

@ -0,0 +1,31 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API grn_bool grn_id_is_builtin(grn_ctx *ctx, grn_id id);
GRN_API grn_bool grn_id_is_builtin_type(grn_ctx *ctx, grn_id id);
#ifdef __cplusplus
}
#endif

42
storage/mroonga/vendor/groonga/include/groonga/ii.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2009-2014 Brazil
Copyright(C) 2009-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_II_H
#define GROONGA_II_H
#pragma once
#ifdef __cplusplus
extern "C" {
@ -27,14 +27,19 @@ extern "C" {
typedef struct _grn_ii grn_ii;
typedef struct _grn_ii_buffer grn_ii_buffer;
GRN_API unsigned int grn_ii_estimate_size(grn_ctx *ctx, grn_ii *ii, grn_id tid);
GRN_API unsigned int grn_ii_estimate_size_for_query(grn_ctx *ctx, grn_ii *ii,
const char *query,
unsigned int query_len,
grn_search_optarg *optarg);
GRN_API unsigned int grn_ii_estimate_size_for_lexicon_cursor(grn_ctx *ctx,
grn_ii *ii,
grn_table_cursor *lexicon_cursor);
GRN_API uint32_t grn_ii_get_n_elements(grn_ctx *ctx, grn_ii *ii);
GRN_API void grn_ii_cursor_set_min_enable_set(grn_bool enable);
GRN_API grn_bool grn_ii_cursor_set_min_enable_get(void);
GRN_API uint32_t grn_ii_estimate_size(grn_ctx *ctx, grn_ii *ii, grn_id tid);
GRN_API uint32_t grn_ii_estimate_size_for_query(grn_ctx *ctx, grn_ii *ii,
const char *query,
unsigned int query_len,
grn_search_optarg *optarg);
GRN_API uint32_t grn_ii_estimate_size_for_lexicon_cursor(grn_ctx *ctx,
grn_ii *ii,
grn_table_cursor *lexicon_cursor);
GRN_API grn_ii_buffer *grn_ii_buffer_open(grn_ctx *ctx, grn_ii *ii,
long long unsigned int update_buffer_size);
@ -46,8 +51,19 @@ GRN_API grn_rc grn_ii_buffer_append(grn_ctx *ctx,
GRN_API grn_rc grn_ii_buffer_commit(grn_ctx *ctx, grn_ii_buffer *ii_buffer);
GRN_API grn_rc grn_ii_buffer_close(grn_ctx *ctx, grn_ii_buffer *ii_buffer);
GRN_API grn_rc grn_ii_posting_add(grn_ctx *ctx, grn_posting *pos,
grn_hash *s, grn_operator op);
GRN_API void grn_ii_resolve_sel_and(grn_ctx *ctx, grn_hash *s, grn_operator op);
/* Experimental */
typedef struct _grn_ii_cursor grn_ii_cursor;
GRN_API grn_ii_cursor *grn_ii_cursor_open(grn_ctx *ctx, grn_ii *ii, grn_id tid,
grn_id min, grn_id max, int nelements, int flags);
GRN_API grn_posting *grn_ii_cursor_next(grn_ctx *ctx, grn_ii_cursor *c);
GRN_API grn_posting *grn_ii_cursor_next_pos(grn_ctx *ctx, grn_ii_cursor *c);
GRN_API grn_rc grn_ii_cursor_close(grn_ctx *ctx, grn_ii_cursor *c);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_II_H */

11
storage/mroonga/vendor/groonga/include/groonga/nfkc.h vendored
View file

@ -1,5 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/* Copyright(C) 2009 Brazil
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -14,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_NFKC_H
#define GROONGA_NFKC_H
#pragma once
#include <groonga.h>
@ -23,10 +24,8 @@
extern "C" {
#endif
GRN_API grn_char_type grn_nfkc_char_type(const unsigned char *str);
GRN_API grn_char_type grn_nfkc_char_type(const unsigned char *utf8);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_NFKC_H */

8
storage/mroonga/vendor/groonga/include/groonga/normalizer.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2012 Brazil
Copyright(C) 2012-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_NORMALIER_H
#define GROONGA_NORMALIER_H
#pragma once
#include <stddef.h>
@ -51,5 +51,3 @@ GRN_PLUGIN_EXPORT grn_rc grn_normalizer_register(grn_ctx *ctx,
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* GROONGA_NORMALIER_H */

54
storage/mroonga/vendor/groonga/include/groonga/obj.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2015 Brazil
Copyright(C) 2015-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -16,22 +16,66 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_OBJ_H
#define GROONGA_OBJ_H
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
/* Just for backward compatibility. Use grn_obj_is_true() instead. */
#define GRN_OBJ_IS_TRUE(ctx, obj, result) do { \
result = grn_obj_is_true(ctx, obj); \
} while (0)
GRN_API grn_bool grn_obj_is_true(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_builtin(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_bulk(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_text_family_bulk(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_table(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_column(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_scalar_column(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_vector_column(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_weight_vector_column(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_reference_column(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_data_column(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_index_column(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_accessor(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_key_accessor(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_type(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_text_family_type(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_tokenizer_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_function_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_selector_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_selector_only_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_normalizer_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_token_filter_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_scorer_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_window_function_proc(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_expr(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_rc grn_obj_cast(grn_ctx *ctx,
grn_obj *src,
grn_obj *dest,
grn_bool add_record_if_not_exist);
GRN_API grn_rc grn_obj_reindex(grn_ctx *ctx, grn_obj *obj);
GRN_API void grn_obj_touch(grn_ctx *ctx, grn_obj *obj, grn_timeval *tv);
GRN_API uint32_t grn_obj_get_last_modified(grn_ctx *ctx, grn_obj *obj);
GRN_API grn_bool grn_obj_is_dirty(grn_ctx *ctx, grn_obj *obj);
GRN_API const char *grn_obj_type_to_string(uint8_t type);
GRN_API grn_bool grn_obj_name_is_column(grn_ctx *ctx,
const char *name,
int name_len);
GRN_API grn_bool grn_obj_is_corrupt(grn_ctx *ctx, grn_obj *obj);
GRN_API size_t grn_obj_get_disk_usage(grn_ctx *ctx, grn_obj *obj);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_OBJ_H */

49
storage/mroonga/vendor/groonga/include/groonga/operator.h vendored Normal file
View file

@ -0,0 +1,49 @@
/*
Copyright(C) 2009-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef grn_bool grn_operator_exec_func(grn_ctx *ctx,
grn_obj *x,
grn_obj *y);
GRN_API const char *grn_operator_to_string(grn_operator op);
GRN_API grn_operator_exec_func *grn_operator_to_exec_func(grn_operator op);
GRN_API grn_bool grn_operator_exec_equal(grn_ctx *ctx, grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_not_equal(grn_ctx *ctx,
grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_less(grn_ctx *ctx, grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_greater(grn_ctx *ctx, grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_less_equal(grn_ctx *ctx,
grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_greater_equal(grn_ctx *ctx,
grn_obj *x, grn_obj *y);
GRN_API grn_bool grn_operator_exec_match(grn_ctx *ctx,
grn_obj *target, grn_obj *sub_text);
GRN_API grn_bool grn_operator_exec_prefix(grn_ctx *ctx,
grn_obj *target, grn_obj *prefix);
GRN_API grn_bool grn_operator_exec_regexp(grn_ctx *ctx,
grn_obj *target, grn_obj *pattern);
#ifdef __cplusplus
}
#endif

30
storage/mroonga/vendor/groonga/include/groonga/output.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2009-2015 Brazil
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_OUTPUT_H
#define GROONGA_OUTPUT_H
#pragma once
#ifdef __cplusplus
extern "C" {
@ -58,7 +58,13 @@ struct _grn_obj_format {
#define GRN_OBJ_FORMAT_FIN(ctx,format) do {\
int ncolumns = GRN_BULK_VSIZE(&(format)->columns) / sizeof(grn_obj *);\
grn_obj **columns = (grn_obj **)GRN_BULK_HEAD(&(format)->columns);\
while (ncolumns--) { grn_obj_unlink((ctx), *columns++); }\
while (ncolumns--) {\
grn_obj *column = *columns;\
columns++;\
if (grn_obj_is_accessor((ctx), column)) {\
grn_obj_close((ctx), column);\
}\
}\
GRN_OBJ_FIN((ctx), &(format)->columns);\
if ((format)->expression) { GRN_OBJ_FIN((ctx), (format)->expression); } \
} while (0)
@ -76,8 +82,10 @@ GRN_API void grn_ctx_output_array_close(grn_ctx *ctx);
GRN_API void grn_ctx_output_map_open(grn_ctx *ctx,
const char *name, int nelements);
GRN_API void grn_ctx_output_map_close(grn_ctx *ctx);
GRN_API void grn_ctx_output_null(grn_ctx *ctx);
GRN_API void grn_ctx_output_int32(grn_ctx *ctx, int value);
GRN_API void grn_ctx_output_int64(grn_ctx *ctx, long long int value);
GRN_API void grn_ctx_output_int64(grn_ctx *ctx, int64_t value);
GRN_API void grn_ctx_output_uint64(grn_ctx *ctx, uint64_t value);
GRN_API void grn_ctx_output_float(grn_ctx *ctx, double value);
GRN_API void grn_ctx_output_cstr(grn_ctx *ctx, const char *value);
GRN_API void grn_ctx_output_str(grn_ctx *ctx,
@ -85,6 +93,16 @@ GRN_API void grn_ctx_output_str(grn_ctx *ctx,
GRN_API void grn_ctx_output_bool(grn_ctx *ctx, grn_bool value);
GRN_API void grn_ctx_output_obj(grn_ctx *ctx,
grn_obj *value, grn_obj_format *format);
GRN_API void grn_ctx_output_result_set_open(grn_ctx *ctx,
grn_obj *result_set,
grn_obj_format *format,
uint32_t n_additional_elements);
GRN_API void grn_ctx_output_result_set_close(grn_ctx *ctx,
grn_obj *result_set,
grn_obj_format *format);
GRN_API void grn_ctx_output_result_set(grn_ctx *ctx,
grn_obj *result_set,
grn_obj_format *format);
GRN_API void grn_ctx_output_table_columns(grn_ctx *ctx,
grn_obj *table,
grn_obj_format *format);
@ -104,5 +122,3 @@ GRN_API grn_rc grn_text_otoj(grn_ctx *ctx, grn_obj *bulk, grn_obj *obj,
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_OUTPUT_H */

102
storage/mroonga/vendor/groonga/include/groonga/pat.h vendored Normal file
View file

@ -0,0 +1,102 @@
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include "hash.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _grn_pat grn_pat;
typedef struct _grn_pat_cursor grn_pat_cursor;
typedef struct _grn_table_scan_hit grn_pat_scan_hit;
GRN_API grn_pat *grn_pat_create(grn_ctx *ctx, const char *path, unsigned int key_size,
unsigned int value_size, unsigned int flags);
GRN_API grn_pat *grn_pat_open(grn_ctx *ctx, const char *path);
GRN_API grn_rc grn_pat_close(grn_ctx *ctx, grn_pat *pat);
GRN_API grn_rc grn_pat_remove(grn_ctx *ctx, const char *path);
GRN_API grn_id grn_pat_get(grn_ctx *ctx, grn_pat *pat, const void *key,
unsigned int key_size, void **value);
GRN_API grn_id grn_pat_add(grn_ctx *ctx, grn_pat *pat, const void *key,
unsigned int key_size, void **value, int *added);
GRN_API int grn_pat_get_key(grn_ctx *ctx, grn_pat *pat, grn_id id, void *keybuf, int bufsize);
GRN_API int grn_pat_get_key2(grn_ctx *ctx, grn_pat *pat, grn_id id, grn_obj *bulk);
GRN_API int grn_pat_get_value(grn_ctx *ctx, grn_pat *pat, grn_id id, void *valuebuf);
GRN_API grn_rc grn_pat_set_value(grn_ctx *ctx, grn_pat *pat, grn_id id,
const void *value, int flags);
GRN_API grn_rc grn_pat_delete_by_id(grn_ctx *ctx, grn_pat *pat, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API grn_rc grn_pat_delete(grn_ctx *ctx, grn_pat *pat, const void *key, unsigned int key_size,
grn_table_delete_optarg *optarg);
GRN_API int grn_pat_delete_with_sis(grn_ctx *ctx, grn_pat *pat, grn_id id,
grn_table_delete_optarg *optarg);
GRN_API int grn_pat_scan(grn_ctx *ctx, grn_pat *pat, const char *str, unsigned int str_len,
grn_pat_scan_hit *sh, unsigned int sh_size, const char **rest);
GRN_API grn_rc grn_pat_prefix_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size, grn_hash *h);
GRN_API grn_rc grn_pat_suffix_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size, grn_hash *h);
GRN_API grn_id grn_pat_lcp_search(grn_ctx *ctx, grn_pat *pat,
const void *key, unsigned int key_size);
GRN_API unsigned int grn_pat_size(grn_ctx *ctx, grn_pat *pat);
GRN_API grn_pat_cursor *grn_pat_cursor_open(grn_ctx *ctx, grn_pat *pat,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_id grn_pat_cursor_next(grn_ctx *ctx, grn_pat_cursor *c);
GRN_API void grn_pat_cursor_close(grn_ctx *ctx, grn_pat_cursor *c);
GRN_API int grn_pat_cursor_get_key(grn_ctx *ctx, grn_pat_cursor *c, void **key);
GRN_API int grn_pat_cursor_get_value(grn_ctx *ctx, grn_pat_cursor *c, void **value);
GRN_API int grn_pat_cursor_get_key_value(grn_ctx *ctx, grn_pat_cursor *c,
void **key, unsigned int *key_size, void **value);
GRN_API grn_rc grn_pat_cursor_set_value(grn_ctx *ctx, grn_pat_cursor *c,
const void *value, int flags);
GRN_API grn_rc grn_pat_cursor_delete(grn_ctx *ctx, grn_pat_cursor *c,
grn_table_delete_optarg *optarg);
#define GRN_PAT_EACH(ctx,pat,id,key,key_size,value,block) do { \
grn_pat_cursor *_sc = grn_pat_cursor_open(ctx, pat, NULL, 0, NULL, 0, 0, -1, 0); \
if (_sc) {\
grn_id id;\
while ((id = grn_pat_cursor_next(ctx, _sc))) {\
grn_pat_cursor_get_key_value(ctx, _sc, (void **)(key),\
(key_size), (void **)(value));\
block\
}\
grn_pat_cursor_close(ctx, _sc);\
}\
} while (0)
#ifdef __cplusplus
}
#endif

83
storage/mroonga/vendor/groonga/include/groonga/plugin.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2010-2014 Brazil
Copyright(C) 2010-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_PLUGIN_H
#define GROONGA_PLUGIN_H
#pragma once
#include <stddef.h>
@ -62,17 +62,34 @@ GRN_PLUGIN_EXPORT grn_rc GRN_PLUGIN_FIN(grn_ctx *ctx);
/*
Don't call these functions directly. Use GRN_PLUGIN_MALLOC(),
GRN_PLUGIN_REALLOC() and GRN_PLUGIN_FREE() instead.
GRN_PLUGIN_CALLOC(), GRN_PLUGIN_REALLOC() and GRN_PLUGIN_FREE() instead.
*/
GRN_API void *grn_plugin_malloc(grn_ctx *ctx, size_t size, const char *file,
int line, const char *func);
GRN_API void *grn_plugin_realloc(grn_ctx *ctx, void *ptr, size_t size,
const char *file, int line, const char *func);
GRN_API void *grn_plugin_malloc(grn_ctx *ctx,
size_t size,
const char *file,
int line,
const char *func) GRN_ATTRIBUTE_ALLOC_SIZE(2);
GRN_API void *grn_plugin_calloc(grn_ctx *ctx,
size_t size,
const char *file,
int line,
const char *func) GRN_ATTRIBUTE_ALLOC_SIZE(2);
GRN_API void *grn_plugin_realloc(grn_ctx *ctx,
void *ptr,
size_t size,
const char *file,
int line,
const char *func) GRN_ATTRIBUTE_ALLOC_SIZE(3);
GRN_API void grn_plugin_free(grn_ctx *ctx, void *ptr, const char *file,
int line, const char *func);
#define GRN_PLUGIN_MALLOC(ctx, size) \
grn_plugin_malloc((ctx), (size), __FILE__, __LINE__, __FUNCTION__)
#define GRN_PLUGIN_MALLOCN(ctx, type, n) \
((type *)(grn_plugin_malloc((ctx), sizeof(type) * (n), \
__FILE__, __LINE__, __FUNCTION__)))
#define GRN_PLUGIN_CALLOC(ctx, size) \
grn_plugin_calloc((ctx), (size), __FILE__, __LINE__, __FUNCTION__)
#define GRN_PLUGIN_REALLOC(ctx, ptr, size) \
grn_plugin_realloc((ctx), (ptr), (size), __FILE__, __LINE__, __FUNCTION__)
#define GRN_PLUGIN_FREE(ctx, ptr) \
@ -89,6 +106,8 @@ GRN_API void grn_plugin_set_error(grn_ctx *ctx, grn_log_level level,
grn_rc error_code,
const char *file, int line, const char *func,
const char *format, ...) GRN_ATTRIBUTE_PRINTF(7);
GRN_API void grn_plugin_clear_error(grn_ctx *ctx);
/*
Don't call these functions directly. grn_plugin_backtrace() and
@ -104,14 +123,15 @@ GRN_API void grn_plugin_logtrace(grn_ctx *ctx, grn_log_level level);
#define GRN_PLUGIN_SET_ERROR(ctx, level, error_code, ...) do { \
grn_plugin_set_error(ctx, level, error_code, \
__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__); \
GRN_LOG(ctx, level, __VA_ARGS__); \
grn_plugin_backtrace(ctx); \
grn_plugin_logtrace(ctx, level); \
} while (0)
#define GRN_PLUGIN_ERROR(ctx, error_code, ...) \
GRN_PLUGIN_SET_ERROR(ctx, GRN_LOG_ERROR, error_code, __VA_ARGS__)
#define GRN_PLUGIN_CLEAR_ERROR(ctx) do { \
grn_plugin_clear_error((ctx)); \
} while (0)
typedef struct _grn_plugin_mutex grn_plugin_mutex;
GRN_API grn_plugin_mutex *grn_plugin_mutex_open(grn_ctx *ctx);
@ -135,18 +155,43 @@ GRN_API void grn_plugin_mutex_lock(grn_ctx *ctx, grn_plugin_mutex *mutex);
GRN_API void grn_plugin_mutex_unlock(grn_ctx *ctx, grn_plugin_mutex *mutex);
GRN_API grn_obj *grn_plugin_proc_alloc(grn_ctx *ctx, grn_user_data *user_data,
grn_id domain, grn_obj_flags flags);
grn_id domain, unsigned char flags);
GRN_API grn_obj *grn_plugin_proc_get_vars(grn_ctx *ctx, grn_user_data *user_data);
GRN_API grn_obj *grn_plugin_proc_get_var(grn_ctx *ctx, grn_user_data *user_data,
const char *name, int name_size);
GRN_API grn_bool grn_plugin_proc_get_var_bool(grn_ctx *ctx,
grn_user_data *user_data,
const char *name,
int name_size,
grn_bool default_value);
GRN_API int32_t grn_plugin_proc_get_var_int32(grn_ctx *ctx,
grn_user_data *user_data,
const char *name,
int name_size,
int32_t default_value);
GRN_API const char *grn_plugin_proc_get_var_string(grn_ctx *ctx,
grn_user_data *user_data,
const char *name,
int name_size,
size_t *size);
GRN_API grn_content_type grn_plugin_proc_get_var_content_type(grn_ctx *ctx,
grn_user_data *user_data,
const char *name,
int name_size,
grn_content_type default_value);
GRN_API grn_obj *grn_plugin_proc_get_var_by_offset(grn_ctx *ctx,
grn_user_data *user_data,
unsigned int offset);
GRN_API grn_obj *grn_plugin_proc_get_caller(grn_ctx *ctx,
grn_user_data *user_data);
/* Deprecated since 5.0.9. Use grn_plugin_windows_base_dir() instead. */
GRN_API const char *grn_plugin_win32_base_dir(void);
GRN_API const char *grn_plugin_windows_base_dir(void);
GRN_API int grn_plugin_charlen(grn_ctx *ctx, const char *str_ptr,
unsigned int str_length, grn_encoding encoding);
@ -159,16 +204,14 @@ GRN_API grn_rc grn_plugin_expr_var_init(grn_ctx *ctx,
const char *name,
int name_size);
GRN_API grn_obj * grn_plugin_command_create(grn_ctx *ctx,
const char *name,
int name_size,
grn_proc_func func,
unsigned int n_vars,
grn_expr_var *vars);
GRN_API grn_obj *grn_plugin_command_create(grn_ctx *ctx,
const char *name,
int name_size,
grn_proc_func func,
unsigned int n_vars,
grn_expr_var *vars);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_PLUGIN_H */

59
storage/mroonga/vendor/groonga/include/groonga/portability.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2015 Brazil
Copyright(C) 2015-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_PORTABILITY_H
#define GROONGA_PORTABILITY_H
#pragma once
#ifdef WIN32
# ifdef __cplusplus
@ -118,11 +118,38 @@
#endif /* WIN32 */
#ifdef WIN32
# define grn_snprintf(dest, dest_size, n, format, ...) \
_snprintf_s((dest), (dest_size), (n) - 1, (format), __VA_ARGS__)
# define grn_strcasecmp(string1, string2) \
_stricmp((string1), (string2))
#else /* WIN32 */
# define grn_snprintf(dest, dest_size, n, format, ...) \
snprintf((dest), (n), (format), __VA_ARGS__)
# define grn_strcasecmp(string1, string2) \
strcasecmp((string1), (string2))
#endif /* WIN32 */
#ifdef WIN32
# define grn_strncasecmp(string1, string2, n) \
_strnicmp((string1), (string2), (n))
#else /* WIN32 */
# define grn_strncasecmp(string1, string2, n) \
strncasecmp((string1), (string2), (n))
#endif /* WIN32 */
#ifdef WIN32
# define grn_snprintf(dest, dest_size, n, ...) do { \
_snprintf_s((dest), (dest_size), (n) - 1, __VA_ARGS__); \
} while (GRN_FALSE)
#else /* WIN32 */
# define grn_snprintf(dest, dest_size, n, ...) \
snprintf((dest), (n), __VA_ARGS__)
#endif /* WIN32 */
#ifdef WIN32
# define grn_vsnprintf(dest, dest_size, format, args) do { \
vsnprintf((dest), (dest_size), (format), (args)); \
(dest)[(dest_size) - 1] = '\0'; \
} while (GRN_FALSE)
#else /* WIN32 */
# define grn_vsnprintf(dest, dest_size, format, args) \
vsnprintf((dest), (dest_size), (format), (args))
#endif /* WIN32 */
#ifdef WIN32
@ -155,4 +182,20 @@
# define grn_close(fd) close((fd))
#endif /* WIN32 */
#endif /* GROONGA_PORTABILITY_H */
#ifdef WIN32
# define grn_fileno(stream) _fileno((stream))
#else /* WIN32 */
# define grn_fileno(stream) fileno((stream))
#endif /* WIN32 */
#ifdef WIN32
# define grn_isatty(stream) _isatty((stream))
#else /* WIN32 */
# define grn_isatty(stream) isatty((stream))
#endif /* WIN32 */
#ifdef WIN32
# define grn_getpid() _getpid()
#else /* WIN32 */
# define grn_getpid() getpid()
#endif /* WIN32 */

8
storage/mroonga/vendor/groonga/include/groonga/request_canceler.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2014 Brazil
Copyright(C) 2014-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -16,8 +16,7 @@
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_REQUEST_CANCELER_H
#define GROONGA_REQUEST_CANCELER_H
#pragma once
#ifdef __cplusplus
extern "C" {
@ -31,9 +30,8 @@ GRN_API void grn_request_canceler_unregister(grn_ctx *ctx,
unsigned int size);
GRN_API grn_bool grn_request_canceler_cancel(const char *request_id,
unsigned int size);
GRN_API grn_bool grn_request_canceler_cancel_all(void);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_REQUEST_CANCELER_H */

53
storage/mroonga/vendor/groonga/include/groonga/request_timer.h vendored Normal file
View file

@ -0,0 +1,53 @@
/*
Copyright(C) 2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _grn_request_timer {
void *user_data;
void *(*register_func)(const char *request_id,
unsigned int request_id_size,
double timeout,
void *user_data);
void (*unregister_func)(void *timer_id,
void *user_data);
void (*fin_func)(void *user_data);
} grn_request_timer;
/* Multithreading unsafe. */
GRN_API void grn_request_timer_set(grn_request_timer *timer);
/* Multithreading safety is depends on grn_request_timer. */
GRN_API void *grn_request_timer_register(const char *request_id,
unsigned int request_id_size,
double timeout);
/* Multithreading safety is depends on grn_request_timer. */
GRN_API void grn_request_timer_unregister(void *timer_id);
GRN_API double grn_get_default_request_timeout(void);
GRN_API void grn_set_default_request_timeout(double timeout);
#ifdef __cplusplus
}
#endif

14
storage/mroonga/vendor/groonga/include/groonga/scorer.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2015 Brazil
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_SCORER_H
#define GROONGA_SCORER_H
#pragma once
#include <groonga/plugin.h>
@ -74,7 +74,7 @@ typedef double grn_scorer_score_func(grn_ctx *ctx,
/*
grn_scorer_register() registers a plugin to the database which is
associated with `ctx'. `plugin_name_ptr' and `plugin_name_length' specify the
associated with `ctx'. `scorer_name_ptr' and `scorer_name_length' specify the
plugin name. Alphabetic letters ('A'-'Z' and 'a'-'z'), digits ('0'-'9') and
an underscore ('_') are capable characters.
@ -84,12 +84,10 @@ typedef double grn_scorer_score_func(grn_ctx *ctx,
code on failure.
*/
GRN_PLUGIN_EXPORT grn_rc grn_scorer_register(grn_ctx *ctx,
const char *plugin_name_ptr,
int plugin_name_length,
const char *scorer_name_ptr,
int scorer_name_length,
grn_scorer_score_func *score);
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* GROONGA_SCORER_H */

246
storage/mroonga/vendor/groonga/include/groonga/table.h vendored Normal file
View file

@ -0,0 +1,246 @@
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#define GRN_TABLE_MAX_KEY_SIZE (0x1000)
GRN_API grn_obj *grn_table_create(grn_ctx *ctx,
const char *name, unsigned int name_size,
const char *path, grn_table_flags flags,
grn_obj *key_type, grn_obj *value_type);
#define GRN_TABLE_OPEN_OR_CREATE(ctx,name,name_size,path,flags,key_type,value_type,table) \
(((table) = grn_ctx_get((ctx), (name), (name_size))) ||\
((table) = grn_table_create((ctx), (name), (name_size), (path), (flags), (key_type), (value_type))))
/* TODO: int *added -> grn_bool *added */
GRN_API grn_id grn_table_add(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size, int *added);
GRN_API grn_id grn_table_get(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API grn_id grn_table_at(grn_ctx *ctx, grn_obj *table, grn_id id);
GRN_API grn_id grn_table_lcp_search(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API int grn_table_get_key(grn_ctx *ctx, grn_obj *table,
grn_id id, void *keybuf, int buf_size);
GRN_API grn_rc grn_table_delete(grn_ctx *ctx, grn_obj *table,
const void *key, unsigned int key_size);
GRN_API grn_rc grn_table_delete_by_id(grn_ctx *ctx, grn_obj *table, grn_id id);
GRN_API grn_rc grn_table_update_by_id(grn_ctx *ctx, grn_obj *table, grn_id id,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_table_update(grn_ctx *ctx, grn_obj *table,
const void *src_key, unsigned int src_key_size,
const void *dest_key, unsigned int dest_key_size);
GRN_API grn_rc grn_table_truncate(grn_ctx *ctx, grn_obj *table);
#define GRN_CURSOR_ASCENDING (0x00<<0)
#define GRN_CURSOR_DESCENDING (0x01<<0)
#define GRN_CURSOR_GE (0x00<<1)
#define GRN_CURSOR_GT (0x01<<1)
#define GRN_CURSOR_LE (0x00<<2)
#define GRN_CURSOR_LT (0x01<<2)
#define GRN_CURSOR_BY_KEY (0x00<<3)
#define GRN_CURSOR_BY_ID (0x01<<3)
#define GRN_CURSOR_PREFIX (0x01<<4)
#define GRN_CURSOR_SIZE_BY_BIT (0x01<<5)
#define GRN_CURSOR_RK (0x01<<6)
GRN_API grn_table_cursor *grn_table_cursor_open(grn_ctx *ctx, grn_obj *table,
const void *min, unsigned int min_size,
const void *max, unsigned int max_size,
int offset, int limit, int flags);
GRN_API grn_rc grn_table_cursor_close(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API grn_id grn_table_cursor_next(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API int grn_table_cursor_get_key(grn_ctx *ctx, grn_table_cursor *tc, void **key);
GRN_API int grn_table_cursor_get_value(grn_ctx *ctx, grn_table_cursor *tc, void **value);
GRN_API grn_rc grn_table_cursor_set_value(grn_ctx *ctx, grn_table_cursor *tc,
const void *value, int flags);
GRN_API grn_rc grn_table_cursor_delete(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API grn_obj *grn_table_cursor_table(grn_ctx *ctx, grn_table_cursor *tc);
GRN_API grn_obj *grn_index_cursor_open(grn_ctx *ctx, grn_table_cursor *tc, grn_obj *index,
grn_id rid_min, grn_id rid_max, int flags);
GRN_API grn_posting *grn_index_cursor_next(grn_ctx *ctx, grn_obj *ic, grn_id *tid);
#define GRN_TABLE_EACH(ctx,table,head,tail,id,key,key_size,value,block) do {\
(ctx)->errlvl = GRN_LOG_NOTICE;\
(ctx)->rc = GRN_SUCCESS;\
if ((ctx)->seqno & 1) {\
(ctx)->subno++;\
} else {\
(ctx)->seqno++;\
}\
if (table) {\
switch ((table)->header.type) {\
case GRN_TABLE_PAT_KEY :\
GRN_PAT_EACH((ctx), (grn_pat *)(table), (id), (key), (key_size), (value), block);\
break;\
case GRN_TABLE_DAT_KEY :\
GRN_DAT_EACH((ctx), (grn_dat *)(table), (id), (key), (key_size), block);\
break;\
case GRN_TABLE_HASH_KEY :\
GRN_HASH_EACH((ctx), (grn_hash *)(table), (id), (key), (key_size), (value), block);\
break;\
case GRN_TABLE_NO_KEY :\
GRN_ARRAY_EACH((ctx), (grn_array *)(table), (head), (tail), (id), (value), block);\
break;\
}\
}\
if ((ctx)->subno) {\
(ctx)->subno--;\
} else {\
(ctx)->seqno++;\
}\
} while (0)
#define GRN_TABLE_EACH_BEGIN(ctx, table, cursor, id) do {\
if ((table)) {\
grn_table_cursor *cursor;\
cursor = grn_table_cursor_open((ctx), (table),\
NULL, 0,\
NULL, 0,\
0, -1, GRN_CURSOR_ASCENDING);\
if (cursor) {\
grn_id id;\
while ((id = grn_table_cursor_next((ctx), cursor))) {
#define GRN_TABLE_EACH_BEGIN_FLAGS(ctx, table, cursor, id, flags) do {\
if ((table)) {\
grn_table_cursor *cursor;\
cursor = grn_table_cursor_open((ctx), (table),\
NULL, 0,\
NULL, 0,\
0, -1, (flags));\
if (cursor) {\
grn_id id;\
while ((id = grn_table_cursor_next((ctx), cursor))) {
#define GRN_TABLE_EACH_BEGIN_MIN(ctx, table, cursor, id,\
min, min_size, flags) do {\
if ((table)) {\
grn_table_cursor *cursor;\
cursor = grn_table_cursor_open((ctx), (table),\
(min), (min_size),\
NULL, 0,\
0, -1, (flags));\
if (cursor) {\
grn_id id;\
while ((id = grn_table_cursor_next((ctx), cursor))) {
#define GRN_TABLE_EACH_END(ctx, cursor)\
}\
grn_table_cursor_close((ctx), cursor);\
}\
}\
} while (0)
typedef struct _grn_table_sort_key grn_table_sort_key;
typedef unsigned char grn_table_sort_flags;
#define GRN_TABLE_SORT_ASC (0x00<<0)
#define GRN_TABLE_SORT_DESC (0x01<<0)
struct _grn_table_sort_key {
grn_obj *key;
grn_table_sort_flags flags;
int offset;
};
GRN_API int grn_table_sort(grn_ctx *ctx, grn_obj *table, int offset, int limit,
grn_obj *result, grn_table_sort_key *keys, int n_keys);
typedef struct _grn_table_group_result grn_table_group_result;
typedef uint32_t grn_table_group_flags;
#define GRN_TABLE_GROUP_CALC_COUNT (0x01<<3)
#define GRN_TABLE_GROUP_CALC_MAX (0x01<<4)
#define GRN_TABLE_GROUP_CALC_MIN (0x01<<5)
#define GRN_TABLE_GROUP_CALC_SUM (0x01<<6)
#define GRN_TABLE_GROUP_CALC_AVG (0x01<<7)
struct _grn_table_group_result {
grn_obj *table;
unsigned char key_begin;
unsigned char key_end;
int limit;
grn_table_group_flags flags;
grn_operator op;
unsigned int max_n_subrecs;
grn_obj *calc_target;
};
GRN_API grn_rc grn_table_group(grn_ctx *ctx, grn_obj *table,
grn_table_sort_key *keys, int n_keys,
grn_table_group_result *results, int n_results);
GRN_API grn_rc grn_table_setoperation(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
grn_obj *res, grn_operator op);
GRN_API grn_rc grn_table_difference(grn_ctx *ctx, grn_obj *table1, grn_obj *table2,
grn_obj *res1, grn_obj *res2);
GRN_API int grn_table_columns(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size,
grn_obj *res);
GRN_API unsigned int grn_table_size(grn_ctx *ctx, grn_obj *table);
GRN_API grn_rc grn_table_rename(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size);
GRN_API grn_obj *grn_table_select(grn_ctx *ctx, grn_obj *table, grn_obj *expr,
grn_obj *res, grn_operator op);
GRN_API grn_table_sort_key *grn_table_sort_key_from_str(grn_ctx *ctx,
const char *str, unsigned int str_size,
grn_obj *table, unsigned int *nkeys);
GRN_API grn_rc grn_table_sort_key_close(grn_ctx *ctx,
grn_table_sort_key *keys, unsigned int nkeys);
GRN_API grn_bool grn_table_is_grouped(grn_ctx *ctx, grn_obj *table);
GRN_API unsigned int grn_table_max_n_subrecs(grn_ctx *ctx, grn_obj *table);
GRN_API grn_obj *grn_table_create_for_group(grn_ctx *ctx,
const char *name,
unsigned int name_size,
const char *path,
grn_obj *group_key,
grn_obj *value_type,
unsigned int max_n_subrecs);
GRN_API unsigned int grn_table_get_subrecs(grn_ctx *ctx, grn_obj *table,
grn_id id, grn_id *subrecbuf,
int *scorebuf, int buf_size);
GRN_API grn_obj *grn_table_tokenize(grn_ctx *ctx, grn_obj *table,
const char *str, unsigned int str_len,
grn_obj *buf, grn_bool addp);
GRN_API grn_rc grn_table_apply_expr(grn_ctx *ctx,
grn_obj *table,
grn_obj *output_column,
grn_obj *expr);
GRN_API grn_id grn_table_find_reference_object(grn_ctx *ctx, grn_obj *table);
#ifdef __cplusplus
}
#endif

39
storage/mroonga/vendor/groonga/include/groonga/thread.h vendored Normal file
View file

@ -0,0 +1,39 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API uint32_t grn_thread_get_limit(void);
GRN_API void grn_thread_set_limit(uint32_t new_limit);
typedef uint32_t (*grn_thread_get_limit_func)(void *data);
GRN_API void grn_thread_set_get_limit_func(grn_thread_get_limit_func func,
void *data);
typedef void (*grn_thread_set_limit_func)(uint32_t new_limit, void *data);
GRN_API void grn_thread_set_set_limit_func(grn_thread_set_limit_func func,
void *data);
#ifdef __cplusplus
}
#endif

61
storage/mroonga/vendor/groonga/include/groonga/time.h vendored Normal file
View file

@ -0,0 +1,61 @@
/*
Copyright(C) 2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#include <time.h>
#ifdef __cplusplus
extern "C" {
#endif
#define GRN_TIMEVAL_TO_MSEC(timeval) \
(((timeval)->tv_sec * GRN_TIME_MSEC_PER_SEC) + \
((timeval)->tv_nsec / GRN_TIME_NSEC_PER_MSEC))
#define GRN_TIME_NSEC_PER_SEC 1000000000
#define GRN_TIME_NSEC_PER_SEC_F 1000000000.0
#define GRN_TIME_NSEC_PER_MSEC 1000000
#define GRN_TIME_NSEC_PER_USEC (GRN_TIME_NSEC_PER_SEC / GRN_TIME_USEC_PER_SEC)
#define GRN_TIME_MSEC_PER_SEC 1000
#define GRN_TIME_NSEC_TO_USEC(nsec) ((nsec) / GRN_TIME_NSEC_PER_USEC)
#define GRN_TIME_USEC_TO_NSEC(usec) ((usec) * GRN_TIME_NSEC_PER_USEC)
#define GRN_TIME_USEC_PER_SEC 1000000
#define GRN_TIME_PACK(sec, usec) ((int64_t)(sec) * GRN_TIME_USEC_PER_SEC + (usec))
#define GRN_TIME_UNPACK(time_value, sec, usec) do {\
sec = (time_value) / GRN_TIME_USEC_PER_SEC;\
usec = (time_value) % GRN_TIME_USEC_PER_SEC;\
} while (0)
GRN_API grn_rc grn_timeval_now(grn_ctx *ctx, grn_timeval *tv);
GRN_API void grn_time_now(grn_ctx *ctx, grn_obj *obj);
#define GRN_TIME_NOW(ctx,obj) (grn_time_now((ctx), (obj)))
GRN_API grn_bool grn_time_to_tm(grn_ctx *ctx,
int64_t time,
struct tm *tm);
GRN_API grn_bool grn_time_from_tm(grn_ctx *ctx,
int64_t *time,
struct tm *tm);
#ifdef __cplusplus
}
#endif

11
storage/mroonga/vendor/groonga/include/groonga/token.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2014 Brazil
Copyright(C) 2014-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_TOKEN_H
#define GROONGA_TOKEN_H
#pragma once
#ifdef __cplusplus
extern "C" {
@ -36,7 +36,8 @@ extern "C" {
typedef enum {
GRN_TOKENIZE_GET = 0,
GRN_TOKENIZE_ADD,
GRN_TOKENIZE_DELETE
GRN_TOKENIZE_DELETE,
GRN_TOKENIZE_ONLY
} grn_tokenize_mode;
/*
@ -132,5 +133,3 @@ GRN_PLUGIN_EXPORT grn_rc grn_token_set_status(grn_ctx *ctx,
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* GROONGA_TOKEN_H */

8
storage/mroonga/vendor/groonga/include/groonga/token_filter.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2014 Brazil
Copyright(C) 2014-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_TOKEN_FILTER_H
#define GROONGA_TOKEN_FILTER_H
#pragma once
#include <groonga/tokenizer.h>
@ -65,5 +65,3 @@ GRN_PLUGIN_EXPORT grn_rc grn_token_filter_register(grn_ctx *ctx,
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* GROONGA_TOKEN_FILTER_H */

8
storage/mroonga/vendor/groonga/include/groonga/tokenizer.h vendored
View file

@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2 -*- */
/*
Copyright(C) 2012 Brazil
Copyright(C) 2012-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_TOKENIZER_H
#define GROONGA_TOKENIZER_H
#pragma once
#include <groonga/plugin.h>
#include <groonga/token.h>
@ -258,5 +258,3 @@ GRN_PLUGIN_EXPORT grn_rc grn_tokenizer_register(grn_ctx *ctx, const char *plugin
#ifdef __cplusplus
} /* extern "C" */
#endif /* __cplusplus */
#endif /* GROONGA_TOKENIZER_H */

40
storage/mroonga/vendor/groonga/include/groonga/type.h vendored Normal file
View file

@ -0,0 +1,40 @@
/*
Copyright(C) 2009-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
/* Just for backward compatibility.
Use grn_type_id_is_text_family() instead. */
#define GRN_TYPE_IS_TEXT_FAMILY(type) \
grn_type_id_is_text_family(NULL, (type))
GRN_API grn_bool grn_type_id_is_builtin(grn_ctx *ctx, grn_id id);
GRN_API grn_bool grn_type_id_is_number_family(grn_ctx *ctx, grn_id id);
GRN_API grn_bool grn_type_id_is_text_family(grn_ctx *ctx, grn_id id);
GRN_API grn_obj *grn_type_create(grn_ctx *ctx, const char *name, unsigned int name_size,
grn_obj_flags flags, unsigned int size);
GRN_API uint32_t grn_type_size(grn_ctx *ctx, grn_obj *type);
#ifdef __cplusplus
}
#endif

14
storage/mroonga/vendor/groonga/include/groonga/util.h vendored
View file

@ -1,5 +1,5 @@
/*
Copyright(C) 2010-2014 Brazil
Copyright(C) 2010-2017 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@ -15,8 +15,8 @@
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GROONGA_UTIL_H
#define GROONGA_UTIL_H
#pragma once
#ifdef __cplusplus
extern "C" {
@ -25,9 +25,15 @@ extern "C" {
GRN_API grn_obj *grn_inspect(grn_ctx *ctx, grn_obj *buffer, grn_obj *obj);
GRN_API grn_obj *grn_inspect_indented(grn_ctx *ctx, grn_obj *buffer,
grn_obj *obj, const char *indent);
GRN_API grn_obj *grn_inspect_limited(grn_ctx *ctx,
grn_obj *buffer,
grn_obj *obj);
GRN_API grn_obj *grn_inspect_name(grn_ctx *ctx, grn_obj *buffer, grn_obj *obj);
GRN_API grn_obj *grn_inspect_encoding(grn_ctx *ctx, grn_obj *buffer, grn_encoding encoding);
GRN_API grn_obj *grn_inspect_type(grn_ctx *ctx, grn_obj *buffer, unsigned char type);
GRN_API grn_obj *grn_inspect_query_log_flags(grn_ctx *ctx,
grn_obj *buffer,
unsigned int flags);
GRN_API void grn_p(grn_ctx *ctx, grn_obj *obj);
GRN_API void grn_p_geo_point(grn_ctx *ctx, grn_geo_point *point);
@ -36,5 +42,3 @@ GRN_API void grn_p_ii_values(grn_ctx *ctx, grn_obj *obj);
#ifdef __cplusplus
}
#endif
#endif /* GROONGA_UTIL_H */

73
storage/mroonga/vendor/groonga/include/groonga/window_function.h vendored Normal file
View file

@ -0,0 +1,73 @@
/*
Copyright(C) 2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
GRN_WINDOW_DIRECTION_ASCENDING,
GRN_WINDOW_DIRECTION_DESCENDING
} grn_window_direction;
typedef struct _grn_window grn_window;
GRN_API grn_id grn_window_next(grn_ctx *ctx,
grn_window *window);
GRN_API grn_rc grn_window_rewind(grn_ctx *ctx,
grn_window *window);
GRN_API grn_rc grn_window_set_direction(grn_ctx *ctx,
grn_window *window,
grn_window_direction direction);
GRN_API grn_obj *grn_window_get_table(grn_ctx *ctx,
grn_window *window);
GRN_API grn_bool grn_window_is_sorted(grn_ctx *ctx,
grn_window *window);
GRN_API size_t grn_window_get_size(grn_ctx *ctx,
grn_window *window);
typedef struct _grn_window_definition {
grn_table_sort_key *sort_keys;
size_t n_sort_keys;
grn_table_sort_key *group_keys;
size_t n_group_keys;
} grn_window_definition;
typedef grn_rc grn_window_function_func(grn_ctx *ctx,
grn_obj *output_column,
grn_window *window,
grn_obj **args,
int n_args);
GRN_API grn_obj *grn_window_function_create(grn_ctx *ctx,
const char *name,
int name_size,
grn_window_function_func func);
GRN_API grn_rc grn_table_apply_window_function(grn_ctx *ctx,
grn_obj *table,
grn_obj *output_column,
grn_window_definition *definition,
grn_obj *window_function_call);
#ifdef __cplusplus
}
#endif

31
storage/mroonga/vendor/groonga/include/groonga/windows.h vendored Normal file
View file

@ -0,0 +1,31 @@
/*
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#ifdef WIN32
GRN_API const char *grn_windows_base_dir(void);
#endif /* WIN32 */
#ifdef __cplusplus
}
#endif

30
storage/mroonga/vendor/groonga/include/groonga/windows_event_logger.h vendored Normal file
View file

@ -0,0 +1,30 @@
/*
Copyright(C) 2015-2016 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
GRN_API grn_rc grn_windows_event_logger_set(grn_ctx *ctx,
const char *event_source_name);
#ifdef __cplusplus
}
#endif