module.h

Go to the documentation of this file.

#ifndef TARANTOOL_MODULE_H_INCLUDED
#define TARANTOOL_MODULE_H_INCLUDED
 
/*
 * Copyright 2010-2016, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY AUTHORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
 * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
 
#include <stddef.h>
#include <stdarg.h> /* va_list */
#include <errno.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdio.h> /* ssize_t for Apple */
#include <sys/types.h> /* ssize_t */
 
#if defined(__cplusplus)
extern "C" {
#endif /* defined(__cplusplus) */
 
#include "lua.h"  /* does not have extern C wrappers */
#define PACKAGE_VERSION_MAJOR 3
#define PACKAGE_VERSION_MINOR 4
#define PACKAGE_VERSION_PATCH 0
#define PACKAGE_VERSION "3.4.0-entrypoint-229-ge2a6e2cd13"
#define TZDATA_VERSION "2022a"
 
#define SYSCONF_DIR "etc"
#define INSTALL_PREFIX "/usr/local"
#define BUILD_TYPE "Debug"
#define BUILD_INFO "Linux-x86_64-Debug"
#define BUILD_OPTIONS "cmake . -DCMAKE_INSTALL_PREFIX=/usr/local -DENABLE_BACKTRACE=TRUE"
#define COMPILER_INFO "GNU-13.3.0"
#define TARANTOOL_C_FLAGS " -fexceptions -funwind-tables -fasynchronous-unwind-tables -fno-common -msse2 -Wformat -Wformat-security -Werror=format-security -fstack-protector-strong -fPIC -fmacro-prefix-map=/home/runner/work/tarantool/tarantool=. -std=c11 -Wall -Wextra -Wno-gnu-alignof-expression -fno-gnu89-inline -Wno-cast-function-type -Werror -g -ggdb -O0 "
#define TARANTOOL_CXX_FLAGS " -fexceptions -funwind-tables -fasynchronous-unwind-tables -fno-common -msse2 -Wformat -Wformat-security -Werror=format-security -fstack-protector-strong -fPIC -fmacro-prefix-map=/home/runner/work/tarantool/tarantool=. -std=c++11 -Wall -Wextra -Wno-invalid-offsetof -Wno-gnu-alignof-expression -Wno-cast-function-type -Werror -g -ggdb -O0 "
 
#define MODULE_LIBDIR "/usr/local/lib/tarantool"
#define MODULE_LUADIR "/usr/local/share/tarantool"
#define MODULE_INCLUDEDIR "/usr/local/include/tarantool"
#define MODULE_LUAPATH "/usr/local/share/tarantool/?.lua;/usr/local/share/tarantool/?/init.lua;/usr/share/tarantool/?.lua;/usr/share/tarantool/?/init.lua;/usr/local/share/lua/5.1/?.lua;/usr/local/share/lua/5.1/?/init.lua;/usr/share/lua/5.1/?.lua;/usr/share/lua/5.1/?/init.lua"
#define MODULE_LIBPATH "/usr/local/lib/x86_64-linux-gnu/tarantool/?.so;/usr/local/lib/tarantool/?.so;/usr/lib/x86_64-linux-gnu/lua/luarocks/lib/tarantool/?.so;/usr/lib/x86_64-linux-gnu/tarantool/?.so;/usr/local/lib/x86_64-linux-gnu/lua/5.1/?.so;/usr/local/lib/lua/5.1/?.so;/usr/lib/x86_64-linux-gnu/lua/luarocks/lib/lua/5.1/?.so;/usr/lib/x86_64-linux-gnu/lua/5.1/?.so"
#define MODULE_LIBSUFFIX ".so"
 
#ifndef __has_feature
#  define __has_feature(x) 0
#endif
#ifndef __has_builtin
#  define __has_builtin(x) 0
#endif
#ifndef __has_attribute
#  define __has_attribute(x) 0
#endif
#ifndef __has_cpp_attribute
#  define __has_cpp_attribute(x) 0
#endif
 
#if __has_builtin(__builtin_expect) || defined(__GNUC__)
#  define likely(x)    __builtin_expect(!! (x),1)
#  define unlikely(x)  __builtin_expect(!! (x),0)
#else
#  define likely(x)    (x)
#  define unlikely(x)  (x)
#endif
 
#if __has_builtin(__builtin_prefetch) || defined(__GNUC__)
#  define prefetch(addr, ...) (__builtin_prefetch(addr, __VA_ARGS__))
#else
#  define prefetch(addr, ...) ((void) addr)
#endif
 
#if __has_builtin(__builtin_unreachable) || defined(__GNUC__)
#  define unreachable() (assert(0), __builtin_unreachable())
#else
#  define unreachable() (assert(0))
#endif
 
#ifndef offsetof
#  if __has_builtin(__builtin_offsetof)
#    define offsetof(type, member) __builtin_offsetof(type, member)
#  else
#    define offsetof(type, member) ((size_t)&((type *)0)->member)
#  endif
#endif /* offsetof */
 
#ifndef container_of
#define container_of(ptr, type, member) ({ \
        const typeof( ((type *)0)->member  ) *__mptr = (ptr); \
        (type *)( (char *)__mptr - offsetof(type,member)  );})
#endif
 
#if defined(__cplusplus)
#  include <stdalign.h>
#endif
#if !defined(alignas) && !defined(__alignas_is_defined)
#  if __has_feature(c_alignas) || (defined(__GNUC__) && __GNUC__ >= 5)
#    include <stdalign.h>
#  elif __has_attribute(aligned) || defined(__GNUC__)
#    define alignas(_n) __attribute__((aligned(_n)))
#    define __alignas_is_defined 1
#  else
#    define alignas(_n)
#  endif
#endif
 
#if !defined(alignof) && !defined(__alignof_is_defined)
#  if __has_feature(c_alignof) || (defined(__GNUC__) && __GNUC__ >= 5)
#    include <stdalign.h>
#  elif defined(__GNUC__)
#    define alignof(_T) __alignof(_T)
#    define __alignof_is_defined 1
#  else
#    define alignof(_T) offsetof(struct { char c; _T member; }, member)
#    define __alignof_is_defined 1
#  endif
#endif
 
#if defined(__cplusplus) && __has_cpp_attribute(maybe_unused)
#  define MAYBE_UNUSED [[maybe_unused]]
#elif __has_attribute(unused) || defined(__GNUC__)
#  define MAYBE_UNUSED __attribute__((unused))
#else
#  define MAYBE_UNUSED
#endif
 
#if defined(__cplusplus) && __has_cpp_attribute(nodiscard)
#  define NODISCARD [[nodiscard]]
#elif __has_attribute(warn_unused_result) || defined(__GNUC__)
#  define NODISCARD __attribute__((warn_unused_result))
#else
#  define NODISCARD
#endif
 
#if __has_attribute(noinline) || defined(__GNUC__)
#  define NOINLINE __attribute__((noinline))
#else
#  define NOINLINE
#endif
 
#if __has_attribute(always_inline) || defined(__GNUC__)
#  define ALWAYS_INLINE inline __attribute__((always_inline))
#else
#  define ALWAYS_INLINE inline
#endif
 
#if defined(__cplusplus) && __has_cpp_attribute(noreturn)
#  define NORETURN [[noreturn]]
#elif __has_attribute(noreturn) || defined(__GNUC__)
#  define NORETURN  __attribute__((noreturn))
#else
#  define NORETURN
#endif
 
#if defined(__cplusplus) && __has_cpp_attribute(deprecated)
#  define DEPRECATED(_msg) [[deprecated(_msg)]]
#elif __has_attribute(deprecated) || defined(__GNUC__)
#  define DEPREACTED  __attribute__((deprecated(_msg)))
#else
#  define DEPRECATED(_msg)
#endif
 
#if defined(__cplusplus) && defined(__GNUC__)
#  define API_EXPORT extern "C" __attribute__ ((nothrow, visibility ("default")))
#elif defined(__cplusplus)
#  define API_EXPORT extern "C"
#elif defined(__GNUC__)
#  define API_EXPORT extern __attribute__ ((nothrow, visibility ("default")))
#else
#  define API_EXPORT extern
#endif
 
#if __has_attribute(format) || defined(__GNUC__)
#  define CFORMAT(_archetype, _stringindex, _firsttocheck) \
        __attribute__((format(_archetype, _stringindex, _firsttocheck)))
#else
#  define CFORMAT(archetype, stringindex, firsttocheck)
#endif
 
#if __has_attribute(packed) || defined(__GNUC__)
#  define PACKED  __attribute__((packed))
#elif defined(__CC_ARM)
#  define PACKED __packed
#else
#  define PACKED
#endif
 
#if __has_feature(address_sanitizer)
#  define NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
#else
#  define NO_SANITIZE_ADDRESS
#endif
 
#if defined(__cplusplus) && __has_cpp_attribute(fallthrough)
#  define FALLTHROUGH [[fallthrough]]
#elif __has_attribute(fallthrough) || (defined(__GNUC__) && __GNUC__ >= 7)
#  define FALLTHROUGH __attribute__((fallthrough))
#else
#  define FALLTHROUGH
#endif
 
API_EXPORT int
box_on_shutdown(void *arg, int (*new_handler)(void *),
                int (*old_handler)(void *));
 
enum say_level {
        S_FATAL,                /* do not use this value directly */
        S_SYSERROR,
        S_ERROR,
        S_CRIT,
        S_WARN,
        S_INFO,
        S_VERBOSE,
        S_DEBUG,
        say_level_MAX
};
 
enum say_format {
        SF_PLAIN,
        SF_JSON,
        say_format_MAX
};
 
extern int log_level;
 
extern void
(*log_write_flightrec)(int level, const char *filename, int line,
                       const char *error, const char *format, va_list ap);
 
static inline bool
say_log_level_is_enabled(int level)
{
       return level <= log_level;
}
 
typedef void (*sayfunc_t)(int, const char *, int, const char *,
                    const char *, ...);
 
CFORMAT(printf, 5, 6) extern sayfunc_t _say;
 
const char *
_say_strerror(int errnum);
 
#define say_file_line(level, file, line, error, format, ...) ({ \
        if (say_log_level_is_enabled(level)) \
                _say(level, file, line, error, format, ##__VA_ARGS__); })
 
#define say(level, error, format, ...) ({ \
        say_file_line(level, __FILE__, __LINE__, error, format, ##__VA_ARGS__); })
 
#define say_error(format, ...) say(S_ERROR, NULL, format, ##__VA_ARGS__)
#define say_crit(format, ...) say(S_CRIT, NULL, format, ##__VA_ARGS__)
#define say_warn(format, ...) say(S_WARN, NULL, format, ##__VA_ARGS__)
#define say_info(format, ...) say(S_INFO, NULL, format, ##__VA_ARGS__)
#define say_verbose(format, ...) say(S_VERBOSE, NULL, format, ##__VA_ARGS__)
#define say_debug(format, ...) say(S_DEBUG, NULL, format, ##__VA_ARGS__)
#define say_syserror(format, ...) say(S_SYSERROR, _say_strerror(errno), \
                                      format, ##__VA_ARGS__)
struct fiber_attr;
 
API_EXPORT struct fiber_attr *
fiber_attr_new(void);
 
API_EXPORT void
fiber_attr_delete(struct fiber_attr *fiber_attr);
 
API_EXPORT int
fiber_attr_setstacksize(struct fiber_attr *fiber_attr, size_t stack_size);
 
API_EXPORT size_t
fiber_attr_getstacksize(struct fiber_attr *fiber_attr);
 
struct fiber;
typedef int (*fiber_func)(va_list);
 
API_EXPORT struct fiber *
fiber_self(void);
 
API_EXPORT struct fiber *
fiber_new(const char *name, fiber_func f);
 
API_EXPORT struct fiber *
fiber_new_ex(const char *name, const struct fiber_attr *fiber_attr, fiber_func f);
 
API_EXPORT void
fiber_yield(void);
 
API_EXPORT void
fiber_start(struct fiber *callee, ...);
 
API_EXPORT void
fiber_set_ctx(struct fiber *f, void *f_arg);
 
API_EXPORT void *
fiber_get_ctx(struct fiber *f);
 
API_EXPORT void
fiber_wakeup(struct fiber *f);
 
API_EXPORT void
fiber_cancel(struct fiber *f);
 
API_EXPORT bool
fiber_set_cancellable(bool yesno);
 
API_EXPORT void
fiber_set_joinable(struct fiber *fiber, bool yesno);
 
API_EXPORT int
fiber_join(struct fiber *f);
 
API_EXPORT int
fiber_join_timeout(struct fiber *f, double timeout);
 
API_EXPORT void
fiber_sleep(double s);
 
API_EXPORT bool
fiber_is_cancelled(void);
 
API_EXPORT double
fiber_time(void);
 
API_EXPORT int64_t
fiber_time64(void);
 
API_EXPORT double
fiber_clock(void);
 
API_EXPORT int64_t
fiber_clock64(void);
 
API_EXPORT void
fiber_reschedule(void);
 
API_EXPORT void
fiber_set_name_n(struct fiber *fiber, const char *name, uint32_t len);
 
API_EXPORT const char *
fiber_name(const struct fiber *fiber);
 
API_EXPORT uint64_t
fiber_id(const struct fiber *fiber);
 
API_EXPORT uint64_t
fiber_csw(const struct fiber *fiber);
 
API_EXPORT struct fiber *
fiber_find(uint64_t fid);
 
API_EXPORT size_t
box_region_used(void);
 
API_EXPORT void *
box_region_alloc(size_t size);
 
API_EXPORT void *
box_region_aligned_alloc(size_t size, size_t alignment);
 
API_EXPORT void
box_region_truncate(size_t size);
 
struct fiber_cond;
 
struct fiber_cond *
fiber_cond_new(void);
 
void
fiber_cond_delete(struct fiber_cond *cond);
 
void
fiber_cond_signal(struct fiber_cond *cond);
 
void
fiber_cond_broadcast(struct fiber_cond *cond);
 
int
fiber_cond_wait_timeout(struct fiber_cond *cond, double timeout);
 
int
fiber_cond_wait(struct fiber_cond *cond);
 
enum {
        COIO_READ  = 0x1,
        COIO_WRITE = 0x2,
};
 
API_EXPORT int
coio_wait(int fd, int event, double timeout);
 
API_EXPORT int
coio_close(int fd);
 
ssize_t
coio_call(ssize_t (*func)(va_list), ...);
 
struct addrinfo;
 
int
coio_getaddrinfo(const char *host, const char *port,
                 const struct addrinfo *hints, struct addrinfo **res,
                 double timeout);
typedef void
(*tnt_tx_func_f)(void *);
 
API_EXPORT void
tnt_tx_push(tnt_tx_func_f func, void *arg);
 
API_EXPORT void
tnt_tx_flush(void);
 
typedef struct ibuf box_ibuf_t;
 
API_EXPORT void *
box_ibuf_reserve(box_ibuf_t *ibuf, size_t size);
 
API_EXPORT void
box_ibuf_read_range(box_ibuf_t *ibuf, char ***rpos, char ***wpos);
 
API_EXPORT void
box_ibuf_write_range(box_ibuf_t *ibuf, char ***wpos, char ***end);
 
LUA_API int
luaL_iscdata(struct lua_State *L, int idx);
 
LUA_API void *
luaL_pushcdata(struct lua_State *L, uint32_t ctypeid);
 
LUA_API void *
luaL_checkcdata(struct lua_State *L, int idx, uint32_t *ctypeid);
 
LUA_API void
luaL_setcdatagc(struct lua_State *L, int idx);
 
size_t
luaL_getgctotal(struct lua_State *L);
 
LUA_API uint32_t
luaL_ctypeid(struct lua_State *L, const char *ctypename);
 
LUA_API int
luaL_cdef(struct lua_State *L, const char *ctypename);
 
LUA_API void
luaL_pushuint64(struct lua_State *L, uint64_t val);
 
LUA_API void
luaL_pushint64(struct lua_State *L, int64_t val);
 
LUA_API uint64_t
luaL_checkuint64(struct lua_State *L, int idx);
 
LUA_API int64_t
luaL_checkint64(struct lua_State *L, int idx);
 
LUA_API uint64_t
luaL_touint64(struct lua_State *L, int idx);
 
LUA_API int64_t
luaL_toint64(struct lua_State *L, int idx);
 
LUA_API int
luaT_call(lua_State *L, int nargs, int nreturns);
 
int
luaT_dostring(struct lua_State *L, const char *str);
 
LUA_API int
luaT_cpcall(lua_State *L, lua_CFunction func, void *ud);
 
LUA_API lua_State *
luaT_state(void);
 
LUA_API const char *
luaT_tolstring(lua_State *L, int idx, size_t *ssize);
 
LUA_API int
luaL_iscallable(lua_State *L, int idx);
 
LUA_API box_ibuf_t *
luaT_toibuf(struct lua_State *L, int idx);
 
LUA_API void
luaL_pushnull(struct lua_State *L);
 
LUA_API bool
luaL_isnull(struct lua_State *L, int idx);
 
struct error;
 
LUA_API int
luaT_error(lua_State *L);
 
int
luaT_error_at(lua_State *L, int level);
 
LUA_API int
luaT_push_nil_and_error(lua_State *L);
 
void
luaT_pusherror(struct lua_State *L, struct error *e);
enum txn_isolation_level {
        TXN_ISOLATION_DEFAULT,
        TXN_ISOLATION_READ_COMMITTED,
        TXN_ISOLATION_READ_CONFIRMED,
        TXN_ISOLATION_BEST_EFFORT,
        TXN_ISOLATION_LINEARIZABLE,
        txn_isolation_level_MAX,
};
 
API_EXPORT int64_t
box_txn_id(void);
 
API_EXPORT int
box_txn_isolation(void);
 
API_EXPORT bool
box_txn(void);
 
API_EXPORT int
box_txn_begin(void);
 
API_EXPORT int
box_txn_commit(void);
 
API_EXPORT int
box_txn_rollback(void);
 
API_EXPORT void *
box_txn_alloc(size_t size);
 
API_EXPORT int
box_txn_set_timeout(double timeout);
 
API_EXPORT int
box_txn_set_isolation(uint32_t level);
 
API_EXPORT void
box_txn_make_sync(void);
typedef struct tuple_format box_tuple_format_t;
 
box_tuple_format_t *
box_tuple_format_default(void);
 
typedef struct tuple box_tuple_t;
 
int
box_tuple_ref(box_tuple_t *tuple);
 
void
box_tuple_unref(box_tuple_t *tuple);
 
uint32_t
box_tuple_field_count(box_tuple_t *tuple);
 
size_t
box_tuple_bsize(box_tuple_t *tuple);
 
ssize_t
box_tuple_to_buf(box_tuple_t *tuple, char *buf, size_t size);
 
box_tuple_format_t *
box_tuple_format(box_tuple_t *tuple);
 
const char *
box_tuple_field(box_tuple_t *tuple, uint32_t fieldno);
 
API_EXPORT const char *
box_tuple_field_by_path(box_tuple_t *tuple, const char *path,
                        uint32_t path_len, int index_base);
typedef struct tuple_iterator box_tuple_iterator_t;
 
box_tuple_iterator_t *
box_tuple_iterator(box_tuple_t *tuple);
 
void
box_tuple_iterator_free(box_tuple_iterator_t *it);
 
uint32_t
box_tuple_position(box_tuple_iterator_t *it);
 
void
box_tuple_rewind(box_tuple_iterator_t *it);
 
const char *
box_tuple_seek(box_tuple_iterator_t *it, uint32_t fieldno);
 
const char *
box_tuple_next(box_tuple_iterator_t *it);
 
box_tuple_t *
box_tuple_new(box_tuple_format_t *format, const char *data, const char *end);
 
box_tuple_t *
box_tuple_update(box_tuple_t *tuple, const char *expr, const char *expr_end);
 
box_tuple_t *
box_tuple_upsert(box_tuple_t *tuple, const char *expr, const char *expr_end);
 
int
box_tuple_validate(box_tuple_t *tuple, box_tuple_format_t *format);
 
typedef struct key_def box_key_def_t;
 
enum {
        BOX_KEY_PART_DEF_IS_NULLABLE = 1 << 0,
        BOX_KEY_PART_DEF_EXCLUDE_NULL = 1 << 1,
        BOX_KEY_PART_DEF_SORT_ORDER_DESC = 1 << 2,
};
 
enum {
        BOX_KEY_PART_DEF_T_SIZE = 64,
};
 
typedef union PACKED {
        struct {
                uint32_t fieldno;
                uint32_t flags;
                const char *field_type;
                const char *collation;
                const char *path;
        };
        char padding[BOX_KEY_PART_DEF_T_SIZE];
} box_key_part_def_t;
 
API_EXPORT box_key_def_t *
box_key_def_new(uint32_t *fields, uint32_t *types, uint32_t part_count);
 
API_EXPORT void
box_key_part_def_create(box_key_part_def_t *part);
 
API_EXPORT box_key_def_t *
box_key_def_new_v2(box_key_part_def_t *parts, uint32_t part_count);
 
API_EXPORT box_key_def_t *
box_key_def_dup(const box_key_def_t *key_def);
 
API_EXPORT void
box_key_def_delete(box_key_def_t *key_def);
 
API_EXPORT box_key_part_def_t *
box_key_def_dump_parts(const box_key_def_t *key_def, uint32_t *part_count_ptr);
 
API_EXPORT int
box_key_def_validate_tuple(box_key_def_t *key_def, box_tuple_t *tuple);
 
API_EXPORT int
box_tuple_compare(box_tuple_t *tuple_a, box_tuple_t *tuple_b,
                  box_key_def_t *key_def);
API_EXPORT int
box_tuple_compare_with_key(box_tuple_t *tuple_a, const char *key_b,
                           box_key_def_t *key_def);
 
API_EXPORT box_key_def_t *
box_key_def_merge(const box_key_def_t *first, const box_key_def_t *second);
 
API_EXPORT char *
box_key_def_extract_key(box_key_def_t *key_def, box_tuple_t *tuple,
                        int multikey_idx, uint32_t *key_size_ptr);
 
API_EXPORT int
box_key_def_validate_key(const box_key_def_t *key_def, const char *key,
                         uint32_t *key_size_ptr);
 
API_EXPORT int
box_key_def_validate_full_key(const box_key_def_t *key_def, const char *key,
                              uint32_t *key_size_ptr);
 
/*
 * Possible field data types. Can't use STRS/ENUM macros for them,
 * since there is a mismatch between enum name (STRING) and type
 * name literal ("STR"). STR is already used as Objective C type.
 */
enum field_type {
        FIELD_TYPE_ANY = 0,
        FIELD_TYPE_UNSIGNED,
        FIELD_TYPE_STRING,
        FIELD_TYPE_NUMBER,
        FIELD_TYPE_DOUBLE,
        FIELD_TYPE_INTEGER,
        FIELD_TYPE_BOOLEAN,
        FIELD_TYPE_VARBINARY,
        FIELD_TYPE_SCALAR,
        FIELD_TYPE_DECIMAL,
        FIELD_TYPE_UUID,
        FIELD_TYPE_DATETIME,
        FIELD_TYPE_INTERVAL,
        FIELD_TYPE_ARRAY,
        FIELD_TYPE_MAP,
        FIELD_TYPE_INT8,
        FIELD_TYPE_UINT8,
        FIELD_TYPE_INT16,
        FIELD_TYPE_UINT16,
        FIELD_TYPE_INT32,
        FIELD_TYPE_UINT32,
        FIELD_TYPE_INT64,
        FIELD_TYPE_UINT64,
        FIELD_TYPE_FLOAT32,
        FIELD_TYPE_FLOAT64,
        field_type_MAX
};
 
enum on_conflict_action {
        ON_CONFLICT_ACTION_NONE = 0,
        ON_CONFLICT_ACTION_ROLLBACK,
        ON_CONFLICT_ACTION_ABORT,
        ON_CONFLICT_ACTION_FAIL,
        ON_CONFLICT_ACTION_IGNORE,
        ON_CONFLICT_ACTION_REPLACE,
        ON_CONFLICT_ACTION_DEFAULT,
        on_conflict_action_MAX
};
 
box_tuple_format_t *
box_tuple_format_new(struct key_def **keys, uint16_t key_count);
 
void
box_tuple_format_ref(box_tuple_format_t *format);
 
void
box_tuple_format_unref(box_tuple_format_t *format);
 
#define SYSTEM_SPACES(_) /* (name, id, is_sync) */ \
 \
        _(VINYL_DEFERRED_DELETE, 257, false) \
 \
        _(SCHEMA, 272, true) \
 \
        _(COLLATION, 276, true) \
 \
        _(VCOLLATION, 277, true) \
 \
        _(SPACE, 280, true) \
 \
        _(VSPACE, 281, true) \
 \
        _(SEQUENCE, 284, true) \
 \
        _(SEQUENCE_DATA, 285, false) \
 \
        _(VSEQUENCE, 286, true) \
 \
        _(INDEX, 288, true) \
 \
        _(VINDEX, 289, true) \
 \
        _(FUNC, 296, true) \
 \
        _(VFUNC, 297, true) \
 \
        _(USER, 304, true) \
 \
        _(VUSER, 305, true) \
 \
        _(PRIV, 312, true) \
 \
        _(VPRIV, 313, true) \
 \
        _(CLUSTER, 320, true) \
 \
        _(TRIGGER, 328, true) \
 \
        _(TRUNCATE, 330, true) \
 \
        _(SPACE_SEQUENCE, 340, true) \
 \
        _(VSPACE_SEQUENCE, 341, true) \
 \
        _(FK_CONSTRAINT, 356, true) \
 \
        _(CK_CONSTRAINT, 364, true) \
 \
        _(FUNC_INDEX, 372, true) \
 \
        _(SESSION_SETTINGS, 380, true) \
 \
        _(GC_CONSUMERS, 388, false) \
 
#define SYSTEM_SPACE_MEMBER(name, id, ...) BOX_ ## name ## _ID = id,
 
enum {
        BOX_SYSTEM_ID_MIN = 256,
        SYSTEM_SPACES(SYSTEM_SPACE_MEMBER)
        BOX_SYSTEM_ID_MAX = 511,
        BOX_ID_NIL = 2147483647
};
API_EXPORT uint64_t
box_schema_version(void);
 
API_EXPORT bool
box_is_ro(void);
 
API_EXPORT int
box_wait_ro(bool ro, double timeout);
 
API_EXPORT const char *
box_ro_reason(void);
 
/*
 * Opaque structure passed to the stored C procedure
 */
typedef struct box_function_ctx box_function_ctx_t;
 
enum iproto_handler_status {
        IPROTO_HANDLER_OK,
        IPROTO_HANDLER_ERROR,
        IPROTO_HANDLER_FALLBACK,
};
 
typedef enum iproto_handler_status
(*iproto_handler_t)(const char *header, const char *header_end,
                    const char *body, const char *body_end,
                    void *ctx);
 
typedef void
(*iproto_handler_destroy_t)(void *ctx);
 
API_EXPORT int
box_return_tuple(box_function_ctx_t *ctx, box_tuple_t *tuple);
 
API_EXPORT int
box_return_mp(box_function_ctx_t *ctx, const char *mp, const char *mp_end);
 
API_EXPORT uint32_t
box_space_id_by_name(const char *name, uint32_t len);
 
API_EXPORT uint32_t
box_index_id_by_name(uint32_t space_id, const char *name, uint32_t len);
 
API_EXPORT int
box_insert(uint32_t space_id, const char *tuple, const char *tuple_end,
           box_tuple_t **result);
 
API_EXPORT int
box_replace(uint32_t space_id, const char *tuple, const char *tuple_end,
            box_tuple_t **result);
 
API_EXPORT int
box_delete(uint32_t space_id, uint32_t index_id, const char *key,
           const char *key_end, box_tuple_t **result);
 
API_EXPORT int
box_update(uint32_t space_id, uint32_t index_id, const char *key,
           const char *key_end, const char *ops, const char *ops_end,
           int index_base, box_tuple_t **result);
 
API_EXPORT int
box_upsert(uint32_t space_id, uint32_t index_id, const char *tuple,
           const char *tuple_end, const char *ops, const char *ops_end,
           int index_base, box_tuple_t **result);
 
struct ArrowArray;
struct ArrowSchema;
 
API_EXPORT int
box_insert_arrow(uint32_t space_id, struct ArrowArray *array,
                 struct ArrowSchema *schema);
 
API_EXPORT int
box_truncate(uint32_t space_id);
 
API_EXPORT int
box_sequence_next(uint32_t seq_id, int64_t *result);
 
API_EXPORT int
box_sequence_current(uint32_t seq_id, int64_t *result);
 
API_EXPORT int
box_sequence_set(uint32_t seq_id, int64_t value);
 
API_EXPORT int
box_sequence_reset(uint32_t seq_id);
 
API_EXPORT int
box_session_push(const char *data, const char *data_end);
 
API_EXPORT uint64_t
box_session_id(void);
 
API_EXPORT int
box_iproto_send(uint64_t sid,
                const char *header, const char *header_end,
                const char *body, const char *body_end);
 
API_EXPORT int
box_iproto_override(uint32_t req_type, iproto_handler_t handler,
                    iproto_handler_destroy_t destroy, void *ctx);
 
API_EXPORT int64_t
box_info_lsn(void);
 
enum box_slab_info_type {
        BOX_SLAB_INFO_ITEMS_SIZE = 0, 
        BOX_SLAB_INFO_ITEMS_USED = 1, 
        BOX_SLAB_INFO_ARENA_SIZE = 2, 
        BOX_SLAB_INFO_ARENA_USED = 3, 
        BOX_SLAB_INFO_QUOTA_SIZE = 4, 
        BOX_SLAB_INFO_QUOTA_USED = 5, 
};
 
API_EXPORT uint64_t
box_slab_info(enum box_slab_info_type type);
 
typedef struct iterator box_iterator_t;
 
box_iterator_t *
box_index_iterator(uint32_t space_id, uint32_t index_id, int type,
                   const char *key, const char *key_end);
int
box_iterator_next(box_iterator_t *iterator, box_tuple_t **result);
 
void
box_iterator_free(box_iterator_t *iterator);
 
ssize_t
box_index_len(uint32_t space_id, uint32_t index_id);
 
ssize_t
box_index_bsize(uint32_t space_id, uint32_t index_id);
 
int
box_index_quantile(uint32_t space_id, uint32_t index_id, double level,
                   const char *begin_key, const char *begin_key_end,
                   const char *end_key, const char *end_key_end,
                   const char **quantile_key, const char **quantile_key_end);
 
int
box_index_random(uint32_t space_id, uint32_t index_id, uint32_t rnd,
                box_tuple_t **result);
 
int
box_index_get(uint32_t space_id, uint32_t index_id, const char *key,
              const char *key_end, box_tuple_t **result);
 
int
box_index_min(uint32_t space_id, uint32_t index_id, const char *key,
              const char *key_end, box_tuple_t **result);
 
int
box_index_max(uint32_t space_id, uint32_t index_id, const char *key,
              const char *key_end, box_tuple_t **result);
 
ssize_t
box_index_count(uint32_t space_id, uint32_t index_id, int type,
                const char *key, const char *key_end);
 
char *
box_tuple_extract_key(box_tuple_t *tuple, uint32_t space_id,
                      uint32_t index_id, uint32_t *key_size);
 
enum iterator_type {
        /* ITER_EQ must be the first member for request_create  */
        ITER_EQ               =  0, /* key == x ASC order                  */
        ITER_REQ              =  1, /* key == x DESC order                 */
        ITER_ALL              =  2, /* all tuples                          */
        ITER_LT               =  3, /* key <  x                            */
        ITER_LE               =  4, /* key <= x                            */
        ITER_GE               =  5, /* key >= x                            */
        ITER_GT               =  6, /* key >  x                            */
        ITER_BITS_ALL_SET     =  7, /* all bits from x are set in key      */
        ITER_BITS_ANY_SET     =  8, /* at least one x's bit is set         */
        ITER_BITS_ALL_NOT_SET =  9, /* all bits are not set                */
        ITER_OVERLAPS         = 10, /* key overlaps x                      */
        ITER_NEIGHBOR         = 11, /* tuples as they move away from x point */
        ITER_NP               = 12, /* next prefix, ASC order              */
        ITER_PP               = 13, /* previous prefix, DESC order         */
        iterator_type_MAX
};
 
struct error;
typedef struct error box_error_t;
 
const char *
box_error_type(const box_error_t *error);
 
uint32_t
box_error_code(const box_error_t *error);
 
const char *
box_error_message(const box_error_t *error);
 
box_error_t *
box_error_last(void);
 
void
box_error_clear(void);
 
int
box_error_set(const char *file, unsigned line, uint32_t code,
              const char *format, ...);
 
#define box_error_raise(code, format, ...) \
        box_error_set(__FILE__, __LINE__, code, format, ##__VA_ARGS__)
 
API_EXPORT box_tuple_t *
luaT_checktuple(struct lua_State *L, int idx);
 
API_EXPORT void
luaT_pushtuple(struct lua_State *L, box_tuple_t *tuple);
 
API_EXPORT box_tuple_t *
luaT_istuple(struct lua_State *L, int idx);
 
API_EXPORT char *
luaT_tuple_encode(struct lua_State *L, int idx, size_t *tuple_len_ptr);
 
API_EXPORT box_tuple_t *
luaT_tuple_new(struct lua_State *L, int idx, box_tuple_format_t *format);
 
typedef struct box_latch box_latch_t;
 
box_latch_t*
box_latch_new(void);
 
void
box_latch_delete(box_latch_t *latch);
 
void
box_latch_lock(box_latch_t *latch);
 
int
box_latch_trylock(box_latch_t *latch);
 
void
box_latch_unlock(box_latch_t *latch);
 
double
clock_realtime(void);
 
double
clock_monotonic(void);
 
double
clock_process(void);
 
double
clock_thread(void);
 
int64_t
clock_realtime64(void);
 
int64_t
clock_monotonic64(void);
 
int64_t
clock_process64(void);
 
int64_t
clock_thread64(void);
 
/* {{{ decimal structure and constants */
 
struct box_decimal {
        uint64_t internal[8];
};
 
typedef struct box_decimal box_decimal_t;
 
#define BOX_DECIMAL_STRING_BUFFER_SIZE 128
 
/* }}} decimal structure and constants */
 
/* {{{ decimal properties */
 
API_EXPORT int
box_decimal_precision(const box_decimal_t *dec);
 
API_EXPORT int
box_decimal_scale(const box_decimal_t *dec);
 
API_EXPORT bool
box_decimal_is_int(const box_decimal_t *dec);
 
API_EXPORT bool
box_decimal_is_neg(const box_decimal_t *dec);
 
/* }}} decimal properties */
 
/* {{{ decimal constructors */
 
API_EXPORT box_decimal_t *
box_decimal_zero(box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
box_decimal_from_string(box_decimal_t *dec, const char *str);
 
API_EXPORT box_decimal_t *
box_decimal_from_double(box_decimal_t *dec, double d);
 
API_EXPORT box_decimal_t *
box_decimal_from_int64(box_decimal_t *dec, int64_t num);
 
API_EXPORT box_decimal_t *
box_decimal_from_uint64(box_decimal_t *dec, uint64_t num);
 
API_EXPORT box_decimal_t *
box_decimal_copy(box_decimal_t *dest, const box_decimal_t *src);
 
/* }}} decimal constructors */
 
/* {{{ decimal conversions */
 
API_EXPORT void
box_decimal_to_string(const box_decimal_t *dec, char *buf);
 
API_EXPORT const box_decimal_t *
box_decimal_to_int64(const box_decimal_t *dec, int64_t *num);
 
API_EXPORT const box_decimal_t *
box_decimal_to_uint64(const box_decimal_t *dec, uint64_t *num);
 
/* }}} decimal conversions */
 
/* {{{ decimal rounding */
 
API_EXPORT box_decimal_t *
box_decimal_round(box_decimal_t *dec, int scale);
 
API_EXPORT box_decimal_t *
box_decimal_floor(box_decimal_t *dec, int scale);
 
API_EXPORT box_decimal_t *
box_decimal_trim(box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
box_decimal_rescale(box_decimal_t *dec, int scale);
 
/* }}} decimal rounding */
 
/* {{{ decimal arithmetic */
 
API_EXPORT int
box_decimal_compare(const box_decimal_t *lhs, const box_decimal_t *rhs);
 
API_EXPORT box_decimal_t *
box_decimal_abs(box_decimal_t *res, const box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
box_decimal_minus(box_decimal_t *res, const box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
box_decimal_add(box_decimal_t *res, const box_decimal_t *lhs,
                const box_decimal_t *rhs);
 
API_EXPORT box_decimal_t *
box_decimal_sub(box_decimal_t *res, const box_decimal_t *lhs,
                const box_decimal_t *rhs);
 
API_EXPORT box_decimal_t *
box_decimal_mul(box_decimal_t *res, const box_decimal_t *lhs,
                const box_decimal_t *rhs);
 
API_EXPORT box_decimal_t *
box_decimal_div(box_decimal_t *res, const box_decimal_t *lhs,
                const box_decimal_t *rhs);
 
API_EXPORT box_decimal_t *
box_decimal_remainder(box_decimal_t *res, const box_decimal_t *lhs,
                      const box_decimal_t *rhs);
 
/* }}} decimal arithmetic */
 
/* {{{ decimal math functions */
 
API_EXPORT box_decimal_t *
box_decimal_log10(box_decimal_t *res, const box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
box_decimal_ln(box_decimal_t *res, const box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
box_decimal_pow(box_decimal_t *res, const box_decimal_t *lhs,
                const box_decimal_t *rhs);
 
API_EXPORT box_decimal_t *
box_decimal_exp(box_decimal_t *res, const box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
box_decimal_sqrt(box_decimal_t *res, const box_decimal_t *dec);
 
/* }}} decimal math functions */
 
/* {{{ decimal encoding to/decoding from msgpack */
 
uint32_t
box_decimal_mp_sizeof(const box_decimal_t *dec);
 
char *
box_decimal_mp_encode(const box_decimal_t *dec, char *data);
 
box_decimal_t *
box_decimal_mp_decode(box_decimal_t *dec, const char **data);
 
box_decimal_t *
box_decimal_mp_decode_data(box_decimal_t *dec, const char **data,
                           uint32_t size);
 
/* }}} decimal encoding to/decoding from msgpack */
 
API_EXPORT box_decimal_t *
luaT_newdecimal(struct lua_State *L);
 
API_EXPORT box_decimal_t *
luaT_pushdecimal(struct lua_State *L, const box_decimal_t *dec);
 
API_EXPORT box_decimal_t *
luaT_isdecimal(struct lua_State *L, int index);
 
enum box_error_code { ER_UNKNOWN = 0, ER_ILLEGAL_PARAMS = 1, ER_MEMORY_ISSUE = 2, ER_TUPLE_FOUND = 3, ER_UNSUPPORTED = 5, ER_READONLY = 7, ER_INJECTION = 8, ER_CREATE_SPACE = 9, ER_SPACE_EXISTS = 10, ER_DROP_SPACE = 11, ER_ALTER_SPACE = 12, ER_INDEX_TYPE = 13, ER_MODIFY_INDEX = 14, ER_LAST_DROP = 15, ER_TUPLE_FORMAT_LIMIT = 16, ER_DROP_PRIMARY_KEY = 17, ER_KEY_PART_TYPE = 18, ER_EXACT_MATCH = 19, ER_INVALID_MSGPACK = 20, ER_TUPLE_NOT_ARRAY = 22, ER_FIELD_TYPE = 23, ER_INDEX_PART_TYPE_MISMATCH = 24, ER_UPDATE_SPLICE = 25, ER_UPDATE_ARG_TYPE = 26, ER_FORMAT_MISMATCH_INDEX_PART = 27, ER_UNKNOWN_UPDATE_OP = 28, ER_UPDATE_FIELD = 29, ER_FUNCTION_TX_ACTIVE = 30, ER_KEY_PART_COUNT = 31, ER_PROC_LUA = 32, ER_NO_SUCH_PROC = 33, ER_NO_SUCH_TRIGGER = 34, ER_NO_SUCH_INDEX_ID = 35, ER_NO_SUCH_SPACE = 36, ER_NO_SUCH_FIELD_NO = 37, ER_EXACT_FIELD_COUNT = 38, ER_FIELD_MISSING = 39, ER_WAL_IO = 40, ER_MORE_THAN_ONE_TUPLE = 41, ER_ACCESS_DENIED = 42, ER_CREATE_USER = 43, ER_DROP_USER = 44, ER_NO_SUCH_USER = 45, ER_USER_EXISTS = 46, ER_CREDS_MISMATCH = 47, ER_UNKNOWN_REQUEST_TYPE = 48, ER_UNKNOWN_SCHEMA_OBJECT = 49, ER_CREATE_FUNCTION = 50, ER_NO_SUCH_FUNCTION = 51, ER_FUNCTION_EXISTS = 52, ER_BEFORE_REPLACE_RET = 53, ER_MULTISTATEMENT_TRANSACTION = 54, ER_TRIGGER_EXISTS = 55, ER_USER_MAX = 56, ER_NO_SUCH_ENGINE = 57, ER_RELOAD_CFG = 58, ER_CFG = 59, ER_SAVEPOINT_EMPTY_TX = 60, ER_NO_SUCH_SAVEPOINT = 61, ER_UNKNOWN_REPLICA = 62, ER_REPLICASET_UUID_MISMATCH = 63, ER_INVALID_UUID = 64, ER_REPLICASET_UUID_IS_RO = 65, ER_INSTANCE_UUID_MISMATCH = 66, ER_REPLICA_ID_IS_RESERVED = 67, ER_MISSING_REQUEST_FIELD = 69, ER_IDENTIFIER = 70, ER_DROP_FUNCTION = 71, ER_ITERATOR_TYPE = 72, ER_REPLICA_MAX = 73, ER_NO_CONNECTION = 77, ER_TIMEOUT = 78, ER_ACTIVE_TRANSACTION = 79, ER_CURSOR_NO_TRANSACTION = 80, ER_NO_SUCH_ROLE = 82, ER_ROLE_EXISTS = 83, ER_CREATE_ROLE = 84, ER_INDEX_EXISTS = 85, ER_SESSION_CLOSED = 86, ER_ROLE_LOOP = 87, ER_GRANT = 88, ER_PRIV_GRANTED = 89, ER_ROLE_GRANTED = 90, ER_PRIV_NOT_GRANTED = 91, ER_ROLE_NOT_GRANTED = 92, ER_MISSING_SNAPSHOT = 93, ER_CANT_UPDATE_PRIMARY_KEY = 94, ER_UPDATE_INTEGER_OVERFLOW = 95, ER_GUEST_USER_PASSWORD = 96, ER_TRANSACTION_CONFLICT = 97, ER_UNSUPPORTED_PRIV = 98, ER_LOAD_FUNCTION = 99, ER_FUNCTION_LANGUAGE = 100, ER_RTREE_RECT = 101, ER_PROC_C = 102, ER_PROTOCOL = 104, ER_WRONG_INDEX_RECORD = 106, ER_WRONG_INDEX_PARTS = 107, ER_WRONG_INDEX_OPTIONS = 108, ER_WRONG_SCHEMA_VERSION = 109, ER_MEMTX_MAX_TUPLE_SIZE = 110, ER_WRONG_SPACE_OPTIONS = 111, ER_UNSUPPORTED_INDEX_FEATURE = 112, ER_VIEW_IS_RO = 113, ER_NO_TRANSACTION = 114, ER_SYSTEM = 115, ER_LOADING = 116, ER_CONNECTION_TO_SELF = 117, ER_COMPRESSION = 119, ER_CHECKPOINT_IN_PROGRESS = 120, ER_SUB_STMT_MAX = 121, ER_COMMIT_IN_SUB_STMT = 122, ER_ROLLBACK_IN_SUB_STMT = 123, ER_DECOMPRESSION = 124, ER_INVALID_XLOG_TYPE = 125, ER_ALREADY_RUNNING = 126, ER_INDEX_FIELD_COUNT_LIMIT = 127, ER_LOCAL_INSTANCE_ID_IS_READ_ONLY = 128, ER_BACKUP_IN_PROGRESS = 129, ER_READ_VIEW_ABORTED = 130, ER_INVALID_INDEX_FILE = 131, ER_INVALID_RUN_FILE = 132, ER_INVALID_VYLOG_FILE = 133, ER_CASCADE_ROLLBACK = 134, ER_VY_QUOTA_TIMEOUT = 135, ER_PARTIAL_KEY = 136, ER_TRUNCATE_SYSTEM_SPACE = 137, ER_LOAD_MODULE = 138, ER_VINYL_MAX_TUPLE_SIZE = 139, ER_WRONG_DD_VERSION = 140, ER_WRONG_SPACE_FORMAT = 141, ER_CREATE_SEQUENCE = 142, ER_ALTER_SEQUENCE = 143, ER_DROP_SEQUENCE = 144, ER_NO_SUCH_SEQUENCE = 145, ER_SEQUENCE_EXISTS = 146, ER_SEQUENCE_OVERFLOW = 147, ER_NO_SUCH_INDEX_NAME = 148, ER_SPACE_FIELD_IS_DUPLICATE = 149, ER_CANT_CREATE_COLLATION = 150, ER_WRONG_COLLATION_OPTIONS = 151, ER_NULLABLE_PRIMARY = 152, ER_NO_SUCH_FIELD_NAME_IN_SPACE = 153, ER_TRANSACTION_YIELD = 154, ER_NO_SUCH_GROUP = 155, ER_SQL_BIND_TYPE = 157, ER_SQL_BIND_PARAMETER_MAX = 158, ER_SQL_EXECUTE = 159, ER_UPDATE_DECIMAL_OVERFLOW = 160, ER_SQL_BIND_NOT_FOUND = 161, ER_ACTION_MISMATCH = 162, ER_VIEW_MISSING_SQL = 163, ER_FOREIGN_KEY_CONSTRAINT = 164, ER_NO_SUCH_MODULE = 165, ER_NO_SUCH_COLLATION = 166, ER_CREATE_FK_CONSTRAINT = 167, ER_NO_SUCH_CONSTRAINT = 169, ER_CONSTRAINT_EXISTS = 170, ER_SQL_TYPE_MISMATCH = 171, ER_ROWID_OVERFLOW = 172, ER_DROP_COLLATION = 173, ER_ILLEGAL_COLLATION_MIX = 174, ER_SQL_NO_SUCH_PRAGMA = 175, ER_SQL_CANT_RESOLVE_FIELD = 176, ER_INDEX_EXISTS_IN_SPACE = 177, ER_INCONSISTENT_TYPES = 178, ER_SQL_SYNTAX_WITH_POS = 179, ER_SQL_STACK_OVERFLOW = 180, ER_SQL_SELECT_WILDCARD = 181, ER_SQL_STATEMENT_EMPTY = 182, ER_SQL_KEYWORD_IS_RESERVED = 183, ER_SQL_SYNTAX_NEAR_TOKEN = 184, ER_SQL_UNKNOWN_TOKEN = 185, ER_SQL_PARSER_GENERIC = 186, ER_SQL_COLUMN_COUNT_MAX = 188, ER_HEX_LITERAL_MAX = 189, ER_INT_LITERAL_MAX = 190, ER_SQL_PARSER_LIMIT = 191, ER_INDEX_DEF_UNSUPPORTED = 192, ER_MULTIKEY_INDEX_MISMATCH = 194, ER_CREATE_CK_CONSTRAINT = 195, ER_SQL_COLUMN_COUNT = 197, ER_FUNC_INDEX_FUNC = 198, ER_FUNC_INDEX_FORMAT = 199, ER_FUNC_INDEX_PARTS = 200, ER_NO_SUCH_FIELD_NAME = 201, ER_FUNC_WRONG_ARG_COUNT = 202, ER_BOOTSTRAP_READONLY = 203, ER_SQL_FUNC_WRONG_RET_COUNT = 204, ER_FUNC_INVALID_RETURN_TYPE = 205, ER_SQL_PARSER_GENERIC_WITH_POS = 206, ER_REPLICA_NOT_ANON = 207, ER_CANNOT_REGISTER = 208, ER_SESSION_SETTING_INVALID_VALUE = 209, ER_SQL_PREPARE = 210, ER_WRONG_QUERY_ID = 211, ER_SEQUENCE_NOT_STARTED = 212, ER_NO_SUCH_SESSION_SETTING = 213, ER_UNCOMMITTED_FOREIGN_SYNC_TXNS = 214, ER_SYNC_QUORUM_TIMEOUT = 216, ER_SYNC_ROLLBACK = 217, ER_TUPLE_METADATA_IS_TOO_BIG = 218, ER_XLOG_GAP = 219, ER_TOO_EARLY_SUBSCRIBE = 220, ER_SQL_CANT_ADD_AUTOINC = 221, ER_QUORUM_WAIT = 222, ER_INTERFERING_PROMOTE = 223, ER_ELECTION_DISABLED = 224, ER_TXN_ROLLBACK = 225, ER_NOT_LEADER = 226, ER_SYNC_QUEUE_UNCLAIMED = 227, ER_SYNC_QUEUE_FOREIGN = 228, ER_UNABLE_TO_PROCESS_IN_STREAM = 229, ER_UNABLE_TO_PROCESS_OUT_OF_STREAM = 230, ER_TRANSACTION_TIMEOUT = 231, ER_ACTIVE_TIMER = 232, ER_TUPLE_FIELD_COUNT_LIMIT = 233, ER_CREATE_CONSTRAINT = 234, ER_FIELD_CONSTRAINT_FAILED = 235, ER_TUPLE_CONSTRAINT_FAILED = 236, ER_CREATE_FOREIGN_KEY = 237, ER_FOREIGN_KEY_INTEGRITY = 238, ER_FIELD_FOREIGN_KEY_FAILED = 239, ER_COMPLEX_FOREIGN_KEY_FAILED = 240, ER_WRONG_SPACE_UPGRADE_OPTIONS = 241, ER_NO_ELECTION_QUORUM = 242, ER_SSL = 243, ER_SPLIT_BRAIN = 244, ER_OLD_TERM = 245, ER_INTERFERING_ELECTIONS = 246, ER_ITERATOR_POSITION = 247, ER_DEFAULT_VALUE_TYPE = 248, ER_UNKNOWN_AUTH_METHOD = 249, ER_INVALID_AUTH_DATA = 250, ER_INVALID_AUTH_REQUEST = 251, ER_WEAK_PASSWORD = 252, ER_OLD_PASSWORD = 253, ER_NO_SUCH_SESSION = 254, ER_WRONG_SESSION_TYPE = 255, ER_PASSWORD_EXPIRED = 256, ER_AUTH_DELAY = 257, ER_AUTH_REQUIRED = 258, ER_SQL_SEQ_SCAN = 259, ER_NO_SUCH_EVENT = 260, ER_BOOTSTRAP_NOT_UNANIMOUS = 261, ER_CANT_CHECK_BOOTSTRAP_LEADER = 262, ER_BOOTSTRAP_CONNECTION_NOT_TO_ALL = 263, ER_NIL_UUID = 264, ER_WRONG_FUNCTION_OPTIONS = 265, ER_MISSING_SYSTEM_SPACES = 266, ER_CLUSTER_NAME_MISMATCH = 267, ER_REPLICASET_NAME_MISMATCH = 268, ER_INSTANCE_NAME_DUPLICATE = 269, ER_INSTANCE_NAME_MISMATCH = 270, ER_SCHEMA_NEEDS_UPGRADE = 271, ER_SCHEMA_UPGRADE_IN_PROGRESS = 272, ER_DEPRECATED = 273, ER_UNCONFIGURED = 274, ER_CREATE_DEFAULT_FUNC = 275, ER_DEFAULT_FUNC_FAILED = 276, ER_INVALID_DEC = 277, ER_IN_ANOTHER_PROMOTE = 278, ER_SHUTDOWN = 279, ER_FIELD_VALUE_OUT_OF_RANGE = 280, ER_REPLICASET_NOT_FOUND = 281, ER_REPLICASET_NO_WRITABLE = 282, ER_REPLICASET_MORE_THAN_ONE_WRITABLE = 283, ER_TXN_COMMIT = 284, ER_READ_VIEW_BUSY = 285, ER_READ_VIEW_CLOSED = 286, ER_WAL_QUEUE_FULL = 287, ER_INVALID_VCLOCK = 288, ER_SYNC_QUEUE_FULL = 289, ER_KEY_PART_VALUE_OUT_OF_RANGE = 290, ER_REPLICA_GC = 291, ER_ALIEN_ENGINE = 292, ER_MVCC_UNAVAILABLE = 293, box_error_code_MAX };
#if defined(__cplusplus)
} /* extern "C" */
#endif /* defined(__cplusplus) */
 
#endif /* TARANTOOL_MODULE_H_INCLUDED */